eslint-plugin-code-style 1.0.41 → 1.1.10

package/index.d.ts

@@ -50,6 +50,10 @@ export type RuleNames =
     | "code-style/simple-call-single-line"
     | "code-style/single-argument-on-one-line"
     | "code-style/string-property-spacing"
+    | "code-style/enum-format"
+    | "code-style/interface-format"
+    | "code-style/type-format"
+    | "code-style/typescript-definition-location"
     | "code-style/variable-naming-convention";
 
 /**
@@ -119,6 +123,10 @@ interface PluginRules {
     "simple-call-single-line": Rule.RuleModule;
     "single-argument-on-one-line": Rule.RuleModule;
     "string-property-spacing": Rule.RuleModule;
+    "enum-format": Rule.RuleModule;
+    "interface-format": Rule.RuleModule;
+    "type-format": Rule.RuleModule;
+    "typescript-definition-location": Rule.RuleModule;
     "variable-naming-convention": Rule.RuleModule;
 }
 

package/index.js

@@ -2515,7 +2515,9 @@ const absoluteImportsOnly = {
             "constants",
             "contexts",
             "data",
+            "enums",
             "hooks",
+            "interfaces",
             "layouts",
             "middlewares",
             "providers",
@@ -3139,6 +3141,7 @@ const moduleIndexExports = {
 
         // Default module folders
         const defaultModuleFolders = [
+            "actions",
             "apis",
             "assets",
             "atoms",
@@ -3146,17 +3149,23 @@ const moduleIndexExports = {
             "constants",
             "contexts",
             "data",
+            "enums",
             "hooks",
+            "interfaces",
             "layouts",
             "middlewares",
             "providers",
+            "reducers",
             "redux",
             "requests",
             "routes",
             "schemas",
             "services",
+            "store",
             "styles",
             "theme",
+            "thunks",
+            "types",
             "utils",
             "views",
         ];
@@ -3185,8 +3194,12 @@ const moduleIndexExports = {
             "__mocks__",
             "*.test.js",
             "*.test.jsx",
+            "*.test.ts",
+            "*.test.tsx",
             "*.spec.js",
             "*.spec.jsx",
+            "*.spec.ts",
+            "*.spec.tsx",
         ];
 
         // Files/folders to ignore
@@ -3320,7 +3333,13 @@ const moduleIndexExports = {
                     }
 
                     // Handle cases like ./folder/index
-                    if (isDirectory && (source === `./${itemName}/index` || source === `./${itemName}/index.js` || source === `./${itemName}/index.jsx`)) {
+                    if (isDirectory && (
+                        source === `./${itemName}/index`
+                        || source === `./${itemName}/index.js`
+                        || source === `./${itemName}/index.jsx`
+                        || source === `./${itemName}/index.ts`
+                        || source === `./${itemName}/index.tsx`
+                    )) {
                         return true;
                     }
 
@@ -3371,12 +3390,19 @@ const moduleIndexExports = {
 
                     if (moduleFolders.includes(folderName) && fileName !== "index") {
                         const dirPath = nodePath.dirname(filename);
-                        const indexPath = nodePath.join(dirPath, "index.js");
+                        const indexPathJs = nodePath.join(dirPath, "index.js");
                         const indexPathJsx = nodePath.join(dirPath, "index.jsx");
+                        const indexPathTs = nodePath.join(dirPath, "index.ts");
+                        const indexPathTsx = nodePath.join(dirPath, "index.tsx");
 
-                        if (!fs.existsSync(indexPath) && !fs.existsSync(indexPathJsx)) {
+                        const hasIndexFile = fs.existsSync(indexPathJs)
+                            || fs.existsSync(indexPathJsx)
+                            || fs.existsSync(indexPathTs)
+                            || fs.existsSync(indexPathTsx);
+
+                        if (!hasIndexFile) {
                             context.report({
-                                message: `Module folder "${folderName}" is missing an index file. Create index.js to export all modules.`,
+                                message: `Module folder "${folderName}" is missing an index file. Create an index file to export all modules.`,
                                 node,
                             });
                         }
@@ -8465,6 +8491,450 @@ const variableNamingConvention = {
     },
 };
 
+/*
+ * typescript-definition-location
+ *
+ * Enforce that TypeScript definitions are declared in their designated folders:
+ * - Interfaces must be in files inside the "interfaces" folder
+ * - Enums must be in files inside the "enums" folder
+ * - Types must be in files inside the "types" folder
+ *
+ * ✓ Good:
+ *   // src/interfaces/user.ts
+ *   export interface UserInterface { ... }
+ *
+ *   // src/enums/status.ts
+ *   export enum StatusEnum { ... }
+ *
+ *   // src/types/config.ts
+ *   export type ConfigType = { ... }
+ *
+ * ✗ Bad:
+ *   // src/components/user.tsx
+ *   export interface UserInterface { ... }  // Interface not in interfaces folder
+ */
+/*
+ * interface-format
+ *
+ * Enforce consistent formatting for TypeScript interfaces:
+ * - Interface name must be PascalCase and end with "Interface" suffix
+ * - Properties must be in camelCase
+ * - No empty lines between properties
+ * - Each property must end with comma (,) not semicolon (;)
+ *
+ * ✓ Good:
+ *   export interface UserInterface {
+ *       firstName: string,
+ *       lastName: string,
+ *       age: number,
+ *   }
+ *
+ * ✗ Bad:
+ *   export interface User {           // Missing "Interface" suffix
+ *       first_name: string;           // snake_case and semicolon
+ *
+ *       lastName: string;             // Empty line above and semicolon
+ *   }
+ */
+/*
+ * enum-format
+ *
+ * Enforce consistent formatting for TypeScript enums:
+ * - Enum name must be PascalCase and end with "Enum" suffix
+ * - Member names must be UPPER_CASE (e.g., DELETE, GET, POST)
+ * - No empty lines between members
+ * - Each member must end with comma (,) not semicolon (;)
+ *
+ * ✓ Good:
+ *   export enum HttpMethodEnum {
+ *       DELETE = "delete",
+ *       GET = "get",
+ *       POST = "post",
+ *   }
+ *
+ * ✗ Bad:
+ *   export enum HttpMethod {           // Missing "Enum" suffix
+ *       delete = "delete";             // lowercase and semicolon
+ *
+ *       Get = "get";                   // PascalCase, empty line, semicolon
+ *   }
+ */
+/*
+ * type-format
+ *
+ * Enforce consistent formatting for TypeScript type aliases:
+ * - Type name must be PascalCase and end with "Type" suffix
+ * - If object-like, properties must be in camelCase
+ * - No empty lines between properties (for object types)
+ * - Each property must end with comma (,) not semicolon (;)
+ *
+ * ✓ Good:
+ *   export type UserType = {
+ *       firstName: string,
+ *       lastName: string,
+ *   }
+ *
+ *   export type IdType = string | number;
+ *
+ * ✗ Bad:
+ *   export type User = {             // Missing "Type" suffix
+ *       first_name: string;          // snake_case and semicolon
+ *   }
+ */
+const typeFormat = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        const pascalCaseRegex = /^[A-Z][a-zA-Z0-9]*$/;
+        const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
+
+        const checkTypeLiteralHandler = (node, members) => {
+            members.forEach((member, index) => {
+                // Check property name is camelCase
+                if (member.type === "TSPropertySignature" && member.key && member.key.type === "Identifier") {
+                    const propName = member.key.name;
+
+                    if (!camelCaseRegex.test(propName)) {
+                        context.report({
+                            message: `Type property "${propName}" must be camelCase`,
+                            node: member.key,
+                        });
+                    }
+                }
+
+                // Check for empty lines between properties
+                if (index > 0) {
+                    const prevMember = members[index - 1];
+                    const currentLine = member.loc.start.line;
+                    const prevLine = prevMember.loc.end.line;
+
+                    if (currentLine - prevLine > 1) {
+                        context.report({
+                            fix(fixer) {
+                                const textBetween = sourceCode.getText().slice(
+                                    prevMember.range[1],
+                                    member.range[0],
+                                );
+                                const newText = textBetween.replace(/\n\s*\n/g, "\n");
+
+                                return fixer.replaceTextRange(
+                                    [prevMember.range[1], member.range[0]],
+                                    newText,
+                                );
+                            },
+                            message: "No empty lines allowed between type properties",
+                            node: member,
+                        });
+                    }
+                }
+
+                // Check property ends with comma, not semicolon
+                const memberText = sourceCode.getText(member);
+
+                if (memberText.trimEnd().endsWith(";")) {
+                    context.report({
+                        fix(fixer) {
+                            const lastChar = memberText.lastIndexOf(";");
+                            const absolutePos = member.range[0] + lastChar;
+
+                            return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
+                        },
+                        message: "Type properties must end with comma (,) not semicolon (;)",
+                        node: member,
+                    });
+                }
+            });
+        };
+
+        return {
+            TSTypeAliasDeclaration(node) {
+                const typeName = node.id.name;
+
+                // Check type name is PascalCase and ends with Type
+                if (!pascalCaseRegex.test(typeName)) {
+                    context.report({
+                        message: `Type name "${typeName}" must be PascalCase`,
+                        node: node.id,
+                    });
+                } else if (!typeName.endsWith("Type")) {
+                    context.report({
+                        fix(fixer) {
+                            return fixer.replaceText(node.id, `${typeName}Type`);
+                        },
+                        message: `Type name "${typeName}" must end with "Type" suffix`,
+                        node: node.id,
+                    });
+                }
+
+                // Check if it's an object type (TSTypeLiteral)
+                if (node.typeAnnotation && node.typeAnnotation.type === "TSTypeLiteral") {
+                    checkTypeLiteralHandler(node, node.typeAnnotation.members);
+                }
+
+                // Also check intersection types that contain object types
+                if (node.typeAnnotation && node.typeAnnotation.type === "TSIntersectionType") {
+                    node.typeAnnotation.types.forEach((type) => {
+                        if (type.type === "TSTypeLiteral") {
+                            checkTypeLiteralHandler(node, type.members);
+                        }
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce type naming (PascalCase + Type suffix), camelCase properties, no empty lines, and trailing commas" },
+        fixable: "code",
+        schema: [],
+        type: "suggestion",
+    },
+};
+
+const enumFormat = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        const pascalCaseRegex = /^[A-Z][a-zA-Z0-9]*$/;
+        const upperCaseRegex = /^[A-Z][A-Z0-9_]*$/;
+
+        return {
+            TSEnumDeclaration(node) {
+                const enumName = node.id.name;
+
+                // Check enum name is PascalCase and ends with Enum
+                if (!pascalCaseRegex.test(enumName)) {
+                    context.report({
+                        message: `Enum name "${enumName}" must be PascalCase`,
+                        node: node.id,
+                    });
+                } else if (!enumName.endsWith("Enum")) {
+                    context.report({
+                        fix(fixer) {
+                            return fixer.replaceText(node.id, `${enumName}Enum`);
+                        },
+                        message: `Enum name "${enumName}" must end with "Enum" suffix`,
+                        node: node.id,
+                    });
+                }
+
+                // Check members
+                const members = node.members;
+
+                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)) {
+                            context.report({
+                                message: `Enum member "${memberName}" must be UPPER_CASE (e.g., ${memberName.toUpperCase()})`,
+                                node: member.id,
+                            });
+                        }
+                    }
+
+                    // Check for empty lines between members
+                    if (index > 0) {
+                        const prevMember = members[index - 1];
+                        const currentLine = member.loc.start.line;
+                        const prevLine = prevMember.loc.end.line;
+
+                        if (currentLine - prevLine > 1) {
+                            context.report({
+                                fix(fixer) {
+                                    const textBetween = sourceCode.getText().slice(
+                                        prevMember.range[1],
+                                        member.range[0],
+                                    );
+                                    const newText = textBetween.replace(/\n\s*\n/g, "\n");
+
+                                    return fixer.replaceTextRange(
+                                        [prevMember.range[1], member.range[0]],
+                                        newText,
+                                    );
+                                },
+                                message: "No empty lines allowed between enum members",
+                                node: member,
+                            });
+                        }
+                    }
+
+                    // Check member ends with comma, not semicolon
+                    const memberText = sourceCode.getText(member);
+
+                    if (memberText.trimEnd().endsWith(";")) {
+                        context.report({
+                            fix(fixer) {
+                                const lastChar = memberText.lastIndexOf(";");
+                                const absolutePos = member.range[0] + lastChar;
+
+                                return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
+                            },
+                            message: "Enum members must end with comma (,) not semicolon (;)",
+                            node: member,
+                        });
+                    }
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce enum naming (PascalCase + Enum suffix), UPPER_CASE members, no empty lines, and trailing commas" },
+        fixable: "code",
+        schema: [],
+        type: "suggestion",
+    },
+};
+
+const interfaceFormat = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        const pascalCaseRegex = /^[A-Z][a-zA-Z0-9]*$/;
+        const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
+
+        return {
+            TSInterfaceDeclaration(node) {
+                const interfaceName = node.id.name;
+
+                // Check interface name is PascalCase and ends with Interface
+                if (!pascalCaseRegex.test(interfaceName)) {
+                    context.report({
+                        message: `Interface name "${interfaceName}" must be PascalCase`,
+                        node: node.id,
+                    });
+                } else if (!interfaceName.endsWith("Interface")) {
+                    context.report({
+                        fix(fixer) {
+                            return fixer.replaceText(node.id, `${interfaceName}Interface`);
+                        },
+                        message: `Interface name "${interfaceName}" must end with "Interface" suffix`,
+                        node: node.id,
+                    });
+                }
+
+                // Check properties
+                const members = node.body.body;
+
+                members.forEach((member, index) => {
+                    // Check property name is camelCase
+                    if (member.type === "TSPropertySignature" && member.key && member.key.type === "Identifier") {
+                        const propName = member.key.name;
+
+                        if (!camelCaseRegex.test(propName)) {
+                            context.report({
+                                message: `Interface property "${propName}" must be camelCase`,
+                                node: member.key,
+                            });
+                        }
+                    }
+
+                    // Check for empty lines between properties
+                    if (index > 0) {
+                        const prevMember = members[index - 1];
+                        const currentLine = member.loc.start.line;
+                        const prevLine = prevMember.loc.end.line;
+
+                        if (currentLine - prevLine > 1) {
+                            context.report({
+                                fix(fixer) {
+                                    const textBetween = sourceCode.getText().slice(
+                                        prevMember.range[1],
+                                        member.range[0],
+                                    );
+                                    const newText = textBetween.replace(/\n\s*\n/g, "\n");
+
+                                    return fixer.replaceTextRange(
+                                        [prevMember.range[1], member.range[0]],
+                                        newText,
+                                    );
+                                },
+                                message: "No empty lines allowed between interface properties",
+                                node: member,
+                            });
+                        }
+                    }
+
+                    // Check property ends with comma, not semicolon
+                    const memberText = sourceCode.getText(member);
+
+                    if (memberText.trimEnd().endsWith(";")) {
+                        context.report({
+                            fix(fixer) {
+                                const lastChar = memberText.lastIndexOf(";");
+                                const absolutePos = member.range[0] + lastChar;
+
+                                return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
+                            },
+                            message: "Interface properties must end with comma (,) not semicolon (;)",
+                            node: member,
+                        });
+                    }
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce interface naming (PascalCase + Interface suffix), camelCase properties, no empty lines, and trailing commas" },
+        fixable: "code",
+        schema: [],
+        type: "suggestion",
+    },
+};
+
+const typescriptDefinitionLocation = {
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        const normalizedFilename = filename.replace(/\\/g, "/");
+
+        const isInFolderHandler = (folderName) => {
+            const pattern = new RegExp(`/${folderName}/[^/]+\\.(ts|tsx)$`);
+
+            return pattern.test(normalizedFilename);
+        };
+
+        const isTypeScriptFileHandler = () => /\.(ts|tsx)$/.test(normalizedFilename);
+
+        return {
+            TSInterfaceDeclaration(node) {
+                if (!isTypeScriptFileHandler()) return;
+
+                if (!isInFolderHandler("interfaces")) {
+                    context.report({
+                        message: "Interfaces must be declared in files inside the \"interfaces\" folder",
+                        node: node.id || node,
+                    });
+                }
+            },
+            TSEnumDeclaration(node) {
+                if (!isTypeScriptFileHandler()) return;
+
+                if (!isInFolderHandler("enums")) {
+                    context.report({
+                        message: "Enums must be declared in files inside the \"enums\" folder",
+                        node: node.id || node,
+                    });
+                }
+            },
+            TSTypeAliasDeclaration(node) {
+                if (!isTypeScriptFileHandler()) return;
+
+                if (!isInFolderHandler("types")) {
+                    context.report({
+                        message: "Type aliases must be declared in files inside the \"types\" folder",
+                        node: node.id || node,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce that interfaces are in interfaces folder, enums in enums folder, and types in types folder" },
+        schema: [],
+        type: "suggestion",
+    },
+};
+
 export default {
     meta: {
         name: packageJson.name,
@@ -8481,28 +8951,33 @@ export default {
         "arrow-function-simplify": arrowFunctionSimplify,
         "curried-arrow-same-line": curriedArrowSameLine,
 
-        // Assignment rules
-        "assignment-value-same-line": assignmentValueSameLine,
-
-        // Block statement rules
-        "block-statement-newlines": blockStatementNewlines,
+        // Call expression rules
+        "function-arguments-format": functionArgumentsFormat,
+        "nested-call-closing-brackets": nestedCallClosingBrackets,
+        "no-empty-lines-in-function-calls": noEmptyLinesInFunctionCalls,
+        "opening-brackets-same-line": openingBracketsSameLine,
+        "simple-call-single-line": simpleCallSingleLine,
+        "single-argument-on-one-line": singleArgumentOnOneLine,
 
         // Comment rules
         "comment-format": commentFormat,
 
+        // Control flow rules
+        "block-statement-newlines": blockStatementNewlines,
+        "if-statement-format": ifStatementFormat,
+        "multiline-if-conditions": multilineIfConditions,
+        "no-empty-lines-in-switch-cases": noEmptyLinesInSwitchCases,
+
         // Function rules
         "function-call-spacing": functionCallSpacing,
         "function-naming-convention": functionNamingConvention,
         "function-params-per-line": functionParamsPerLine,
+        "no-empty-lines-in-function-params": noEmptyLinesInFunctionParams,
 
         // Hook rules
         "hook-callback-format": hookCallbackFormat,
         "hook-deps-per-line": hookDepsPerLine,
 
-        // If statement rules
-        "if-statement-format": ifStatementFormat,
-        "multiline-if-conditions": multilineIfConditions,
-
         // Import/Export rules
         "absolute-imports-only": absoluteImportsOnly,
         "export-format": exportFormat,
@@ -8521,37 +8996,24 @@ export default {
         "jsx-simple-element-one-line": jsxSimpleElementOneLine,
         "jsx-string-value-trim": jsxStringValueTrim,
         "jsx-ternary-format": jsxTernaryFormat,
-
-        // Member expression rules
-        "member-expression-bracket-spacing": memberExpressionBracketSpacing,
-
-        // Function arguments formatting rule
-        "function-arguments-format": functionArgumentsFormat,
-
-        // Nested call rules
-        "nested-call-closing-brackets": nestedCallClosingBrackets,
-
-        // No empty lines rules
-        "no-empty-lines-in-function-calls": noEmptyLinesInFunctionCalls,
-        "no-empty-lines-in-function-params": noEmptyLinesInFunctionParams,
         "no-empty-lines-in-jsx": noEmptyLinesInJsx,
-        "no-empty-lines-in-objects": noEmptyLinesInObjects,
-        "no-empty-lines-in-switch-cases": noEmptyLinesInSwitchCases,
 
-        // Object property rules
+        // Object rules
+        "no-empty-lines-in-objects": noEmptyLinesInObjects,
         "object-property-per-line": objectPropertyPerLine,
         "object-property-value-brace": objectPropertyValueBrace,
         "object-property-value-format": objectPropertyValueFormat,
+        "string-property-spacing": stringPropertySpacing,
 
-        // Opening brackets rules
-        "opening-brackets-same-line": openingBracketsSameLine,
-
-        // Simple call/Single argument rules
-        "simple-call-single-line": simpleCallSingleLine,
-        "single-argument-on-one-line": singleArgumentOnOneLine,
+        // Spacing rules
+        "assignment-value-same-line": assignmentValueSameLine,
+        "member-expression-bracket-spacing": memberExpressionBracketSpacing,
 
-        // String property rules
-        "string-property-spacing": stringPropertySpacing,
+        // TypeScript rules
+        "enum-format": enumFormat,
+        "interface-format": interfaceFormat,
+        "type-format": typeFormat,
+        "typescript-definition-location": typescriptDefinitionLocation,
 
         // Variable rules
         "variable-naming-convention": variableNamingConvention,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.0.41",
+    "version": "1.1.10",
     "description": "A custom ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects",
     "main": "index.js",
     "types": "index.d.ts",