@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.1

package/lib/rules/enforce-id-capitalization.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceIdCapitalization = void 0;
+const createRule_1 = require("../utils/createRule");
+/**
+ * This rule ensures consistency in user-facing text by enforcing the use of "ID"
+ * instead of "id" when referring to identifiers in UI labels, instructions,
+ * error messages, and other visible strings.
+ */
+exports.enforceIdCapitalization = (0, createRule_1.createRule)({
+    name: 'enforce-id-capitalization',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of "ID" instead of "id" in user-facing text',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceIdCapitalization: 'Use "ID" instead of "id" in user-facing text for better readability',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Regular expression to match standalone "id" surrounded by whitespace or punctuation
+        // This ensures we only match "id" as a word, not as part of another word
+        const idRegex = /(^|\s|[.,;:!?'"()\[\]{}])id(\s|$|[.,;:!?'"()\[\]{}])/g;
+        /**
+         * Check if a string contains "id" as a standalone word and report if found
+         */
+        function checkForIdInString(node, value) {
+            if (typeof value !== 'string')
+                return;
+            // Reset the regex lastIndex to ensure consistent behavior
+            idRegex.lastIndex = 0;
+            // Check if the string contains "id" as a standalone word
+            if (idRegex.test(value)) {
+                // Reset the regex lastIndex again before replacing
+                idRegex.lastIndex = 0;
+                const fixedText = value.replace(idRegex, (_match, prefix, suffix) => {
+                    return `${prefix}ID${suffix}`;
+                });
+                context.report({
+                    node,
+                    messageId: 'enforceIdCapitalization',
+                    fix: (fixer) => {
+                        if (node.type === 'Literal') {
+                            return fixer.replaceText(node, JSON.stringify(fixedText));
+                        }
+                        else if (node.type === 'JSXText') {
+                            return fixer.replaceText(node, fixedText);
+                        }
+                        else if (node.type === 'TemplateElement') {
+                            return fixer.replaceText(node, fixedText);
+                        }
+                        return fixer.replaceText(node, JSON.stringify(fixedText));
+                    },
+                });
+            }
+        }
+        return {
+            // Check string literals
+            Literal(node) {
+                if (typeof node.value === 'string') {
+                    checkForIdInString(node, node.value);
+                }
+            },
+            // Check JSX text
+            JSXText(node) {
+                checkForIdInString(node, node.value);
+            },
+            // We don't need a separate handler for CallExpression since we already handle Literals
+            // The Literal handler will catch the string arguments in t("user.profile.id")
+        };
+    },
+});
+//# sourceMappingURL=enforce-id-capitalization.js.map

package/lib/rules/enforce-mui-rounded-icons.d.ts

@@ -0,0 +1 @@
+export declare const enforceMuiRoundedIcons: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceRoundedVariant", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-mui-rounded-icons.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceMuiRoundedIcons = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
+    name: 'enforce-mui-rounded-icons',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of -Rounded variant for MUI icons',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceRoundedVariant: 'Use the -Rounded variant for MUI icons (e.g., LogoutRounded instead of Logout)',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                // Only check imports from @mui/icons-material
+                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.source.value === 'string' &&
+                    node.source.value.startsWith('@mui/icons-material/')) {
+                    const iconPath = node.source.value;
+                    // Skip if already using -Rounded variant
+                    if (iconPath.endsWith('Rounded')) {
+                        return;
+                    }
+                    // Extract the icon name from the path
+                    const iconName = iconPath.split('/').pop();
+                    // Skip if the icon name is not a string (shouldn't happen)
+                    if (!iconName) {
+                        return;
+                    }
+                    // Create the rounded variant name
+                    const roundedVariant = `${iconName}Rounded`;
+                    context.report({
+                        node,
+                        messageId: 'enforceRoundedVariant',
+                        fix: (fixer) => {
+                            // Replace the import path with the rounded variant
+                            return fixer.replaceText(node.source, `'@mui/icons-material/${roundedVariant}'`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-mui-rounded-icons.js.map

package/lib/rules/enforce-positive-naming.js

@@ -125,6 +125,21 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // Get the filename from the context
+        const filename = context.getFilename();
+        // Skip checking for files that should be ignored
+        // 1. Files that are not .ts or .tsx
+        // 2. Files starting with .
+        // 3. Files containing .config
+        // 4. Files containing rc suffix
+        if ((!filename.endsWith('.ts') && !filename.endsWith('.tsx')) ||
+            filename.split('/').pop()?.startsWith('.') ||
+            filename.includes('.config') ||
+            filename.includes('rc.') ||
+            filename.endsWith('rc')) {
+            // Return empty object to skip all checks for this file
+            return {};
+        }
         /**
          * Check if a name has negative connotations
          */
@@ -196,6 +211,15 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
             return { isNegative: false, alternatives: [] };
         }
+        /**
+         * Safely formats alternatives for display
+         */
+        function formatAlternatives(alternatives) {
+            if (Array.isArray(alternatives)) {
+                return alternatives.join(', ');
+            }
+            return String(alternatives);
+        }
         /**
          * Check variable declarations for negative naming
          */
@@ -210,7 +234,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: variableName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -246,7 +270,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: functionName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -265,7 +289,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: methodName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -284,7 +308,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: propertyName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -303,7 +327,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: propertyName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -322,7 +346,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: paramName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }

package/lib/rules/enforce-react-type-naming.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'reactNodeShouldBeLowercase' | 'componentTypeShouldBeUppercase';
+export declare const enforceReactTypeNaming: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-react-type-naming.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceReactTypeNaming = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Types that should have lowercase variable names
+const LOWERCASE_TYPES = ['ReactNode', 'JSX.Element'];
+// Types that should have uppercase variable names
+const UPPERCASE_TYPES = ['ComponentType', 'FC', 'FunctionComponent'];
+exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
+    name: 'enforce-react-type-naming',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce naming conventions for React types',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            reactNodeShouldBeLowercase: 'Variables or parameters of type "{{type}}" should use lowercase naming (e.g., "{{suggestion}}").',
+            componentTypeShouldBeUppercase: 'Variables or parameters of type "{{type}}" should use uppercase naming (e.g., "{{suggestion}}").',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Checks if a string starts with an uppercase letter
+         */
+        function isUppercase(str) {
+            return /^[A-Z]/.test(str);
+        }
+        /**
+         * Converts a string to start with lowercase
+         */
+        function toLowercase(str) {
+            if (!str)
+                return str;
+            return str.charAt(0).toLowerCase() + str.slice(1);
+        }
+        /**
+         * Converts a string to start with uppercase
+         */
+        function toUppercase(str) {
+            if (!str)
+                return str;
+            return str.charAt(0).toUpperCase() + str.slice(1);
+        }
+        /**
+         * Extracts the type name from a type annotation
+         */
+        function getTypeName(typeAnnotation) {
+            if (!typeAnnotation)
+                return null;
+            // Handle TSTypeReference (e.g., ReactNode, ComponentType)
+            if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                if (typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return typeAnnotation.typeName.name;
+                }
+                // Handle qualified names like JSX.Element
+                if (typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                    const left = typeAnnotation.typeName.left.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? typeAnnotation.typeName.left.name
+                        : '';
+                    const right = typeAnnotation.typeName.right.name;
+                    return `${left}.${right}`;
+                }
+            }
+            return null;
+        }
+        /**
+         * Checks if a node is a destructured variable
+         */
+        function isDestructured(node) {
+            return (node.parent?.type === utils_1.AST_NODE_TYPES.Property ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    (node.parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                        node.parent.id.type === utils_1.AST_NODE_TYPES.ArrayPattern)));
+        }
+        /**
+         * Checks if a node is a default import
+         */
+        function isDefaultImport(node) {
+            return (node.parent?.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                (node.parent?.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    node.parent.local.name !== node.parent.imported?.name));
+        }
+        /**
+         * Check variable declarations for React type naming conventions
+         */
+        function checkVariableDeclaration(node) {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            // Skip destructured variables
+            if (isDestructured(node.id))
+                return;
+            const variableName = node.id.name;
+            // Get the type annotation
+            const typeAnnotation = node.id.typeAnnotation?.typeAnnotation;
+            const typeName = getTypeName(typeAnnotation);
+            if (!typeName)
+                return;
+            // Check if it's a ReactNode or JSX.Element (should be lowercase)
+            if (LOWERCASE_TYPES.includes(typeName) && isUppercase(variableName)) {
+                const suggestion = toLowercase(variableName);
+                context.report({
+                    node: node.id,
+                    messageId: 'reactNodeShouldBeLowercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node.id, suggestion),
+                });
+            }
+            // Check if it's a ComponentType or FC (should be uppercase)
+            if (UPPERCASE_TYPES.includes(typeName) && !isUppercase(variableName)) {
+                const suggestion = toUppercase(variableName);
+                context.report({
+                    node: node.id,
+                    messageId: 'componentTypeShouldBeUppercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node.id, suggestion),
+                });
+            }
+        }
+        /**
+         * Check function parameters for React type naming conventions
+         */
+        function checkParameter(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            // Skip destructured parameters
+            if (isDestructured(node))
+                return;
+            // Skip default imports
+            if (isDefaultImport(node))
+                return;
+            const paramName = node.name;
+            // Get the type annotation
+            const typeAnnotation = node.typeAnnotation?.typeAnnotation;
+            const typeName = getTypeName(typeAnnotation);
+            if (!typeName)
+                return;
+            // Check if it's a ReactNode or JSX.Element (should be lowercase)
+            if (LOWERCASE_TYPES.includes(typeName) && isUppercase(paramName)) {
+                const suggestion = toLowercase(paramName);
+                context.report({
+                    node,
+                    messageId: 'reactNodeShouldBeLowercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node, suggestion),
+                });
+            }
+            // Check if it's a ComponentType or FC (should be uppercase)
+            if (UPPERCASE_TYPES.includes(typeName) && !isUppercase(paramName)) {
+                const suggestion = toUppercase(paramName);
+                context.report({
+                    node,
+                    messageId: 'componentTypeShouldBeUppercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node, suggestion),
+                });
+            }
+        }
+        return {
+            VariableDeclarator: checkVariableDeclaration,
+            Identifier(node) {
+                // Check parameter names in function declarations
+                if (node.parent &&
+                    (node.parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                    node.parent.params.includes(node)) {
+                    checkParameter(node);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-react-type-naming.js.map

package/lib/rules/enforce-singular-type-names.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceSingularTypeNames: TSESLint.RuleModule<'typeShouldBeSingular', never[]>;

package/lib/rules/enforce-singular-type-names.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceSingularTypeNames = void 0;
+const createRule_1 = require("../utils/createRule");
+const pluralize = __importStar(require("pluralize"));
+exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
+    create(context) {
+        /**
+         * Check if a name is plural
+         * @param name The name to check
+         * @returns true if the name is plural, false otherwise
+         */
+        function isPlural(name) {
+            // Skip checking if name is too short (less than 3 characters)
+            if (name.length < 3)
+                return false;
+            // Skip checking if name ends with 'Props' or 'Params'
+            if (name.endsWith('Props') || name.endsWith('Params'))
+                return false;
+            // Skip checking if name is already singular according to pluralize
+            if (pluralize.isSingular(name))
+                return false;
+            // Check if the singular form is different from the name
+            const singular = pluralize.singular(name);
+            return singular !== name;
+        }
+        /**
+         * Get the singular form of a name
+         * @param name The name to get the singular form of
+         * @returns The singular form of the name
+         */
+        function getSingularForm(name) {
+            return pluralize.singular(name);
+        }
+        /**
+         * Report a plural type name
+         * @param node The node to report
+         * @param name The plural name
+         * @param suggestedName The suggested singular name
+         */
+        function reportPluralName(node, name, suggestedName) {
+            context.report({
+                node,
+                messageId: 'typeShouldBeSingular',
+                data: {
+                    name,
+                    suggestedName,
+                },
+            });
+        }
+        return {
+            // Check type aliases
+            TSTypeAliasDeclaration(node) {
+                const name = node.id.name;
+                if (isPlural(name)) {
+                    reportPluralName(node.id, name, getSingularForm(name));
+                }
+            },
+            // Check interfaces
+            TSInterfaceDeclaration(node) {
+                const name = node.id.name;
+                if (isPlural(name)) {
+                    reportPluralName(node.id, name, getSingularForm(name));
+                }
+            },
+            // Check enums
+            TSEnumDeclaration(node) {
+                const name = node.id.name;
+                if (isPlural(name)) {
+                    reportPluralName(node.id, name, getSingularForm(name));
+                }
+            },
+        };
+    },
+    name: 'enforce-singular-type-names',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce TypeScript type names to be singular',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            typeShouldBeSingular: "Type name '{{name}}' should be singular. Consider using '{{suggestedName}}' instead.",
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=enforce-singular-type-names.js.map

package/lib/rules/enforce-verb-noun-naming.js

@@ -4651,10 +4651,13 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                         }
                     }
                     return false;
-                })()
+                })(),
+                // 5. Component name ends with "Unmemoized" (common React pattern)
+                functionName && functionName.endsWith('Unmemoized')
             ];
             // Consider it a React component if it matches at least 2 indicators
-            return indicators.filter(Boolean).length >= 2;
+            // OR if it has the Unmemoized suffix (strong indicator of a React component)
+            return indicators.filter(Boolean).length >= 2 || (!!functionName && functionName.endsWith('Unmemoized'));
         }
         return {
             FunctionDeclaration(node) {

package/lib/rules/ensure-pointer-events-none.d.ts

@@ -0,0 +1 @@
+export declare const ensurePointerEventsNone: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missingPointerEventsNone", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;