eslint-plugin-code-style 1.11.7 → 1.13.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,
@@ -7818,16 +7825,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
@@ -8558,6 +8555,350 @@ const jsxPropNamingConvention = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Prop Naming Convention
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   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:
+ *   interface PropsInterface {
+ *       isLoading: boolean,
+ *       hasError: boolean,
+ *       onClick: () => void,
+ *       onSubmit: (data: Data) => void,
+ *       config: {
+ *           isEnabled: boolean,
+ *           onToggle: () => void,
+ *       },
+ *   }
+ *
+ * ✗ Bad:
+ *   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 propNamingConvention = {
+    create(context) {
+        const options = context.options[0] || {};
+
+        // Boolean prefixes handling (like module-index-exports pattern)
+        const defaultBooleanPrefixes = ["is", "has", "with", "without"];
+        const booleanPrefixes = options.booleanPrefixes || [
+            ...defaultBooleanPrefixes,
+            ...(options.extendBooleanPrefixes || []),
+        ];
+
+        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);
+        };
+
+        // 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);
+
+                return callbackPrefix + rest[0].toUpperCase() + rest.slice(1);
+            }
+
+            // Handle "xxxHandler" pattern -> "onXxx"
+            if (name.endsWith("Handler") && name.length > 7) {
+                const rest = name.slice(0, -7);
+
+                return callbackPrefix + rest[0].toUpperCase() + rest.slice(1);
+            }
+
+            // Simple case: just add "on" prefix
+            return callbackPrefix + name[0].toUpperCase() + name.slice(1);
+        };
+
+        // 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;
+        };
+
+        // 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;
+            }
+
+            // 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;
+        };
+
+        // Check if type annotation is a nested object type (TSTypeLiteral)
+        const isNestedObjectTypeHandler = (typeAnnotation) => {
+            if (!typeAnnotation) return false;
+            const type = typeAnnotation.typeAnnotation;
+
+            if (!type) return false;
+
+            return type.type === "TSTypeLiteral";
+        };
+
+        // Check if name is a valid boolean prop 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 name is a valid callback prop name
+        const isValidCallbackNameHandler = (name) => {
+            // Starts with "on" prefix
+            if (callbackPrefixPattern.test(name)) return true;
+
+            // Allow "xxxAction" suffix if option is enabled
+            if (allowActionSuffix && name.endsWith("Action") && name.length > 6) return true;
+
+            return false;
+        };
+
+        // 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) => fixer.replaceText(member.key, 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) => fixer.replaceText(member.key, 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
@@ -11141,39 +11482,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 +16070,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 +16090,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 +16887,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;
@@ -17986,6 +18361,153 @@ const svgComponentIconNaming = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * 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"
+ *
+ *   // In pages/home.tsx:
+ *   export const Home = () => <div>Home</div>;  // Should be "HomePage"
+ */
+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 { name: node.parent.id.name, identifierNode: node.parent.id };
+            }
+
+            // Function declaration: function Name() { ... }
+            if (node.id && node.id.type === "Identifier") {
+                return { name: node.id.name, identifierNode: node.id };
+            }
+
+            return null;
+        };
+
+        // Check if component name starts with uppercase (React component convention)
+        const isReactComponentNameHandler = (name) => name && /^[A-Z]/.test(name);
+
+        // Check if the function returns JSX
+        const returnsJsxHandler = (node) => {
+            const body = node.body;
+
+            if (!body) return false;
+
+            // Arrow function with expression body: () => <div>...</div>
+            if (body.type === "JSXElement" || body.type === "JSXFragment") {
+                return true;
+            }
+
+            // Parenthesized expression
+            if (body.type === "ParenthesizedExpression" && body.expression) {
+                if (body.expression.type === "JSXElement" || body.expression.type === "JSXFragment") {
+                    return true;
+                }
+            }
+
+            // Block body with return statement
+            if (body.type === "BlockStatement") {
+                const hasJsxReturn = body.body.some((stmt) => {
+                    if (stmt.type === "ReturnStatement" && stmt.argument) {
+                        const arg = stmt.argument;
+
+                        return arg.type === "JSXElement" || arg.type === "JSXFragment"
+                            || (arg.type === "ParenthesizedExpression" && arg.expression
+                                && (arg.expression.type === "JSXElement" || arg.expression.type === "JSXFragment"));
+                    }
+
+                    return false;
+                });
+
+                return hasJsxReturn;
+            }
+
+            return false;
+        };
+
+        const checkFunctionHandler = (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(name)) return;
+
+            // Only check functions that return JSX
+            if (!returnsJsxHandler(node)) return;
+
+            const { folder, suffix } = folderInfo;
+
+            // Check if component name ends with the required suffix
+            if (!name.endsWith(suffix)) {
+                context.report({
+                    message: `Component "${name}" in "${folder}" folder must end with "${suffix}" suffix (e.g., "${name}${suffix}")`,
+                    node: identifierNode,
+                });
+            }
+        };
+
+        return {
+            ArrowFunctionExpression: checkFunctionHandler,
+            FunctionDeclaration: checkFunctionHandler,
+            FunctionExpression: checkFunctionHandler,
+        };
+    },
+    meta: {
+        docs: { description: "Enforce components in 'views' folder end with 'View' and components in 'pages' folder end with 'Page'" },
+        fixable: null,
+        schema: [],
+        type: "suggestion",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: No Inline Type Definitions
@@ -18238,10 +18760,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 +18844,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 +19251,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 +21023,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 +21196,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 +21293,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 (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);
+                            }
 
-                        if (cleanText.endsWith(",") || cleanText.endsWith(";")) {
-                            cleanText = cleanText.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 +21345,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 +21378,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 +21663,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
@@ -20912,6 +21735,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,