@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.2

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceIdCapitalization = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * 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 node is in a context that should be excluded from the rule
+         * (e.g., parameter names, property names, type definitions)
+         */
+        function isExcludedContext(node) {
+            // Check if the node is a property of an object pattern (destructuring)
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) &&
+                node.parent.key === node) {
+                return true;
+            }
+            // Check if the node is a parameter name
+            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)) {
+                return true;
+            }
+            // Check if the node is part of a type definition
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.TSPropertySignature ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSParameterProperty ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference)) {
+                return true;
+            }
+            // Check if the node is a variable name
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id === node) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Check if a string contains "id" as a standalone word and report if found
+         */
+        function checkForIdInString(node, value) {
+            if (typeof value !== 'string')
+                return;
+            // Skip checking if the node is in an excluded context
+            if (isExcludedContext(node))
+                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 === utils_1.AST_NODE_TYPES.Literal) {
+                            return fixer.replaceText(node, JSON.stringify(fixedText));
+                        }
+                        else if (node.type === utils_1.AST_NODE_TYPES.JSXText) {
+                            return fixer.replaceText(node, fixedText);
+                        }
+                        else if (node.type === utils_1.AST_NODE_TYPES.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-object-literal-as-const.js

@@ -18,6 +18,36 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        /**
+         * Checks if the node is inside a React hook like useMemo
+         */
+        function isInsideReactHook(ancestors) {
+            for (let i = 0; i < ancestors.length; i++) {
+                const ancestor = ancestors[i];
+                // Check for CallExpression (function call)
+                if (ancestor.type === 'CallExpression') {
+                    const callee = ancestor.callee;
+                    // Check if it's a hook like useMemo, useCallback, etc.
+                    if (callee.type === 'Identifier' &&
+                        (callee.name === 'useMemo' ||
+                            callee.name === 'useCallback' ||
+                            callee.name.startsWith('use'))) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        /**
+         * Checks if an array contains object literals that might be used as component props
+         */
+        function isArrayWithObjectLiterals(node) {
+            if (node.type !== 'ArrayExpression') {
+                return false;
+            }
+            // Check if any element in the array is an object literal
+            return node.elements.some((elem) => elem !== null && elem.type === 'ObjectExpression');
+        }
         return {
             ReturnStatement(node) {
                 // Skip if there's no argument in the return statement
@@ -66,6 +96,13 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                         argument.elements.some((elem) => elem !== null && elem.type === 'SpreadElement'))) {
                     return;
                 }
+                // Skip arrays with object literals inside React hooks (likely component props)
+                if (isInsideReactHook(ancestors) &&
+                    isArrayWithObjectLiterals(argument.type === 'TSAsExpression'
+                        ? argument.expression
+                        : argument)) {
+                    return;
+                }
                 // Report the issue and provide a fix
                 context.report({
                     node,

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

@@ -3,60 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforcePositiveNaming = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-// Common negative prefixes and words to detect
-const NEGATIVE_PREFIXES = ['not', 'no', 'non', 'un', 'in', 'dis'];
-const NEGATIVE_WORDS = [
-    'invalid',
-    'disabled',
-    'incomplete',
-    'unpaid',
-    'inactive',
-    'disallowed',
-    'unauthorized',
-    'unverified',
-    'prevent',
-    'avoid',
-    'block',
-    'deny',
-    'reject',
-    'exclude',
-    'fail',
-    'missing',
-    'forbidden',
-    'impossible',
-    'error',
-    'broken',
-    'banned',
-    'restricted',
-    'limitation',
-    'limitation',
-    'blocked',
-    'prohibited',
-];
-// Whitelist of acceptable negative terms (technical terms, common patterns)
-const ALLOWED_NEGATIVE_TERMS = new Set([
-    'isNaN',
-    'isNull',
-    'isUndefined',
-    'isEmpty',
-    'isOffline',
-    'isMissing',
-    'isOutOfStock',
-    'isOutOfBounds',
-    'isOffPeak',
-    'isNoticeable',
-    'hasNotification',
-    'isNoteworthy',
-    'isNone',
-    'isNegative',
-    'isNeutral',
-    'isNotification',
-    'isNote',
-    'hasNote',
-]);
-// Map of negative terms to suggested positive alternatives
-const POSITIVE_ALTERNATIVES = {
-    // Prefixes
+// Common negative prefixes for boolean variables
+const BOOLEAN_NEGATIVE_PREFIXES = ['not', 'no', 'non', 'un', 'in', 'dis'];
+// Map of negative boolean terms to suggested positive alternatives
+const BOOLEAN_POSITIVE_ALTERNATIVES = {
+    // Boolean prefixes
     'isNot': ['is'],
     'isUn': ['is'],
     'isDis': ['is'],
@@ -68,54 +19,13 @@ const POSITIVE_ALTERNATIVES = {
     'shouldNot': ['should'],
     'willNot': ['will'],
     'doesNot': ['does'],
-    // Words
-    'isInvalid': ['isValid'],
-    'isDisabled': ['isEnabled'],
-    'isIncomplete': ['isComplete'],
-    'isUnpaid': ['isPaid', 'hasPaid'],
-    'isInactive': ['isActive'],
-    'isDisallowed': ['isAllowed'],
-    'isUnauthorized': ['isAuthorized'],
-    'isUnverified': ['isVerified'],
-    'isImpossible': ['isPossible'],
-    'isError': ['isSuccess', 'isValid'],
-    'isBroken': ['isWorking', 'isFunctional'],
-    'isBanned': ['isAllowed', 'isPermitted'],
-    'isRestricted': ['isAllowed', 'isAccessible'],
-    'isBlocked': ['isAllowed', 'isAccessible'],
-    'isProhibited': ['isAllowed', 'isPermitted'],
-    'prevent': ['allow', 'enable'],
-    'avoid': ['use', 'prefer'],
-    'block': ['allow', 'permit'],
-    'deny': ['allow', 'grant'],
-    'reject': ['accept', 'approve'],
-    'exclude': ['include'],
-    'fail': ['succeed', 'pass'],
-    'missing': ['present', 'available'],
-    'forbidden': ['allowed', 'permitted'],
-    'disabled': ['enabled'],
-    'incomplete': ['complete'],
-    'invalid': ['valid'],
-    'disallowed': ['allowed'],
-    'unauthorized': ['authorized'],
-    'unverified': ['verified'],
-    'inactive': ['active'],
-    'disabledFeatures': ['enabledFeatures'],
-    'inactiveUsers': ['activeUsers'],
-    'disableFeature': ['enableFeature'],
-    'disableAccount': ['enableAccount'],
-    'blockUser': ['allowUser'],
-    'preventAccess': ['allowAccess', 'enableAccess'],
-    'restrictAccess': ['allowAccess', 'grantAccess'],
-    'limitations': ['capabilities', 'features'],
-    'limitation': ['capability', 'feature'],
 };
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce positive variable naming patterns and avoid negative naming',
+            description: 'Enforce positive naming for boolean variables and avoid negations',
             recommended: 'error',
         },
         schema: [],
@@ -125,76 +35,95 @@ 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
+         * Check if a name has boolean negative naming
          */
-        function hasNegativeNaming(name) {
-            // Skip checking if the name is in the whitelist
-            if (ALLOWED_NEGATIVE_TERMS.has(name)) {
-                return { isNegative: false, alternatives: [] };
-            }
+        function hasBooleanNegativeNaming(name) {
             // Check for exact matches in our alternatives map first
-            if (POSITIVE_ALTERNATIVES[name]) {
-                return { isNegative: true, alternatives: POSITIVE_ALTERNATIVES[name] };
+            if (BOOLEAN_POSITIVE_ALTERNATIVES[name]) {
+                return { isNegative: true, alternatives: BOOLEAN_POSITIVE_ALTERNATIVES[name] };
             }
-            // Check for negative prefixes
-            for (const prefix of NEGATIVE_PREFIXES) {
-                // Check for patterns like isNot, hasNo, canNot, etc.
-                const prefixPatterns = [
-                    { pattern: new RegExp(`^is${prefix}`, 'i'), key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^has${prefix}`, 'i'), key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^can${prefix}`, 'i'), key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^should${prefix}`, 'i'), key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^will${prefix}`, 'i'), key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                    { pattern: new RegExp(`^does${prefix}`, 'i'), key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
-                ];
-                for (const { pattern, key } of prefixPatterns) {
-                    if (pattern.test(name)) {
-                        // If we have a direct match for this pattern (like isNotVerified -> isVerified)
-                        const directMatch = POSITIVE_ALTERNATIVES[name];
-                        if (directMatch) {
-                            return { isNegative: true, alternatives: directMatch };
-                        }
-                        const alternatives = POSITIVE_ALTERNATIVES[key] || [];
-                        if (alternatives.length > 0) {
-                            // Suggest the positive version with the rest of the name
-                            const restOfName = name.replace(pattern, '');
-                            const suggestedAlternatives = alternatives.map(alt => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
-                            return { isNegative: true, alternatives: suggestedAlternatives };
+            // Check for negative prefixes in boolean-like variables
+            if (name.startsWith('is') || name.startsWith('has') || name.startsWith('can') ||
+                name.startsWith('should') || name.startsWith('will') || name.startsWith('does')) {
+                for (const prefix of BOOLEAN_NEGATIVE_PREFIXES) {
+                    // Check for patterns like isNot, hasNo, canNot, etc.
+                    const prefixPatterns = [
+                        { pattern: new RegExp(`^is${prefix}`, 'i'), key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^has${prefix}`, 'i'), key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^can${prefix}`, 'i'), key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^should${prefix}`, 'i'), key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^will${prefix}`, 'i'), key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                        { pattern: new RegExp(`^does${prefix}`, 'i'), key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}` },
+                    ];
+                    for (const { pattern, key } of prefixPatterns) {
+                        if (pattern.test(name)) {
+                            // If we have a direct match for this pattern (like isNotVerified -> isVerified)
+                            const directMatch = BOOLEAN_POSITIVE_ALTERNATIVES[name];
+                            if (directMatch) {
+                                return { isNegative: true, alternatives: directMatch };
+                            }
+                            const alternatives = BOOLEAN_POSITIVE_ALTERNATIVES[key] || [];
+                            if (alternatives.length > 0) {
+                                // Suggest the positive version with the rest of the name
+                                const restOfName = name.replace(pattern, '');
+                                const suggestedAlternatives = alternatives.map(alt => `${alt}${restOfName.charAt(0).toUpperCase() + restOfName.slice(1)}`);
+                                return { isNegative: true, alternatives: suggestedAlternatives };
+                            }
+                            return { isNegative: true, alternatives: ['a positive alternative'] };
                         }
-                        return { isNegative: true, alternatives: ['a positive alternative'] };
                     }
                 }
             }
-            // Check for exact negative words
-            for (const word of NEGATIVE_WORDS) {
-                if (name.toLowerCase() === word.toLowerCase()) {
-                    const alternatives = POSITIVE_ALTERNATIVES[word] || [];
-                    return {
-                        isNegative: true,
-                        alternatives: alternatives.length ? alternatives : ['a positive alternative']
-                    };
-                }
+            return { isNegative: false, alternatives: [] };
+        }
+        /**
+         * Safely formats alternatives for display
+         */
+        function formatAlternatives(alternatives) {
+            if (Array.isArray(alternatives)) {
+                return alternatives.join(', ');
             }
-            // Check for negative words in camelCase/PascalCase
-            for (const word of NEGATIVE_WORDS) {
-                // Match the word at the beginning or after a capital letter
-                const pattern = new RegExp(`(^|[A-Z])${word}($|[A-Z])`, 'i');
-                if (pattern.test(name)) {
-                    // For compound names like isInvalid, check if we have a specific suggestion
-                    const exactMatch = `is${word.charAt(0).toUpperCase() + word.slice(1)}`;
-                    if (POSITIVE_ALTERNATIVES[exactMatch]) {
-                        return { isNegative: true, alternatives: POSITIVE_ALTERNATIVES[exactMatch] };
-                    }
-                    // Otherwise suggest general alternatives for the negative word
-                    const alternatives = POSITIVE_ALTERNATIVES[word] || [];
-                    return {
-                        isNegative: true,
-                        alternatives: alternatives.length ? alternatives : ['a positive alternative']
-                    };
-                }
+            return String(alternatives);
+        }
+        /**
+         * Check if a node is likely to be a boolean
+         */
+        function isBooleanLike(node) {
+            // Check if the node has a boolean type annotation
+            if (node.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                return true;
             }
-            return { isNegative: false, alternatives: [] };
+            // Check if the node is initialized with a boolean literal
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.init?.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.parent.init.value === 'boolean') {
+                return true;
+            }
+            // Check if the node has a name that suggests it's a boolean
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                (node.name.startsWith('is') || node.name.startsWith('has') ||
+                    node.name.startsWith('can') || node.name.startsWith('should') ||
+                    node.name.startsWith('will') || node.name.startsWith('does'))) {
+                return true;
+            }
+            return false;
         }
         /**
          * Check variable declarations for negative naming
@@ -202,15 +131,18 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkVariableDeclaration(node) {
             if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean-like variables
+            if (!isBooleanLike(node.id) && !isBooleanLike(node))
+                return;
             const variableName = node.id.name;
-            const { isNegative, alternatives } = hasNegativeNaming(variableName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(variableName);
             if (isNegative) {
                 context.report({
                     node: node.id,
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: variableName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -239,14 +171,17 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
             if (!functionName)
                 return;
-            const { isNegative, alternatives } = hasNegativeNaming(functionName);
+            // Only check boolean-returning functions
+            if (!isBooleanLike(node.id || node))
+                return;
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(functionName);
             if (isNegative) {
                 context.report({
                     node: node.id || node,
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: functionName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -257,15 +192,18 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkMethodDefinition(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean-returning methods
+            if (!isBooleanLike(node.key))
+                return;
             const methodName = node.key.name;
-            const { isNegative, alternatives } = hasNegativeNaming(methodName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(methodName);
             if (isNegative) {
                 context.report({
                     node: node.key,
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: methodName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -276,15 +214,18 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkProperty(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean properties
+            if (!isBooleanLike(node.key))
+                return;
             const propertyName = node.key.name;
-            const { isNegative, alternatives } = hasNegativeNaming(propertyName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);
             if (isNegative) {
                 context.report({
                     node: node.key,
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: propertyName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -295,15 +236,19 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkPropertySignature(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean properties
+            if (!isBooleanLike(node.key) &&
+                !(node.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword))
+                return;
             const propertyName = node.key.name;
-            const { isNegative, alternatives } = hasNegativeNaming(propertyName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);
             if (isNegative) {
                 context.report({
                     node: node.key,
                     messageId: 'avoidNegativeNaming',
                     data: {
                         name: propertyName,
-                        alternatives: alternatives.join(', '),
+                        alternatives: formatAlternatives(alternatives),
                     },
                 });
             }
@@ -314,15 +259,18 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
         function checkParameter(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            // Only check boolean parameters
+            if (!isBooleanLike(node))
+                return;
             const paramName = node.name;
-            const { isNegative, alternatives } = hasNegativeNaming(paramName);
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(paramName);
             if (isNegative) {
                 context.report({
                     node,
                     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 {};