eslint-plugin-code-style 1.11.7 → 1.14.0

package/index.js

@@ -1709,9 +1709,16 @@ const commentFormat = {
                         const isSingleLine = !value.includes("\n");
 
                         if (isSingleLine) {
-                            // Single-line block comment should use // syntax
+                            // Skip ESLint directive comments (eslint-disable, eslint-enable, etc.)
                             const trimmedValue = value.trim();
+                            const isEslintDirective = /^eslint-disable|^eslint-enable|^eslint-disable-next-line|^eslint-disable-line/.test(trimmedValue);
+
+                            if (isEslintDirective) {
+                                // Allow /* */ syntax for ESLint directives
+                                return;
+                            }
 
+                            // Single-line block comment should use // syntax
                             context.report({
                                 fix: (fixer) => fixer.replaceText(comment, `// ${trimmedValue}`),
                                 loc: comment.loc,
@@ -2108,6 +2115,7 @@ const functionNamingConvention = {
             "build", "make", "generate", "compute", "calculate", "process", "execute", "run",
             "evaluate", "analyze", "measure", "benchmark", "profile", "optimize",
             "count", "sum", "avg", "min", "max", "clamp", "round", "floor", "ceil", "abs",
+            "increment", "decrement", "multiply", "divide", "mod", "negate",
             // Invocation
             "apply", "call", "invoke", "trigger", "fire", "dispatch", "emit", "raise", "signal",
             // Auth
@@ -2209,6 +2217,23 @@ const functionNamingConvention = {
                 if (node.parent && node.parent.type === "VariableDeclarator" && node.parent.id) {
                     name = node.parent.id.name;
                     identifierNode = node.parent.id;
+                } else if (node.parent && node.parent.type === "CallExpression") {
+                    // Check for useCallback wrapped functions: const login = useCallback(() => {...}, [])
+                    // Note: Skip useMemo - it returns computed values, not action functions
+                    const callExpr = node.parent;
+                    const callee = callExpr.callee;
+
+                    // Only check useCallback (not useMemo, useEffect, etc.)
+                    if (callee && callee.type === "Identifier" && callee.name === "useCallback") {
+                        // Check if the function is the first argument to useCallback
+                        if (callExpr.arguments && callExpr.arguments[0] === node) {
+                            // Check if the CallExpression is the init of a VariableDeclarator
+                            if (callExpr.parent && callExpr.parent.type === "VariableDeclarator" && callExpr.parent.id) {
+                                name = callExpr.parent.id.name;
+                                identifierNode = callExpr.parent.id;
+                            }
+                        }
+                    }
                 }
             }
 
@@ -2314,15 +2339,14 @@ const functionNamingConvention = {
             if (!hasVerbPrefix && !hasHandlerSuffix) {
                 context.report({
                     message: `Function "${name}" should start with a verb (get, set, fetch, etc.) AND end with "Handler" (e.g., getDataHandler, clickHandler)`,
-                    node: node.id || node.parent.id,
+                    node: identifierNode,
                 });
             } else if (!hasVerbPrefix) {
                 context.report({
                     message: `Function "${name}" should start with a verb (get, set, fetch, handle, click, submit, etc.)`,
-                    node: node.id || node.parent.id,
+                    node: identifierNode,
                 });
             } else if (!hasHandlerSuffix) {
-                const identifierNode = node.id || node.parent.id;
                 const newName = `${name}Handler`;
 
                 context.report({
@@ -3305,6 +3329,249 @@ const hookDepsPerLine = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: useState Naming Convention
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   When useState holds a boolean value, the state variable name
+ *   should start with a valid boolean prefix (is, has, with, without).
+ *
+ * ✓ Good:
+ *   const [isLoading, setIsLoading] = useState(false);
+ *   const [hasError, setHasError] = useState(false);
+ *   const [isAuthenticated, setIsAuthenticated] = useState<boolean>(() => checkAuth());
+ *
+ * ✗ Bad:
+ *   const [loading, setLoading] = useState(false);
+ *   const [authenticated, setAuthenticated] = useState<boolean>(true);
+ *   const [error, setError] = useState<boolean>(false);
+ */
+const useStateNamingConvention = {
+    create(context) {
+        const options = context.options[0] || {};
+
+        // Boolean prefixes handling (same pattern as prop-naming-convention)
+        const defaultBooleanPrefixes = ["is", "has", "with", "without"];
+        const booleanPrefixes = options.booleanPrefixes || [
+            ...defaultBooleanPrefixes,
+            ...(options.extendBooleanPrefixes || []),
+        ];
+
+        const allowPastVerbBoolean = options.allowPastVerbBoolean || false;
+        const allowContinuousVerbBoolean = options.allowContinuousVerbBoolean || false;
+
+        // Pattern to check if name starts with valid boolean prefix followed by capital letter
+        const booleanPrefixPattern = new RegExp(`^(${booleanPrefixes.join("|")})[A-Z]`);
+
+        // Pattern for past verb booleans (ends with -ed: disabled, selected, checked, etc.)
+        const pastVerbPattern = /^[a-z]+ed$/;
+
+        // Pattern for continuous verb booleans (ends with -ing: loading, saving, etc.)
+        const continuousVerbPattern = /^[a-z]+ing$/;
+
+        // Words that suggest "has" prefix instead of "is"
+        const hasKeywords = [
+            "children", "content", "data", "error", "errors", "items",
+            "permission", "permissions", "value", "values",
+        ];
+
+        // Convert name to appropriate boolean prefix
+        const toBooleanNameHandler = (name) => {
+            const lowerName = name.toLowerCase();
+            const prefix = hasKeywords.some((k) => lowerName.includes(k)) ? "has" : "is";
+
+            return prefix + name[0].toUpperCase() + name.slice(1);
+        };
+
+        // Convert setter name based on new state name
+        const toSetterNameHandler = (stateName) => "set" + stateName[0].toUpperCase() + stateName.slice(1);
+
+        // Check if name is a valid boolean state name
+        const isValidBooleanNameHandler = (name) => {
+            // Starts with valid prefix
+            if (booleanPrefixPattern.test(name)) return true;
+
+            // Allow past verb booleans if option is enabled (disabled, selected, checked, etc.)
+            if (allowPastVerbBoolean && pastVerbPattern.test(name)) return true;
+
+            // Allow continuous verb booleans if option is enabled (loading, saving, etc.)
+            if (allowContinuousVerbBoolean && continuousVerbPattern.test(name)) return true;
+
+            return false;
+        };
+
+        // Check if the useState initial value indicates boolean
+        const isBooleanValueHandler = (arg) => {
+            if (!arg) return false;
+
+            // Direct boolean literal: useState(false) or useState(true)
+            if (arg.type === "Literal" && typeof arg.value === "boolean") return true;
+
+            // Arrow function returning boolean: useState(() => checkAuth())
+            // We can't reliably determine return type, so skip these unless typed
+            return false;
+        };
+
+        // Check if the useState has boolean type annotation
+        const hasBooleanTypeAnnotationHandler = (node) => {
+            // useState<boolean>(...) or useState<boolean | null>(...)
+            if (node.typeParameters && node.typeParameters.params && node.typeParameters.params.length > 0) {
+                const typeParam = node.typeParameters.params[0];
+
+                if (typeParam.type === "TSBooleanKeyword") return true;
+
+                // Check union types: boolean | null, boolean | undefined
+                if (typeParam.type === "TSUnionType") {
+                    return typeParam.types.some((t) => t.type === "TSBooleanKeyword");
+                }
+            }
+
+            return false;
+        };
+
+        return {
+            CallExpression(node) {
+                // Check if it's a useState call
+                if (node.callee.type !== "Identifier" || node.callee.name !== "useState") return;
+
+                // Check if it's in a variable declaration with array destructuring
+                if (!node.parent || node.parent.type !== "VariableDeclarator") return;
+                if (!node.parent.id || node.parent.id.type !== "ArrayPattern") return;
+
+                const arrayPattern = node.parent.id;
+
+                // Must have at least the state variable (first element)
+                if (!arrayPattern.elements || arrayPattern.elements.length < 1) return;
+
+                const stateElement = arrayPattern.elements[0];
+                const setterElement = arrayPattern.elements[1];
+
+                if (!stateElement || stateElement.type !== "Identifier") return;
+
+                const stateName = stateElement.name;
+
+                // Check if this is a boolean useState
+                const isBooleanState = (node.arguments && node.arguments.length > 0 && isBooleanValueHandler(node.arguments[0]))
+                    || hasBooleanTypeAnnotationHandler(node);
+
+                if (!isBooleanState) return;
+
+                // Check if state name follows boolean naming convention
+                if (isValidBooleanNameHandler(stateName)) return;
+
+                const suggestedStateName = toBooleanNameHandler(stateName);
+                const suggestedSetterName = toSetterNameHandler(suggestedStateName);
+
+                context.report({
+                    fix(fixer) {
+                        const fixes = [];
+                        const scope = context.sourceCode
+                            ? context.sourceCode.getScope(node)
+                            : context.getScope();
+
+                        // Helper to find variable in scope
+                        const findVariableHandler = (s, name) => {
+                            const v = s.variables.find((variable) => variable.name === name);
+
+                            if (v) return v;
+                            if (s.upper) return findVariableHandler(s.upper, name);
+
+                            return null;
+                        };
+
+                        // Fix state variable
+                        const stateVar = findVariableHandler(scope, stateName);
+                        const stateFixedRanges = new Set();
+
+                        // Fix definition first
+                        const stateDefRangeKey = `${stateElement.range[0]}-${stateElement.range[1]}`;
+
+                        stateFixedRanges.add(stateDefRangeKey);
+                        fixes.push(fixer.replaceText(stateElement, suggestedStateName));
+
+                        // Fix all usages
+                        if (stateVar) {
+                            stateVar.references.forEach((ref) => {
+                                const rangeKey = `${ref.identifier.range[0]}-${ref.identifier.range[1]}`;
+
+                                if (!stateFixedRanges.has(rangeKey)) {
+                                    stateFixedRanges.add(rangeKey);
+                                    fixes.push(fixer.replaceText(ref.identifier, suggestedStateName));
+                                }
+                            });
+                        }
+
+                        // Fix setter if exists
+                        if (setterElement && setterElement.type === "Identifier") {
+                            const setterName = setterElement.name;
+                            const setterVar = findVariableHandler(scope, setterName);
+                            const setterFixedRanges = new Set();
+
+                            // Fix definition first
+                            const setterDefRangeKey = `${setterElement.range[0]}-${setterElement.range[1]}`;
+
+                            setterFixedRanges.add(setterDefRangeKey);
+                            fixes.push(fixer.replaceText(setterElement, suggestedSetterName));
+
+                            // Fix all usages
+                            if (setterVar) {
+                                setterVar.references.forEach((ref) => {
+                                    const rangeKey = `${ref.identifier.range[0]}-${ref.identifier.range[1]}`;
+
+                                    if (!setterFixedRanges.has(rangeKey)) {
+                                        setterFixedRanges.add(rangeKey);
+                                        fixes.push(fixer.replaceText(ref.identifier, suggestedSetterName));
+                                    }
+                                });
+                            }
+                        }
+
+                        return fixes;
+                    },
+                    message: `Boolean state "${stateName}" should start with a valid prefix (${booleanPrefixes.join(", ")}). Use "${suggestedStateName}" instead.`,
+                    node: stateElement,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce boolean useState variables to start with is/has/with/without prefix" },
+        fixable: "code",
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    allowContinuousVerbBoolean: {
+                        default: false,
+                        description: "Allow continuous verb boolean state without prefix (e.g., loading, saving)",
+                        type: "boolean",
+                    },
+                    allowPastVerbBoolean: {
+                        default: false,
+                        description: "Allow past verb boolean state without prefix (e.g., disabled, selected)",
+                        type: "boolean",
+                    },
+                    booleanPrefixes: {
+                        description: "Replace default boolean prefixes entirely",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    extendBooleanPrefixes: {
+                        default: [],
+                        description: "Add additional prefixes to the defaults (is, has, with, without)",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "suggestion",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: If Statement Format
@@ -7818,16 +8085,6 @@ const jsxChildrenOnNewLine = {
                     message: "JSX child should be on its own line",
                     node: firstChild,
                 });
-            } else if (openingTag.loc.end.line < firstChild.loc.start.line - 1) {
-                // Check for extra blank lines after opening tag (more than 1 newline)
-                context.report({
-                    fix: (fixer) => fixer.replaceTextRange(
-                        [openingTag.range[1], firstChild.range[0]],
-                        "\n" + childIndent,
-                    ),
-                    message: "Remove blank lines after opening tag",
-                    node: firstChild,
-                });
             }
 
             // Check if closing tag is on same line as last child
@@ -8560,134 +8817,583 @@ const jsxPropNamingConvention = {
 
 /**
  * ───────────────────────────────────────────────────────────────
- * Rule: JSX Simple Element On One Line
+ * Rule: Prop Naming Convention
  * ───────────────────────────────────────────────────────────────
  *
  * Description:
- *   Simple JSX elements with only a single text or expression
- *   child should be collapsed onto a single line.
+ *   Enforces naming conventions for boolean and callback/method props:
+ *   - Boolean props must start with: is, has, with, without (followed by capital letter)
+ *   - Callback props must start with: on (followed by capital letter)
+ *
+ *   Applies to: interfaces, type aliases, inline types, and nested object types
+ *   at any nesting level. Does NOT apply to JSX element attributes.
+ *
+ * Options:
+ *   { booleanPrefixes: ["is", "has"] } - Replace default prefixes entirely
+ *   { extendBooleanPrefixes: ["should", "can"] } - Add to default prefixes
+ *   { allowPastVerbBoolean: false } - Allow past verb booleans (disabled, selected, checked, opened, etc.)
+ *   { allowContinuousVerbBoolean: false } - Allow continuous verb booleans (loading, saving, closing, etc.)
+ *   { callbackPrefix: "on" } - Required prefix for callbacks
+ *   { allowActionSuffix: false } - Allow "xxxAction" pattern for callbacks
  *
  * ✓ Good:
- *   <Button>{buttonLinkText}</Button>
- *   <Title>Hello</Title>
+ *   interface PropsInterface {
+ *       isLoading: boolean,
+ *       hasError: boolean,
+ *       onClick: () => void,
+ *       onSubmit: (data: Data) => void,
+ *       config: {
+ *           isEnabled: boolean,
+ *           onToggle: () => void,
+ *       },
+ *   }
  *
  * ✗ Bad:
- *   <Button>
- *       {buttonLinkText}
- *   </Button>
+ *   interface PropsInterface {
+ *       loading: boolean,      // Should be isLoading
+ *       error: boolean,        // Should be hasError
+ *       click: () => void,     // Should be onClick
+ *       handleSubmit: () => void, // Should be onSubmit
+ *       config: {
+ *           enabled: boolean,  // Should be isEnabled (nested)
+ *           toggle: () => void, // Should be onToggle (nested)
+ *       },
+ *   }
+ *
+ * ✓ Good (with allowPastVerbBoolean: true):
+ *   interface PropsInterface {
+ *       disabled: boolean,     // Past verb - allowed
+ *       selected: boolean,     // Past verb - allowed
+ *       checked: boolean,      // Past verb - allowed
+ *   }
+ *
+ * ✓ Good (with allowContinuousVerbBoolean: true):
+ *   interface PropsInterface {
+ *       loading: boolean,      // Continuous verb - allowed
+ *       saving: boolean,       // Continuous verb - allowed
+ *       fetching: boolean,     // Continuous verb - allowed
+ *   }
  */
-const jsxSimpleElementOneLine = {
+const propNamingConvention = {
     create(context) {
-        const sourceCode = context.sourceCode || context.getSourceCode();
+        const options = context.options[0] || {};
 
-        // Check if an argument is simple (identifier, literal, or simple member expression)
-        const isSimpleArgHandler = (node) => {
-            if (!node) return false;
-            if (node.type === "Identifier") return true;
-            if (node.type === "Literal") return true;
-            if (node.type === "MemberExpression") {
-                return node.object.type === "Identifier" && node.property.type === "Identifier";
-            }
+        // Boolean prefixes handling (like module-index-exports pattern)
+        const defaultBooleanPrefixes = ["is", "has", "with", "without"];
+        const booleanPrefixes = options.booleanPrefixes || [
+            ...defaultBooleanPrefixes,
+            ...(options.extendBooleanPrefixes || []),
+        ];
 
-            return false;
+        const allowPastVerbBoolean = options.allowPastVerbBoolean || false;
+        const allowContinuousVerbBoolean = options.allowContinuousVerbBoolean || false;
+        const callbackPrefix = options.callbackPrefix || "on";
+        const allowActionSuffix = options.allowActionSuffix || false;
+
+        // Pattern to check if name starts with valid boolean prefix followed by capital letter
+        const booleanPrefixPattern = new RegExp(`^(${booleanPrefixes.join("|")})[A-Z]`);
+
+        // Pattern for callback prefix
+        const callbackPrefixPattern = new RegExp(`^${callbackPrefix}[A-Z]`);
+
+        // Pattern for past verb booleans (ends with -ed: disabled, selected, checked, opened, closed, etc.)
+        const pastVerbPattern = /^[a-z]+ed$/;
+
+        // Pattern for continuous verb booleans (ends with -ing: loading, saving, closing, etc.)
+        const continuousVerbPattern = /^[a-z]+ing$/;
+
+        // Words that suggest "has" prefix instead of "is"
+        const hasKeywords = [
+            "children", "content", "data", "error", "errors", "items",
+            "permission", "permissions", "value", "values",
+        ];
+
+        // Convert name to appropriate boolean prefix
+        const toBooleanNameHandler = (name) => {
+            const lowerName = name.toLowerCase();
+            const prefix = hasKeywords.some((k) => lowerName.includes(k)) ? "has" : "is";
+
+            return prefix + name[0].toUpperCase() + name.slice(1);
         };
 
-        // Check if an expression is simple (identifier, literal, member expression, or simple function call)
-        const isSimpleExpressionHandler = (node) => {
-            if (!node) return false;
+        // Convert name to callback format (add "on" prefix)
+        const toCallbackNameHandler = (name) => {
+            // Handle "handleXxx" pattern -> "onXxx"
+            if (name.startsWith("handle") && name.length > 6) {
+                const rest = name.slice(6);
 
-            if (node.type === "Identifier") return true;
-            if (node.type === "Literal") return true;
-            if (node.type === "MemberExpression") {
-                // Allow simple member expressions like obj.prop
-                return node.object.type === "Identifier" && node.property.type === "Identifier";
+                return callbackPrefix + rest[0].toUpperCase() + rest.slice(1);
             }
 
-            // Allow simple function calls with 0-1 simple arguments
-            if (node.type === "CallExpression") {
-                // Check callee is simple (identifier or member expression)
-                const { callee } = node;
-                const isSimpleCallee = callee.type === "Identifier" ||
-                    (callee.type === "MemberExpression" &&
-                     callee.object.type === "Identifier" &&
-                     callee.property.type === "Identifier");
+            // Handle "xxxHandler" pattern -> "onXxx"
+            if (name.endsWith("Handler") && name.length > 7) {
+                const rest = name.slice(0, -7);
 
-                if (!isSimpleCallee) return false;
+                return callbackPrefix + rest[0].toUpperCase() + rest.slice(1);
+            }
 
-                // Allow 0-1 arguments, and the argument must be simple
-                if (node.arguments.length === 0) return true;
-                if (node.arguments.length === 1 && isSimpleArgHandler(node.arguments[0])) return true;
+            // Simple case: just add "on" prefix
+            return callbackPrefix + name[0].toUpperCase() + name.slice(1);
+        };
 
-                return false;
+        // Check if type annotation indicates boolean
+        const isBooleanTypeHandler = (typeAnnotation) => {
+            if (!typeAnnotation) return false;
+            const type = typeAnnotation.typeAnnotation;
+
+            if (!type) return false;
+            if (type.type === "TSBooleanKeyword") return true;
+            // Check for union with boolean (e.g., boolean | undefined)
+            if (type.type === "TSUnionType") {
+                return type.types.some((t) => t.type === "TSBooleanKeyword");
             }
 
             return false;
         };
 
-        // Check if child is simple (text or simple expression)
-        const isSimpleChildHandler = (child) => {
-            if (child.type === "JSXText") {
-                return child.value.trim().length > 0;
+        // React event handler type names
+        const reactEventHandlerTypes = [
+            "MouseEventHandler",
+            "ChangeEventHandler",
+            "FormEventHandler",
+            "KeyboardEventHandler",
+            "FocusEventHandler",
+            "TouchEventHandler",
+            "PointerEventHandler",
+            "DragEventHandler",
+            "WheelEventHandler",
+            "AnimationEventHandler",
+            "TransitionEventHandler",
+            "ClipboardEventHandler",
+            "CompositionEventHandler",
+            "UIEventHandler",
+            "ScrollEventHandler",
+            "EventHandler",
+        ];
+
+        // Check if type annotation indicates function/callback
+        const isCallbackTypeHandler = (typeAnnotation) => {
+            if (!typeAnnotation) return false;
+            const type = typeAnnotation.typeAnnotation;
+
+            if (!type) return false;
+            if (type.type === "TSFunctionType") return true;
+            if (type.type === "TSTypeReference") {
+                const typeName = type.typeName?.name;
+
+                // Check for Function, VoidFunction, or React event handler types
+                if (typeName === "Function" || typeName === "VoidFunction") return true;
+                if (reactEventHandlerTypes.includes(typeName)) return true;
             }
 
-            if (child.type === "JSXExpressionContainer") {
-                return isSimpleExpressionHandler(child.expression);
+            // Check for union with function (e.g., (() => void) | undefined)
+            if (type.type === "TSUnionType") {
+                return type.types.some((t) =>
+                    t.type === "TSFunctionType" ||
+                    (t.type === "TSTypeReference" && (
+                        t.typeName?.name === "Function" ||
+                        t.typeName?.name === "VoidFunction" ||
+                        reactEventHandlerTypes.includes(t.typeName?.name)
+                    )));
             }
 
             return false;
         };
 
-        return {
-            JSXElement(node) {
-                const openingTag = node.openingElement;
-                const closingTag = node.closingElement;
+        // Check if type annotation is a nested object type (TSTypeLiteral)
+        const isNestedObjectTypeHandler = (typeAnnotation) => {
+            if (!typeAnnotation) return false;
+            const type = typeAnnotation.typeAnnotation;
 
-                // Skip self-closing elements
-                if (!closingTag) return;
+            if (!type) return false;
 
-                // Check if element is multiline
-                if (openingTag.loc.end.line === closingTag.loc.start.line) return;
+            return type.type === "TSTypeLiteral";
+        };
 
-                const { children } = node;
+        // Check if name is a valid boolean prop name
+        const isValidBooleanNameHandler = (name) => {
+            // Starts with valid prefix
+            if (booleanPrefixPattern.test(name)) return true;
 
-                // Filter out whitespace-only text children
-                const significantChildren = children.filter((child) => {
-                    if (child.type === "JSXText") {
-                        return child.value.trim() !== "";
-                    }
+            // Allow past verb booleans if option is enabled (disabled, selected, checked, etc.)
+            if (allowPastVerbBoolean && pastVerbPattern.test(name)) return true;
 
-                    return true;
-                });
+            // Allow continuous verb booleans if option is enabled (loading, saving, etc.)
+            if (allowContinuousVerbBoolean && continuousVerbPattern.test(name)) return true;
 
-                // Must have exactly one simple child
-                if (significantChildren.length !== 1) return;
+            return false;
+        };
 
-                const child = significantChildren[0];
+        // Check if name is a valid callback prop name
+        const isValidCallbackNameHandler = (name) => {
+            // Starts with "on" prefix
+            if (callbackPrefixPattern.test(name)) return true;
 
-                if (!isSimpleChildHandler(child)) return;
+            // Allow "xxxAction" suffix if option is enabled
+            if (allowActionSuffix && name.endsWith("Action") && name.length > 6) return true;
 
-                // Check if opening tag itself is simple (single line, not too many attributes)
-                if (openingTag.loc.start.line !== openingTag.loc.end.line) return;
+            return false;
+        };
 
-                // Get the text content
-                const openingText = sourceCode.getText(openingTag);
-                const childText = child.type === "JSXText" ? child.value.trim() : sourceCode.getText(child);
-                const closingText = sourceCode.getText(closingTag);
+        // Find the containing function for inline type annotations
+        const findContainingFunctionHandler = (node) => {
+            let current = node;
 
-                context.report({
-                    fix: (fixer) => fixer.replaceText(
-                        node,
-                        `${openingText}${childText}${closingText}`,
-                    ),
-                    message: "Simple JSX element with single text/expression child should be on one line",
-                    node,
-                });
-            },
-        };
-    },
-    meta: {
-        docs: { description: "Simple JSX elements with only text/expression children should be on one line" },
-        fixable: "whitespace",
+            while (current) {
+                if (current.type === "ArrowFunctionExpression" ||
+                    current.type === "FunctionExpression" ||
+                    current.type === "FunctionDeclaration") {
+                    return current;
+                }
+
+                current = current.parent;
+            }
+
+            return null;
+        };
+
+        // Find matching property in ObjectPattern (destructured params)
+        const findDestructuredPropertyHandler = (funcNode, propName) => {
+            if (!funcNode || !funcNode.params || funcNode.params.length === 0) return null;
+
+            const firstParam = funcNode.params[0];
+
+            if (firstParam.type !== "ObjectPattern") return null;
+
+            // Find the property in the ObjectPattern
+            for (const prop of firstParam.properties) {
+                if (prop.type === "Property" && prop.key && prop.key.type === "Identifier") {
+                    if (prop.key.name === propName) {
+                        return prop;
+                    }
+                }
+            }
+
+            return null;
+        };
+
+        // Create fix that renames type annotation, destructured prop, and all references
+        const createRenamingFixHandler = (fixer, member, propName, suggestedName) => {
+            const fixes = [fixer.replaceText(member.key, suggestedName)];
+
+            // Find the containing function
+            const funcNode = findContainingFunctionHandler(member);
+
+            if (!funcNode) return fixes;
+
+            // Find the matching destructured property
+            const destructuredProp = findDestructuredPropertyHandler(funcNode, propName);
+
+            if (!destructuredProp) return fixes;
+
+            // Get the value node (the actual variable being declared)
+            const valueNode = destructuredProp.value || destructuredProp.key;
+
+            if (!valueNode || valueNode.type !== "Identifier") return fixes;
+
+            // If key and value are the same (shorthand: { copied }), we need to expand and rename
+            // If different (renamed: { copied: isCopied }), just rename the value
+            const isShorthand = destructuredProp.shorthand !== false &&
+                destructuredProp.key === destructuredProp.value;
+
+            if (isShorthand) {
+                // Shorthand syntax: { copied } -> { copied: isCopied }
+                // We need to keep the key (for the type match) and add the renamed value
+                fixes.push(fixer.replaceText(destructuredProp, `${propName}: ${suggestedName}`));
+            } else {
+                // Already renamed syntax or explicit: just update the value
+                fixes.push(fixer.replaceText(valueNode, suggestedName));
+            }
+
+            // Find all references to the variable and rename them
+            const scope = context.sourceCode
+                ? context.sourceCode.getScope(funcNode)
+                : context.getScope();
+
+            // Find the variable in the scope
+            const findVariableHandler = (s, name) => {
+                const v = s.variables.find((variable) => variable.name === name);
+
+                if (v) return v;
+                if (s.upper) return findVariableHandler(s.upper, name);
+
+                return null;
+            };
+
+            const variable = findVariableHandler(scope, propName);
+
+            if (variable) {
+                const fixedRanges = new Set();
+
+                variable.references.forEach((ref) => {
+                    // Skip the definition itself
+                    if (ref.identifier === valueNode) return;
+                    // Skip if already fixed
+                    const rangeKey = `${ref.identifier.range[0]}-${ref.identifier.range[1]}`;
+
+                    if (fixedRanges.has(rangeKey)) return;
+                    fixedRanges.add(rangeKey);
+                    fixes.push(fixer.replaceText(ref.identifier, suggestedName));
+                });
+            }
+
+            return fixes;
+        };
+
+        // Check a property signature (interface/type member) - recursive for nested types
+        const checkPropertySignatureHandler = (member) => {
+            if (member.type !== "TSPropertySignature") return;
+            if (!member.key || member.key.type !== "Identifier") return;
+
+            const propName = member.key.name;
+
+            // Skip private properties (starting with _)
+            if (propName.startsWith("_")) return;
+
+            // Check for nested object types and recursively check their members
+            if (isNestedObjectTypeHandler(member.typeAnnotation)) {
+                const nestedType = member.typeAnnotation.typeAnnotation;
+
+                if (nestedType && nestedType.members) {
+                    nestedType.members.forEach(checkPropertySignatureHandler);
+                }
+
+                return;
+            }
+
+            // Check boolean props
+            if (isBooleanTypeHandler(member.typeAnnotation)) {
+                if (!isValidBooleanNameHandler(propName)) {
+                    const suggestedName = toBooleanNameHandler(propName);
+
+                    context.report({
+                        fix: (fixer) => createRenamingFixHandler(fixer, member, propName, suggestedName),
+                        message: `Boolean prop "${propName}" should start with a valid prefix (${booleanPrefixes.join(", ")}). Use "${suggestedName}" instead.`,
+                        node: member.key,
+                    });
+                }
+
+                return;
+            }
+
+            // Check callback props
+            if (isCallbackTypeHandler(member.typeAnnotation)) {
+                if (!isValidCallbackNameHandler(propName)) {
+                    const suggestedName = toCallbackNameHandler(propName);
+
+                    context.report({
+                        fix: (fixer) => createRenamingFixHandler(fixer, member, propName, suggestedName),
+                        message: `Callback prop "${propName}" should start with "${callbackPrefix}" prefix. Use "${suggestedName}" instead.`,
+                        node: member.key,
+                    });
+                }
+            }
+        };
+
+        // Check members of a type literal (inline types, type aliases)
+        const checkTypeLiteralHandler = (node) => {
+            if (!node.members) return;
+            node.members.forEach(checkPropertySignatureHandler);
+        };
+
+        return {
+            // Interface declarations
+            TSInterfaceDeclaration(node) {
+                if (!node.body || !node.body.body) return;
+                node.body.body.forEach(checkPropertySignatureHandler);
+            },
+
+            // Type alias declarations with object type
+            TSTypeAliasDeclaration(node) {
+                if (node.typeAnnotation?.type === "TSTypeLiteral") {
+                    checkTypeLiteralHandler(node.typeAnnotation);
+                }
+            },
+
+            // Inline type literals (e.g., in function parameters)
+            TSTypeLiteral(node) {
+                // Skip if already handled by TSTypeAliasDeclaration
+                if (node.parent?.type === "TSTypeAliasDeclaration") return;
+                checkTypeLiteralHandler(node);
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce naming conventions: boolean props must start with is/has/with/without, callback props must start with on" },
+        fixable: "code",
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    allowActionSuffix: {
+                        default: false,
+                        description: "Allow 'xxxAction' pattern for callback props (e.g., submitAction, copyAction)",
+                        type: "boolean",
+                    },
+                    allowContinuousVerbBoolean: {
+                        default: false,
+                        description: "Allow continuous verb boolean props without prefix (e.g., loading, saving, fetching, closing)",
+                        type: "boolean",
+                    },
+                    allowPastVerbBoolean: {
+                        default: false,
+                        description: "Allow past verb boolean props without prefix (e.g., disabled, selected, checked, opened)",
+                        type: "boolean",
+                    },
+                    booleanPrefixes: {
+                        description: "Replace default boolean prefixes entirely. If not provided, defaults are used with extendBooleanPrefixes",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    callbackPrefix: {
+                        default: "on",
+                        description: "Required prefix for callback props",
+                        type: "string",
+                    },
+                    extendBooleanPrefixes: {
+                        default: [],
+                        description: "Add additional prefixes to the defaults (is, has, with, without)",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "suggestion",
+    },
+};
+
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: JSX Simple Element On One Line
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Simple JSX elements with only a single text or expression
+ *   child should be collapsed onto a single line.
+ *
+ * ✓ Good:
+ *   <Button>{buttonLinkText}</Button>
+ *   <Title>Hello</Title>
+ *
+ * ✗ Bad:
+ *   <Button>
+ *       {buttonLinkText}
+ *   </Button>
+ */
+const jsxSimpleElementOneLine = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        // Check if an argument is simple (identifier, literal, or simple member expression)
+        const isSimpleArgHandler = (node) => {
+            if (!node) return false;
+            if (node.type === "Identifier") return true;
+            if (node.type === "Literal") return true;
+            if (node.type === "MemberExpression") {
+                return node.object.type === "Identifier" && node.property.type === "Identifier";
+            }
+
+            return false;
+        };
+
+        // Check if an expression is simple (identifier, literal, member expression, or simple function call)
+        const isSimpleExpressionHandler = (node) => {
+            if (!node) return false;
+
+            if (node.type === "Identifier") return true;
+            if (node.type === "Literal") return true;
+            if (node.type === "MemberExpression") {
+                // Allow simple member expressions like obj.prop
+                return node.object.type === "Identifier" && node.property.type === "Identifier";
+            }
+
+            // Allow simple function calls with 0-1 simple arguments
+            if (node.type === "CallExpression") {
+                // Check callee is simple (identifier or member expression)
+                const { callee } = node;
+                const isSimpleCallee = callee.type === "Identifier" ||
+                    (callee.type === "MemberExpression" &&
+                     callee.object.type === "Identifier" &&
+                     callee.property.type === "Identifier");
+
+                if (!isSimpleCallee) return false;
+
+                // Allow 0-1 arguments, and the argument must be simple
+                if (node.arguments.length === 0) return true;
+                if (node.arguments.length === 1 && isSimpleArgHandler(node.arguments[0])) return true;
+
+                return false;
+            }
+
+            return false;
+        };
+
+        // Check if child is simple (text or simple expression)
+        const isSimpleChildHandler = (child) => {
+            if (child.type === "JSXText") {
+                return child.value.trim().length > 0;
+            }
+
+            if (child.type === "JSXExpressionContainer") {
+                return isSimpleExpressionHandler(child.expression);
+            }
+
+            return false;
+        };
+
+        return {
+            JSXElement(node) {
+                const openingTag = node.openingElement;
+                const closingTag = node.closingElement;
+
+                // Skip self-closing elements
+                if (!closingTag) return;
+
+                // Check if element is multiline
+                if (openingTag.loc.end.line === closingTag.loc.start.line) return;
+
+                const { children } = node;
+
+                // Filter out whitespace-only text children
+                const significantChildren = children.filter((child) => {
+                    if (child.type === "JSXText") {
+                        return child.value.trim() !== "";
+                    }
+
+                    return true;
+                });
+
+                // Must have exactly one simple child
+                if (significantChildren.length !== 1) return;
+
+                const child = significantChildren[0];
+
+                if (!isSimpleChildHandler(child)) return;
+
+                // Check if opening tag itself is simple (single line, not too many attributes)
+                if (openingTag.loc.start.line !== openingTag.loc.end.line) return;
+
+                // Get the text content
+                const openingText = sourceCode.getText(openingTag);
+                const childText = child.type === "JSXText" ? child.value.trim() : sourceCode.getText(child);
+                const closingText = sourceCode.getText(closingTag);
+
+                context.report({
+                    fix: (fixer) => fixer.replaceText(
+                        node,
+                        `${openingText}${childText}${closingText}`,
+                    ),
+                    message: "Simple JSX element with single text/expression child should be on one line",
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Simple JSX elements with only text/expression children should be on one line" },
+        fixable: "whitespace",
         schema: [],
         type: "layout",
     },
@@ -11141,39 +11847,42 @@ const noEmptyLinesInFunctionParams = {
             const firstParam = params[0];
             const lastParam = params[params.length - 1];
 
-            // Find opening paren (could be after async keyword for async functions)
-            let openParen = sourceCode.getFirstToken(node);
-
-            while (openParen && openParen.value !== "(") {
-                openParen = sourceCode.getTokenAfter(openParen);
-            }
-
-            if (!openParen) return;
-
-            const closeParen = sourceCode.getTokenAfter(lastParam, (t) => t.value === ")");
-
-            if (!closeParen) return;
-
-            if (firstParam.loc.start.line - openParen.loc.end.line > 1) {
-                context.report({
-                    fix: (fixer) => fixer.replaceTextRange(
-                        [openParen.range[1], firstParam.range[0]],
-                        "\n" + " ".repeat(firstParam.loc.start.column),
-                    ),
-                    message: "No empty line after opening parenthesis in function parameters",
-                    node: firstParam,
-                });
-            }
+            // Find opening paren - must be WITHIN this function's range (not from an outer call expression)
+            const tokenBeforeFirstParam = sourceCode.getTokenBefore(firstParam);
+            // Check that the ( is within this function's range (not from .map( or similar)
+            const hasParenAroundParams = tokenBeforeFirstParam
+                && tokenBeforeFirstParam.value === "("
+                && tokenBeforeFirstParam.range[0] >= node.range[0];
+
+            // Only check open/close paren spacing if params are wrapped in parentheses
+            if (hasParenAroundParams) {
+                const openParen = tokenBeforeFirstParam;
+                const closeParen = sourceCode.getTokenAfter(lastParam);
+
+                // Verify closeParen is actually a ) right after lastParam AND within this function's range
+                if (closeParen && closeParen.value === ")" && closeParen.range[1] <= (node.body ? node.body.range[0] : node.range[1])) {
+                    if (firstParam.loc.start.line - openParen.loc.end.line > 1) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [openParen.range[1], firstParam.range[0]],
+                                "\n" + " ".repeat(firstParam.loc.start.column),
+                            ),
+                            message: "No empty line after opening parenthesis in function parameters",
+                            node: firstParam,
+                        });
+                    }
 
-            if (closeParen.loc.start.line - lastParam.loc.end.line > 1) {
-                context.report({
-                    fix: (fixer) => fixer.replaceTextRange(
-                        [lastParam.range[1], closeParen.range[0]],
-                        "\n" + " ".repeat(closeParen.loc.start.column),
-                    ),
-                    message: "No empty line before closing parenthesis in function parameters",
-                    node: lastParam,
-                });
+                    if (closeParen.loc.start.line - lastParam.loc.end.line > 1) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [lastParam.range[1], closeParen.range[0]],
+                                "\n" + " ".repeat(closeParen.loc.start.column),
+                            ),
+                            message: "No empty line before closing parenthesis in function parameters",
+                            node: lastParam,
+                        });
+                    }
+                }
             }
 
             for (let i = 0; i < params.length - 1; i += 1) {
@@ -15726,7 +16435,7 @@ const variableNamingConvention = {
 
             const name = node.key.name;
 
-            if (name.startsWith("_") || constantRegex.test(name) || allowedIdentifiers.includes(name)) return;
+            if (name.startsWith("_") || allowedIdentifiers.includes(name)) return;
 
             // Allow PascalCase for properties that hold component references
             // e.g., Icon: AdminPanelSettingsIcon, FormComponent: UpdateEventForm
@@ -15746,8 +16455,11 @@ const variableNamingConvention = {
             if (name.startsWith("Mui")) return;
 
             if (!camelCaseRegex.test(name)) {
+                const camelCaseName = toCamelCaseHandler(name);
+
                 context.report({
-                    message: `Property "${name}" should be camelCase`,
+                    fix: (fixer) => fixer.replaceText(node.key, camelCaseName),
+                    message: `Property "${name}" should be camelCase (e.g., ${camelCaseName} instead of ${name})`,
                     node: node.key,
                 });
             }
@@ -16540,24 +17252,52 @@ const functionObjectDestructure = {
                     if (param.type !== "Identifier") return;
 
                     const paramName = param.name;
+
+                    // Check if param is used in a spread operation - skip because destructuring would break it
+                    let usedInSpread = false;
+                    const checkSpread = (n, parent) => {
+                        if (!n || typeof n !== "object") return;
+                        if (n.type === "SpreadElement" && n.argument && n.argument.type === "Identifier" && n.argument.name === paramName) {
+                            usedInSpread = true;
+
+                            return;
+                        }
+                        for (const key of Object.keys(n)) {
+                            if (key === "parent") continue;
+                            const child = n[key];
+                            if (Array.isArray(child)) child.forEach((c) => checkSpread(c, n));
+                            else if (child && typeof child === "object" && child.type) checkSpread(child, n);
+                        }
+                    };
+                    checkSpread(body, null);
+
+                    if (usedInSpread) return;
+
                     const accesses = findObjectAccessesHandler(body, paramName);
 
                     if (accesses.length > 0) {
                         const accessedProps = [...new Set(accesses.map((a) => a.property))];
 
-                        // Count all references to paramName in the body to check if it's used beyond dot notation
+                        // Count all actual references to paramName (excluding object property keys)
                         const allRefs = [];
-                        const countRefs = (n) => {
+                        const countRefs = (n, parent) => {
                             if (!n || typeof n !== "object") return;
-                            if (n.type === "Identifier" && n.name === paramName) allRefs.push(n);
+                            if (n.type === "Identifier" && n.name === paramName) {
+                                // Exclude object property keys (non-computed)
+                                const isPropertyKey = parent && parent.type === "Property" && parent.key === n && !parent.computed;
+
+                                if (!isPropertyKey) {
+                                    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);
+                                if (Array.isArray(child)) child.forEach((c) => countRefs(c, n));
+                                else if (child && typeof child === "object" && child.type) countRefs(child, n);
                             }
                         };
-                        countRefs(body);
+                        countRefs(body, null);
 
                         // Only auto-fix if all references are covered by the detected dot notation accesses
                         const canAutoFix = allRefs.length === accesses.length;
@@ -17872,28 +18612,178 @@ const componentPropsInlineType = {
  *   );
  *
  * ✗ Bad:
- *   // Returns SVG but doesn't end with "Icon"
- *   export const Success = ({ className }: { className?: string }) => (
- *       <svg className={className}>...</svg>
- *   );
+ *   // Returns SVG but doesn't end with "Icon"
+ *   export const Success = ({ className }: { className?: string }) => (
+ *       <svg className={className}>...</svg>
+ *   );
+ *
+ *   // Ends with "Icon" but doesn't return SVG
+ *   export const ButtonIcon = ({ children }: { children: ReactNode }) => (
+ *       <button>{children}</button>
+ *   );
+ */
+const svgComponentIconNaming = {
+    create(context) {
+        // Get the component name from node
+        const getComponentNameHandler = (node) => {
+            // Arrow function: const Name = () => ...
+            if (node.parent && node.parent.type === "VariableDeclarator" && node.parent.id && node.parent.id.type === "Identifier") {
+                return node.parent.id.name;
+            }
+
+            // Function declaration: function Name() { ... }
+            if (node.id && node.id.type === "Identifier") {
+                return node.id.name;
+            }
+
+            return null;
+        };
+
+        // Check if component name starts with uppercase (React component convention)
+        const isReactComponentNameHandler = (name) => name && /^[A-Z]/.test(name);
+
+        // Check if name ends with "Icon"
+        const hasIconSuffixHandler = (name) => name && name.endsWith("Icon");
+
+        // Check if the return value is purely an SVG element
+        const returnsSvgOnlyHandler = (node) => {
+            const body = node.body;
+
+            if (!body) return false;
+
+            // Arrow function with expression body: () => <svg>...</svg>
+            if (body.type === "JSXElement") {
+                return body.openingElement && body.openingElement.name && body.openingElement.name.name === "svg";
+            }
+
+            // Arrow function with parenthesized expression: () => (<svg>...</svg>)
+            if (body.type === "ParenthesizedExpression" && body.expression) {
+                if (body.expression.type === "JSXElement") {
+                    return body.expression.openingElement && body.expression.openingElement.name && body.expression.openingElement.name.name === "svg";
+                }
+            }
+
+            // Block body with return statement: () => { return <svg>...</svg>; }
+            if (body.type === "BlockStatement") {
+                // Find all return statements
+                const returnStatements = body.body.filter((stmt) => stmt.type === "ReturnStatement" && stmt.argument);
+
+                // Should have exactly one return statement for a simple SVG component
+                if (returnStatements.length === 1) {
+                    const returnArg = returnStatements[0].argument;
+
+                    if (returnArg.type === "JSXElement") {
+                        return returnArg.openingElement && returnArg.openingElement.name && returnArg.openingElement.name.name === "svg";
+                    }
+
+                    // Parenthesized: return (<svg>...</svg>);
+                    if (returnArg.type === "ParenthesizedExpression" && returnArg.expression && returnArg.expression.type === "JSXElement") {
+                        return returnArg.expression.openingElement && returnArg.expression.openingElement.name && returnArg.expression.openingElement.name.name === "svg";
+                    }
+                }
+            }
+
+            return false;
+        };
+
+        const checkFunctionHandler = (node) => {
+            const componentName = getComponentNameHandler(node);
+
+            // Only check React components (PascalCase)
+            if (!isReactComponentNameHandler(componentName)) return;
+
+            const returnsSvg = returnsSvgOnlyHandler(node);
+            const hasIconSuffix = hasIconSuffixHandler(componentName);
+
+            // Case 1: Returns SVG but doesn't end with "Icon"
+            if (returnsSvg && !hasIconSuffix) {
+                context.report({
+                    message: `Component "${componentName}" returns an SVG element and should end with "Icon" suffix (e.g., "${componentName}Icon")`,
+                    node: node.parent && node.parent.type === "VariableDeclarator" ? node.parent.id : node.id || node,
+                });
+            }
+
+            // Case 2: Ends with "Icon" but doesn't return SVG
+            if (hasIconSuffix && !returnsSvg) {
+                context.report({
+                    message: `Component "${componentName}" has "Icon" suffix but doesn't return an SVG element. Either rename it or make it return an SVG.`,
+                    node: node.parent && node.parent.type === "VariableDeclarator" ? node.parent.id : node.id || node,
+                });
+            }
+        };
+
+        return {
+            ArrowFunctionExpression: checkFunctionHandler,
+            FunctionDeclaration: checkFunctionHandler,
+            FunctionExpression: checkFunctionHandler,
+        };
+    },
+    meta: {
+        docs: { description: "Enforce SVG components to have 'Icon' suffix and vice versa" },
+        fixable: null,
+        schema: [],
+        type: "suggestion",
+    },
+};
+
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Folder Component Suffix
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforces naming conventions for components based on folder location:
+ *   - Components in "views" folder must end with "View" suffix
+ *   - Components in "pages" folder must end with "Page" suffix
+ *
+ * ✓ Good:
+ *   // In views/dashboard-view.tsx:
+ *   export const DashboardView = () => <div>Dashboard</div>;
+ *
+ *   // In pages/home-page.tsx:
+ *   export const HomePage = () => <div>Home</div>;
+ *
+ * ✗ Bad:
+ *   // In views/dashboard.tsx:
+ *   export const Dashboard = () => <div>Dashboard</div>;  // Should be "DashboardView"
  *
- *   // Ends with "Icon" but doesn't return SVG
- *   export const ButtonIcon = ({ children }: { children: ReactNode }) => (
- *       <button>{children}</button>
- *   );
+ *   // In pages/home.tsx:
+ *   export const Home = () => <div>Home</div>;  // Should be "HomePage"
  */
-const svgComponentIconNaming = {
+const folderComponentSuffix = {
     create(context) {
+        const filename = context.filename || context.getFilename();
+        const normalizedFilename = filename.replace(/\\/g, "/");
+
+        // Folder-to-suffix mapping
+        const folderSuffixMap = {
+            pages: "Page",
+            views: "View",
+        };
+
+        // Check which folder the file is in
+        const getFolderSuffixHandler = () => {
+            for (const [folder, suffix] of Object.entries(folderSuffixMap)) {
+                const pattern = new RegExp(`/${folder}/[^/]+\\.(jsx?|tsx?)$`);
+
+                if (pattern.test(normalizedFilename)) {
+                    return { folder, suffix };
+                }
+            }
+
+            return null;
+        };
+
         // Get the component name from node
         const getComponentNameHandler = (node) => {
             // Arrow function: const Name = () => ...
             if (node.parent && node.parent.type === "VariableDeclarator" && node.parent.id && node.parent.id.type === "Identifier") {
-                return node.parent.id.name;
+                return { name: node.parent.id.name, identifierNode: node.parent.id };
             }
 
             // Function declaration: function Name() { ... }
             if (node.id && node.id.type === "Identifier") {
-                return node.id.name;
+                return { name: node.id.name, identifierNode: node.id };
             }
 
             return null;
@@ -17902,72 +18792,115 @@ const svgComponentIconNaming = {
         // Check if component name starts with uppercase (React component convention)
         const isReactComponentNameHandler = (name) => name && /^[A-Z]/.test(name);
 
-        // Check if name ends with "Icon"
-        const hasIconSuffixHandler = (name) => name && name.endsWith("Icon");
-
-        // Check if the return value is purely an SVG element
-        const returnsSvgOnlyHandler = (node) => {
+        // Check if the function returns JSX
+        const returnsJsxHandler = (node) => {
             const body = node.body;
 
             if (!body) return false;
 
-            // Arrow function with expression body: () => <svg>...</svg>
-            if (body.type === "JSXElement") {
-                return body.openingElement && body.openingElement.name && body.openingElement.name.name === "svg";
+            // Arrow function with expression body: () => <div>...</div>
+            if (body.type === "JSXElement" || body.type === "JSXFragment") {
+                return true;
             }
 
-            // Arrow function with parenthesized expression: () => (<svg>...</svg>)
+            // Parenthesized expression
             if (body.type === "ParenthesizedExpression" && body.expression) {
-                if (body.expression.type === "JSXElement") {
-                    return body.expression.openingElement && body.expression.openingElement.name && body.expression.openingElement.name.name === "svg";
+                if (body.expression.type === "JSXElement" || body.expression.type === "JSXFragment") {
+                    return true;
                 }
             }
 
-            // Block body with return statement: () => { return <svg>...</svg>; }
+            // Block body with return statement
             if (body.type === "BlockStatement") {
-                // Find all return statements
-                const returnStatements = body.body.filter((stmt) => stmt.type === "ReturnStatement" && stmt.argument);
-
-                // Should have exactly one return statement for a simple SVG component
-                if (returnStatements.length === 1) {
-                    const returnArg = returnStatements[0].argument;
+                const hasJsxReturn = body.body.some((stmt) => {
+                    if (stmt.type === "ReturnStatement" && stmt.argument) {
+                        const arg = stmt.argument;
 
-                    if (returnArg.type === "JSXElement") {
-                        return returnArg.openingElement && returnArg.openingElement.name && returnArg.openingElement.name.name === "svg";
+                        return arg.type === "JSXElement" || arg.type === "JSXFragment"
+                            || (arg.type === "ParenthesizedExpression" && arg.expression
+                                && (arg.expression.type === "JSXElement" || arg.expression.type === "JSXFragment"));
                     }
 
-                    // Parenthesized: return (<svg>...</svg>);
-                    if (returnArg.type === "ParenthesizedExpression" && returnArg.expression && returnArg.expression.type === "JSXElement") {
-                        return returnArg.expression.openingElement && returnArg.expression.openingElement.name && returnArg.expression.openingElement.name.name === "svg";
-                    }
-                }
+                    return false;
+                });
+
+                return hasJsxReturn;
             }
 
             return false;
         };
 
         const checkFunctionHandler = (node) => {
-            const componentName = getComponentNameHandler(node);
+            const folderInfo = getFolderSuffixHandler();
+
+            // Not in a folder that requires specific suffix
+            if (!folderInfo) return;
+
+            const componentInfo = getComponentNameHandler(node);
+
+            if (!componentInfo) return;
+
+            const { name, identifierNode } = componentInfo;
 
             // Only check React components (PascalCase)
-            if (!isReactComponentNameHandler(componentName)) return;
+            if (!isReactComponentNameHandler(name)) return;
 
-            const returnsSvg = returnsSvgOnlyHandler(node);
-            const hasIconSuffix = hasIconSuffixHandler(componentName);
+            // Only check functions that return JSX
+            if (!returnsJsxHandler(node)) return;
 
-            // Case 1: Returns SVG but doesn't end with "Icon"
-            if (returnsSvg && !hasIconSuffix) {
-                context.report({
-                    message: `Component "${componentName}" returns an SVG element and should end with "Icon" suffix (e.g., "${componentName}Icon")`,
-                    node: node.parent && node.parent.type === "VariableDeclarator" ? node.parent.id : node.id || node,
-                });
-            }
+            const { folder, suffix } = folderInfo;
+
+            // Check if component name ends with the required suffix
+            if (!name.endsWith(suffix)) {
+                const newName = `${name}${suffix}`;
 
-            // Case 2: Ends with "Icon" but doesn't return SVG
-            if (hasIconSuffix && !returnsSvg) {
                 context.report({
-                    message: `Component "${componentName}" has "Icon" suffix but doesn't return an SVG element. Either rename it or make it return an SVG.`,
-                    node: node.parent && node.parent.type === "VariableDeclarator" ? node.parent.id : node.id || node,
+                    fix(fixer) {
+                        const scope = context.sourceCode
+                            ? context.sourceCode.getScope(node)
+                            : context.getScope();
+
+                        // Find the variable in scope
+                        const findVariableHandler = (s, varName) => {
+                            const v = s.variables.find((variable) => variable.name === varName);
+
+                            if (v) return v;
+                            if (s.upper) return findVariableHandler(s.upper, varName);
+
+                            return null;
+                        };
+
+                        const variable = findVariableHandler(scope, name);
+
+                        if (!variable) return fixer.replaceText(identifierNode, newName);
+
+                        const fixes = [];
+                        const fixedRanges = new Set();
+
+                        // Fix definition
+                        variable.defs.forEach((def) => {
+                            const rangeKey = `${def.name.range[0]}-${def.name.range[1]}`;
+
+                            if (!fixedRanges.has(rangeKey)) {
+                                fixedRanges.add(rangeKey);
+                                fixes.push(fixer.replaceText(def.name, newName));
+                            }
+                        });
+
+                        // Fix all references
+                        variable.references.forEach((ref) => {
+                            const rangeKey = `${ref.identifier.range[0]}-${ref.identifier.range[1]}`;
+
+                            if (!fixedRanges.has(rangeKey)) {
+                                fixedRanges.add(rangeKey);
+                                fixes.push(fixer.replaceText(ref.identifier, newName));
+                            }
+                        });
+
+                        return fixes;
+                    },
+                    message: `Component "${name}" in "${folder}" folder must end with "${suffix}" suffix (e.g., "${newName}")`,
+                    node: identifierNode,
                 });
             }
         };
@@ -17979,8 +18912,8 @@ const svgComponentIconNaming = {
         };
     },
     meta: {
-        docs: { description: "Enforce SVG components to have 'Icon' suffix and vice versa" },
-        fixable: null,
+        docs: { description: "Enforce components in 'views' folder end with 'View' and components in 'pages' folder end with 'Page'" },
+        fixable: "code",
         schema: [],
         type: "suggestion",
     },
@@ -18238,10 +19171,32 @@ const noInlineTypeDefinitions = {
 const typeFormat = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
+        const options = context.options[0] || {};
+        const minUnionMembersForMultiline = options.minUnionMembersForMultiline !== undefined ? options.minUnionMembersForMultiline : 5;
 
         const pascalCaseRegex = /^[A-Z][a-zA-Z0-9]*$/;
         const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
 
+        // Convert PascalCase/SCREAMING_SNAKE_CASE/snake_case to camelCase
+        const toCamelCaseHandler = (name) => {
+            // Handle SCREAMING_SNAKE_CASE (e.g., USER_NAME -> userName)
+            if (/^[A-Z][A-Z0-9_]*$/.test(name)) {
+                return name.toLowerCase().replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+            }
+
+            // Handle snake_case (e.g., user_name -> userName)
+            if (/_/.test(name)) {
+                return name.toLowerCase().replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+            }
+
+            // Handle PascalCase (e.g., UserName -> userName)
+            if (/^[A-Z]/.test(name)) {
+                return name[0].toLowerCase() + name.slice(1);
+            }
+
+            return name;
+        };
+
         const checkTypeLiteralHandler = (declarationNode, typeLiteralNode, members) => {
             if (members.length === 0) return;
 
@@ -18300,13 +19255,46 @@ const typeFormat = {
                     const propName = member.key.name;
 
                     if (!camelCaseRegex.test(propName)) {
+                        const fixedName = toCamelCaseHandler(propName);
+
                         context.report({
-                            message: `Type property "${propName}" must be camelCase`,
+                            fix: (fixer) => fixer.replaceText(member.key, fixedName),
+                            message: `Type property "${propName}" must be camelCase. Use "${fixedName}" instead.`,
                             node: member.key,
                         });
                     }
                 }
 
+                // Collapse single-member nested object types to one line
+                if (member.type === "TSPropertySignature" && member.typeAnnotation?.typeAnnotation?.type === "TSTypeLiteral") {
+                    const nestedType = member.typeAnnotation.typeAnnotation;
+
+                    if (nestedType.members && nestedType.members.length === 1) {
+                        const nestedOpenBrace = sourceCode.getFirstToken(nestedType);
+                        const nestedCloseBrace = sourceCode.getLastToken(nestedType);
+                        const isNestedMultiLine = nestedOpenBrace.loc.end.line !== nestedCloseBrace.loc.start.line;
+
+                        if (isNestedMultiLine) {
+                            const nestedMember = nestedType.members[0];
+                            let nestedMemberText = sourceCode.getText(nestedMember).trim();
+
+                            // Remove trailing punctuation
+                            if (nestedMemberText.endsWith(",") || nestedMemberText.endsWith(";")) {
+                                nestedMemberText = nestedMemberText.slice(0, -1);
+                            }
+
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [nestedOpenBrace.range[0], nestedCloseBrace.range[1]],
+                                    `{ ${nestedMemberText} }`,
+                                ),
+                                message: "Single property nested object type should be on one line",
+                                node: nestedType,
+                            });
+                        }
+                    }
+                }
+
                 // Check for space before ? in optional properties
                 if (member.type === "TSPropertySignature" && member.optional) {
                     const keyToken = sourceCode.getFirstToken(member);
@@ -18674,13 +19662,166 @@ const typeFormat = {
                         }
                     });
                 }
+
+                // Check union types formatting (e.g., "a" | "b" | "c")
+                if (node.typeAnnotation && node.typeAnnotation.type === "TSUnionType") {
+                    const unionType = node.typeAnnotation;
+                    const types = unionType.types;
+                    const minMembersForMultiline = minUnionMembersForMultiline;
+
+                    // Get line info
+                    const typeLine = sourceCode.lines[node.loc.start.line - 1];
+                    const baseIndent = typeLine.match(/^\s*/)[0];
+                    const memberIndent = baseIndent + "    ";
+
+                    // Get the = token
+                    const equalToken = sourceCode.getTokenAfter(node.id);
+                    const firstType = types[0];
+                    const lastType = types[types.length - 1];
+
+                    // Check if currently on single line
+                    const isCurrentlySingleLine = firstType.loc.start.line === lastType.loc.end.line &&
+                        equalToken.loc.end.line === firstType.loc.start.line;
+
+                    // Check if currently properly multiline (= on its own conceptually, first type on new line)
+                    const isFirstTypeOnNewLine = firstType.loc.start.line > equalToken.loc.end.line;
+
+                    if (types.length >= minMembersForMultiline) {
+                        // Should be multiline format
+                        // Check if needs reformatting
+                        let needsReformat = false;
+
+                        // Check if first type is on new line after =
+                        if (!isFirstTypeOnNewLine) {
+                            needsReformat = true;
+                        }
+
+                        // Check if each type is on its own line
+                        if (!needsReformat) {
+                            for (let i = 1; i < types.length; i++) {
+                                if (types[i].loc.start.line === types[i - 1].loc.end.line) {
+                                    needsReformat = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        // Check proper indentation and | placement
+                        if (!needsReformat) {
+                            for (let i = 1; i < types.length; i++) {
+                                const pipeToken = sourceCode.getTokenBefore(types[i]);
+
+                                if (pipeToken && pipeToken.value === "|") {
+                                    // | should be at start of line (after indent)
+                                    if (pipeToken.loc.start.line !== types[i].loc.start.line) {
+                                        needsReformat = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (needsReformat) {
+                            // Build the correct multiline format
+                            const formattedTypes = types.map((type, index) => {
+                                const typeText = sourceCode.getText(type);
+
+                                if (index === 0) {
+                                    return memberIndent + typeText;
+                                }
+
+                                return memberIndent + "| " + typeText;
+                            }).join("\n");
+
+                            const newTypeText = `= \n${formattedTypes}`;
+
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [equalToken.range[0], lastType.range[1]],
+                                    newTypeText,
+                                ),
+                                message: `Union type with ${types.length} members should be multiline with each member on its own line`,
+                                node: unionType,
+                            });
+                        }
+                    } else {
+                        // Should be single line format (less than 5 members)
+                        if (!isCurrentlySingleLine) {
+                            // Build single line format
+                            const typeTexts = types.map((type) => sourceCode.getText(type));
+                            const singleLineText = `= ${typeTexts.join(" | ")}`;
+
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [equalToken.range[0], lastType.range[1]],
+                                    singleLineText,
+                                ),
+                                message: `Union type with ${types.length} members should be on a single line`,
+                                node: unionType,
+                            });
+                        }
+                    }
+                }
+            },
+            // Handle inline type literals (e.g., in function parameters)
+            TSTypeLiteral(node) {
+                // Skip if already handled by TSTypeAliasDeclaration or TSAsExpression
+                if (node.parent?.type === "TSTypeAliasDeclaration") return;
+                if (node.parent?.type === "TSAsExpression") return;
+
+                // Check for single-member nested object types that should be collapsed
+                if (node.members) {
+                    node.members.forEach((member) => {
+                        if (member.type === "TSPropertySignature" && member.typeAnnotation?.typeAnnotation?.type === "TSTypeLiteral") {
+                            const nestedType = member.typeAnnotation.typeAnnotation;
+
+                            if (nestedType.members && nestedType.members.length === 1) {
+                                const nestedOpenBrace = sourceCode.getFirstToken(nestedType);
+                                const nestedCloseBrace = sourceCode.getLastToken(nestedType);
+                                const isNestedMultiLine = nestedOpenBrace.loc.end.line !== nestedCloseBrace.loc.start.line;
+
+                                if (isNestedMultiLine) {
+                                    const nestedMember = nestedType.members[0];
+                                    let nestedMemberText = sourceCode.getText(nestedMember).trim();
+
+                                    // Remove trailing punctuation
+                                    if (nestedMemberText.endsWith(",") || nestedMemberText.endsWith(";")) {
+                                        nestedMemberText = nestedMemberText.slice(0, -1);
+                                    }
+
+                                    context.report({
+                                        fix: (fixer) => fixer.replaceTextRange(
+                                            [nestedOpenBrace.range[0], nestedCloseBrace.range[1]],
+                                            `{ ${nestedMemberText} }`,
+                                        ),
+                                        message: "Single property nested object type should be on one line",
+                                        node: nestedType,
+                                    });
+                                }
+                            }
+                        }
+                    });
+                }
             },
         };
     },
     meta: {
-        docs: { description: "Enforce type naming (PascalCase + Type suffix), camelCase properties, proper formatting, and trailing commas" },
+        docs: { description: "Enforce type naming (PascalCase + Type suffix), camelCase properties, proper formatting, union type formatting, and trailing commas" },
         fixable: "code",
-        schema: [],
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    minUnionMembersForMultiline: {
+                        default: 5,
+                        description: "Minimum number of union members to require multiline format",
+                        minimum: 2,
+                        type: "integer",
+                    },
+                },
+                type: "object",
+            },
+        ],
         type: "suggestion",
     },
 };
@@ -20293,14 +21434,27 @@ const enumFormat = {
                     });
                 }
 
+                // Convert camelCase/PascalCase to UPPER_SNAKE_CASE
+                const toUpperSnakeCaseHandler = (name) => {
+                    // Insert underscore before each uppercase letter (except the first)
+                    // Then convert to uppercase
+                    return name
+                        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+                        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+                        .toUpperCase();
+                };
+
                 members.forEach((member, index) => {
                     // Check member name is UPPER_CASE
                     if (member.id && member.id.type === "Identifier") {
                         const memberName = member.id.name;
 
                         if (!upperCaseRegex.test(memberName)) {
+                            const fixedName = toUpperSnakeCaseHandler(memberName);
+
                             context.report({
-                                message: `Enum member "${memberName}" must be UPPER_CASE (e.g., ${memberName.toUpperCase()})`,
+                                fix: (fixer) => fixer.replaceText(member.id, fixedName),
+                                message: `Enum member "${memberName}" must be UPPER_CASE (e.g., ${fixedName})`,
                                 node: member.id,
                             });
                         }
@@ -20453,6 +21607,26 @@ const interfaceFormat = {
         const pascalCaseRegex = /^[A-Z][a-zA-Z0-9]*$/;
         const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
 
+        // Convert PascalCase/SCREAMING_SNAKE_CASE/snake_case to camelCase
+        const toCamelCaseHandler = (name) => {
+            // Handle SCREAMING_SNAKE_CASE (e.g., USER_NAME -> userName)
+            if (/^[A-Z][A-Z0-9_]*$/.test(name)) {
+                return name.toLowerCase().replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+            }
+
+            // Handle snake_case (e.g., user_name -> userName)
+            if (/_/.test(name)) {
+                return name.toLowerCase().replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+            }
+
+            // Handle PascalCase (e.g., UserName -> userName)
+            if (/^[A-Z]/.test(name)) {
+                return name[0].toLowerCase() + name.slice(1);
+            }
+
+            return name;
+        };
+
         return {
             TSInterfaceDeclaration(node) {
                 const interfaceName = node.id.name;
@@ -20530,17 +21704,41 @@ const interfaceFormat = {
                 }
 
                 // For single member, should be on one line without trailing punctuation
+                // But skip if the property has a nested object type with 2+ members
                 if (members.length === 1) {
                     const member = members[0];
-                    const memberText = sourceCode.getText(member);
                     const isMultiLine = openBraceToken.loc.end.line !== closeBraceToken.loc.start.line;
 
-                    if (isMultiLine) {
-                        // Collapse to single line without trailing punctuation
-                        let cleanText = memberText.trim();
+                    // Check if property has nested object type
+                    const nestedType = member.typeAnnotation?.typeAnnotation;
+                    const hasNestedType = nestedType?.type === "TSTypeLiteral";
+                    const hasMultiMemberNestedType = hasNestedType && nestedType.members?.length >= 2;
+                    const hasSingleMemberNestedType = hasNestedType && nestedType.members?.length === 1;
 
-                        if (cleanText.endsWith(",") || cleanText.endsWith(";")) {
-                            cleanText = cleanText.slice(0, -1);
+                    if (isMultiLine && !hasMultiMemberNestedType) {
+                        // Build the collapsed text, handling nested types specially
+                        let cleanText;
+
+                        if (hasSingleMemberNestedType) {
+                            // Collapse nested type first, then build the member text
+                            const nestedMember = nestedType.members[0];
+                            let nestedMemberText = sourceCode.getText(nestedMember).trim();
+
+                            if (nestedMemberText.endsWith(",") || nestedMemberText.endsWith(";")) {
+                                nestedMemberText = nestedMemberText.slice(0, -1);
+                            }
+
+                            // Build: propName: { nestedProp: type }
+                            const propName = member.key.name;
+                            const optionalMark = member.optional ? "?" : "";
+
+                            cleanText = `${propName}${optionalMark}: { ${nestedMemberText} }`;
+                        } else {
+                            cleanText = sourceCode.getText(member).trim();
+
+                            if (cleanText.endsWith(",") || cleanText.endsWith(";")) {
+                                cleanText = cleanText.slice(0, -1);
+                            }
                         }
 
                         const newInterfaceText = `{ ${cleanText} }`;
@@ -20558,6 +21756,8 @@ const interfaceFormat = {
                     }
 
                     // Check for trailing comma/semicolon in single-line single member
+                    const memberText = sourceCode.getText(member);
+
                     if (memberText.trimEnd().endsWith(",") || memberText.trimEnd().endsWith(";")) {
                         const punctIndex = Math.max(memberText.lastIndexOf(","), memberText.lastIndexOf(";"));
 
@@ -20589,13 +21789,46 @@ const interfaceFormat = {
                         const propName = member.key.name;
 
                         if (!camelCaseRegex.test(propName)) {
+                            const fixedName = toCamelCaseHandler(propName);
+
                             context.report({
-                                message: `Interface property "${propName}" must be camelCase`,
+                                fix: (fixer) => fixer.replaceText(member.key, fixedName),
+                                message: `Interface property "${propName}" must be camelCase. Use "${fixedName}" instead.`,
                                 node: member.key,
                             });
                         }
                     }
 
+                    // Collapse single-member nested object types to one line
+                    if (member.type === "TSPropertySignature" && member.typeAnnotation?.typeAnnotation?.type === "TSTypeLiteral") {
+                        const nestedType = member.typeAnnotation.typeAnnotation;
+
+                        if (nestedType.members && nestedType.members.length === 1) {
+                            const nestedOpenBrace = sourceCode.getFirstToken(nestedType);
+                            const nestedCloseBrace = sourceCode.getLastToken(nestedType);
+                            const isNestedMultiLine = nestedOpenBrace.loc.end.line !== nestedCloseBrace.loc.start.line;
+
+                            if (isNestedMultiLine) {
+                                const nestedMember = nestedType.members[0];
+                                let nestedMemberText = sourceCode.getText(nestedMember).trim();
+
+                                // Remove trailing punctuation
+                                if (nestedMemberText.endsWith(",") || nestedMemberText.endsWith(";")) {
+                                    nestedMemberText = nestedMemberText.slice(0, -1);
+                                }
+
+                                context.report({
+                                    fix: (fixer) => fixer.replaceTextRange(
+                                        [nestedOpenBrace.range[0], nestedCloseBrace.range[1]],
+                                        `{ ${nestedMemberText} }`,
+                                    ),
+                                    message: "Single property nested object type should be on one line",
+                                    node: nestedType,
+                                });
+                            }
+                        }
+                    }
+
                     // Check for space before ? in optional properties
                     if (member.type === "TSPropertySignature" && member.optional) {
                         const keyToken = sourceCode.getFirstToken(member);
@@ -20841,6 +22074,7 @@ export default {
         // Component rules
         "component-props-destructure": componentPropsDestructure,
         "component-props-inline-type": componentPropsInlineType,
+        "folder-component-suffix": folderComponentSuffix,
         "svg-component-icon-naming": svgComponentIconNaming,
 
         // React rules
@@ -20871,6 +22105,7 @@ export default {
         // Hook rules
         "hook-callback-format": hookCallbackFormat,
         "hook-deps-per-line": hookDepsPerLine,
+        "use-state-naming-convention": useStateNamingConvention,
 
         // Import/Export rules
         "absolute-imports-only": absoluteImportsOnly,
@@ -20912,6 +22147,7 @@ export default {
         "enum-format": enumFormat,
         "interface-format": interfaceFormat,
         "no-inline-type-definitions": noInlineTypeDefinitions,
+        "prop-naming-convention": propNamingConvention,
         "type-annotation-spacing": typeAnnotationSpacing,
         "type-format": typeFormat,
         "typescript-definition-location": typescriptDefinitionLocation,