@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

package/lib/rules/enforce-object-literal-as-const.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceObjectLiteralAsConst = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
+    name: 'enforce-object-literal-as-const',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce that object literals returned from functions should be marked with `as const` to ensure type safety and immutability.',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        messages: {
+            enforceAsConst: 'Object literals returned from functions should be marked with `as const` to ensure type safety and immutability',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ReturnStatement(node) {
+                // Skip if there's no argument in the return statement
+                if (!node.argument) {
+                    return;
+                }
+                // Check if the return statement is inside a function
+                const sourceCode = context.getSourceCode();
+                // Use context.getAncestors() for now, but note it's deprecated
+                // We'll need to update this when upgrading to ESLint v9
+                const ancestors = context.getAncestors();
+                const isInFunction = ancestors.some((ancestor) => ancestor.type === 'FunctionDeclaration' ||
+                    ancestor.type === 'ArrowFunctionExpression' ||
+                    ancestor.type === 'FunctionExpression' ||
+                    ancestor.type === 'MethodDefinition');
+                if (!isInFunction) {
+                    return;
+                }
+                // Check if the return value is an object or array literal
+                const { argument } = node;
+                // Skip if the return value already has 'as const' assertion
+                if (argument.type === 'TSAsExpression') {
+                    const tsAsExpression = argument;
+                    // Check if the type annotation is 'const'
+                    if (tsAsExpression.typeAnnotation.type === 'TSTypeReference' &&
+                        tsAsExpression.typeAnnotation.typeName.type === 'Identifier' &&
+                        tsAsExpression.typeAnnotation.typeName.name === 'const') {
+                        return;
+                    }
+                    // If it has another type assertion but not 'as const', we still need to check
+                    // if the expression is an object/array literal
+                    if (tsAsExpression.expression.type !== 'ObjectExpression' &&
+                        tsAsExpression.expression.type !== 'ArrayExpression') {
+                        return;
+                    }
+                }
+                else if (argument.type !== 'ObjectExpression' &&
+                    argument.type !== 'ArrayExpression') {
+                    // Skip if not an object/array literal and not a type assertion
+                    return;
+                }
+                // Skip if the return value uses spread operator
+                if ((argument.type === 'ObjectExpression' &&
+                    argument.properties.some((prop) => prop.type === 'SpreadElement')) ||
+                    (argument.type === 'ArrayExpression' &&
+                        argument.elements.some((elem) => elem !== null && elem.type === 'SpreadElement'))) {
+                    return;
+                }
+                // Report the issue and provide a fix
+                context.report({
+                    node,
+                    messageId: 'enforceAsConst',
+                    fix(fixer) {
+                        const text = sourceCode.getText(argument);
+                        // If it's already a type assertion but not 'as const'
+                        if (argument.type === 'TSAsExpression') {
+                            // Get the expression part (before the 'as')
+                            const expressionText = sourceCode.getText(argument.expression);
+                            return fixer.replaceText(argument, `${expressionText} as const`);
+                        }
+                        return fixer.replaceText(argument, `${text} as const`);
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-object-literal-as-const.js.map

package/lib/rules/enforce-positive-naming.d.ts

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

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

@@ -0,0 +1,387 @@
+"use strict";
+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
+    'isNot': ['is'],
+    'isUn': ['is'],
+    'isDis': ['is'],
+    'isIn': ['is'],
+    'isNon': ['is'],
+    'hasNo': ['has'],
+    'hasNot': ['has'],
+    'canNot': ['can'],
+    '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',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            avoidNegativeNaming: 'Avoid negative naming "{{name}}". Consider using a positive alternative like: {{alternatives}}',
+        },
+    },
+    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
+         */
+        function hasNegativeNaming(name) {
+            // Skip checking if the name is in the whitelist
+            if (ALLOWED_NEGATIVE_TERMS.has(name)) {
+                return { isNegative: false, alternatives: [] };
+            }
+            // Check for exact matches in our alternatives map first
+            if (POSITIVE_ALTERNATIVES[name]) {
+                return { isNegative: true, alternatives: 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 };
+                        }
+                        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']
+                    };
+                }
+            }
+            // 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 { 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
+         */
+        function checkVariableDeclaration(node) {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const variableName = node.id.name;
+            const { isNegative, alternatives } = hasNegativeNaming(variableName);
+            if (isNegative) {
+                context.report({
+                    node: node.id,
+                    messageId: 'avoidNegativeNaming',
+                    data: {
+                        name: variableName,
+                        alternatives: formatAlternatives(alternatives),
+                    },
+                });
+            }
+        }
+        /**
+         * Check function declarations for negative naming
+         */
+        function checkFunctionDeclaration(node) {
+            // Skip anonymous functions
+            if (!node.id && node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return;
+            }
+            // Get function name from either the function declaration or variable declarator
+            let functionName = '';
+            if (node.id) {
+                functionName = node.id.name;
+            }
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                functionName = node.parent.id.name;
+            }
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                node.parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Handle object method shorthand
+                functionName = node.parent.key.name;
+            }
+            if (!functionName)
+                return;
+            const { isNegative, alternatives } = hasNegativeNaming(functionName);
+            if (isNegative) {
+                context.report({
+                    node: node.id || node,
+                    messageId: 'avoidNegativeNaming',
+                    data: {
+                        name: functionName,
+                        alternatives: formatAlternatives(alternatives),
+                    },
+                });
+            }
+        }
+        /**
+         * Check method definitions for negative naming
+         */
+        function checkMethodDefinition(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const methodName = node.key.name;
+            const { isNegative, alternatives } = hasNegativeNaming(methodName);
+            if (isNegative) {
+                context.report({
+                    node: node.key,
+                    messageId: 'avoidNegativeNaming',
+                    data: {
+                        name: methodName,
+                        alternatives: formatAlternatives(alternatives),
+                    },
+                });
+            }
+        }
+        /**
+         * Check property definitions for negative naming
+         */
+        function checkProperty(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = node.key.name;
+            const { isNegative, alternatives } = hasNegativeNaming(propertyName);
+            if (isNegative) {
+                context.report({
+                    node: node.key,
+                    messageId: 'avoidNegativeNaming',
+                    data: {
+                        name: propertyName,
+                        alternatives: formatAlternatives(alternatives),
+                    },
+                });
+            }
+        }
+        /**
+         * Check TSPropertySignature for negative naming (in interfaces)
+         */
+        function checkPropertySignature(node) {
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = node.key.name;
+            const { isNegative, alternatives } = hasNegativeNaming(propertyName);
+            if (isNegative) {
+                context.report({
+                    node: node.key,
+                    messageId: 'avoidNegativeNaming',
+                    data: {
+                        name: propertyName,
+                        alternatives: formatAlternatives(alternatives),
+                    },
+                });
+            }
+        }
+        /**
+         * Check parameter names for negative naming
+         */
+        function checkParameter(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const paramName = node.name;
+            const { isNegative, alternatives } = hasNegativeNaming(paramName);
+            if (isNegative) {
+                context.report({
+                    node,
+                    messageId: 'avoidNegativeNaming',
+                    data: {
+                        name: paramName,
+                        alternatives: formatAlternatives(alternatives),
+                    },
+                });
+            }
+        }
+        return {
+            VariableDeclarator: checkVariableDeclaration,
+            FunctionDeclaration: checkFunctionDeclaration,
+            // Only check function expressions when they're not part of a variable declaration
+            // to avoid duplicate errors
+            FunctionExpression(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    checkFunctionDeclaration(node);
+                }
+            },
+            // Only check arrow function expressions when they're not part of a variable declaration
+            // to avoid duplicate errors
+            ArrowFunctionExpression(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    checkFunctionDeclaration(node);
+                }
+            },
+            MethodDefinition: checkMethodDefinition,
+            Property: checkProperty,
+            TSPropertySignature: checkPropertySignature,
+            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-positive-naming.js.map

package/lib/rules/enforce-props-argument-name.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        enforceDestructuring?: boolean;
+        ignoreExternalInterfaces?: boolean;
+    }
+];
+export declare const enforcePropsArgumentName: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"usePropsForType", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-props-argument-name.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforcePropsArgumentName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = {
+    enforceDestructuring: false,
+    ignoreExternalInterfaces: true,
+};
+exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
+    name: 'enforce-props-argument-name',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using "Props" suffix in type names for parameter objects',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    enforceDestructuring: {
+                        type: 'boolean',
+                    },
+                    ignoreExternalInterfaces: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            usePropsForType: 'Use "Props" suffix in type name instead of "{{ typeSuffix }}"',
+        },
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [options]) {
+        const finalOptions = { ...defaultOptions, ...options };
+        // Check if a node is from an external library
+        function isFromExternalLibrary(node) {
+            if (!finalOptions.ignoreExternalInterfaces) {
+                return false;
+            }
+            let current = node;
+            while (current.parent) {
+                if (current.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                    // Check if the interface extends something from an external library
+                    const interfaceDecl = current;
+                    if (interfaceDecl.extends && interfaceDecl.extends.length > 0) {
+                        // Check if any of the extended interfaces are from external libraries
+                        // This is a simplified check - a more robust implementation would trace imports
+                        return true;
+                    }
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        // Extract type name from a type annotation
+        function getTypeName(typeAnnotation) {
+            if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                const typeName = typeAnnotation.typeName;
+                if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return typeName.name;
+                }
+            }
+            return null;
+        }
+        // Check if a type name has a non-"Props" suffix
+        function hasNonPropsSuffix(typeName) {
+            if (typeName.endsWith('Props')) {
+                return null;
+            }
+            const suffixes = ['Config', 'Settings', 'Options', 'Params', 'Parameters', 'Args', 'Arguments'];
+            for (const suffix of suffixes) {
+                if (typeName.endsWith(suffix)) {
+                    return suffix;
+                }
+            }
+            return null;
+        }
+        // Fix type name
+        function fixTypeName(fixer, node, oldName, suffix) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const baseName = oldName.slice(0, -suffix.length);
+                return fixer.replaceText(node.typeName, `${baseName}Props`);
+            }
+            return null;
+        }
+        // Check function parameters
+        function checkFunctionParams(node) {
+            if (node.params.length !== 1) {
+                return; // Only check functions with a single parameter
+            }
+            const param = node.params[0];
+            // Skip primitive parameters
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && (param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSStringKeyword ||
+                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSNumberKeyword ||
+                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword)) {
+                return;
+            }
+            // Check if the parameter has a type annotation
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                if (typeName) {
+                    const nonPropsSuffix = hasNonPropsSuffix(typeName);
+                    if (nonPropsSuffix) {
+                        context.report({
+                            node: param.typeAnnotation.typeAnnotation,
+                            messageId: 'usePropsForType',
+                            data: { typeSuffix: nonPropsSuffix },
+                            fix: (fixer) => fixTypeName(fixer, param.typeAnnotation.typeAnnotation, typeName, nonPropsSuffix),
+                        });
+                    }
+                }
+            }
+        }
+        // Check class constructor parameters
+        function checkClassConstructor(node) {
+            if (node.kind !== 'constructor') {
+                return;
+            }
+            const constructor = node.value;
+            if (constructor.params.length !== 1) {
+                return; // Only check constructors with a single parameter
+            }
+            const param = constructor.params[0];
+            // Skip primitive parameters
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && (param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSStringKeyword ||
+                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSNumberKeyword ||
+                param.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword)) {
+                return;
+            }
+            // Check if the parameter has a type annotation
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+                const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                if (typeName) {
+                    const nonPropsSuffix = hasNonPropsSuffix(typeName);
+                    if (nonPropsSuffix) {
+                        context.report({
+                            node: param.typeAnnotation.typeAnnotation,
+                            messageId: 'usePropsForType',
+                            data: { typeSuffix: nonPropsSuffix },
+                            fix: (fixer) => fixTypeName(fixer, param.typeAnnotation.typeAnnotation, typeName, nonPropsSuffix),
+                        });
+                    }
+                }
+            }
+        }
+        // Check type definitions
+        function checkTypeDefinition(node) {
+            if (!node.id || !node.id.name) {
+                return;
+            }
+            const typeName = node.id.name;
+            const nonPropsSuffix = hasNonPropsSuffix(typeName);
+            if (nonPropsSuffix && !isFromExternalLibrary(node)) {
+                const baseName = typeName.slice(0, -nonPropsSuffix.length);
+                const newTypeName = `${baseName}Props`;
+                context.report({
+                    node: node.id,
+                    messageId: 'usePropsForType',
+                    data: { typeSuffix: nonPropsSuffix },
+                    fix: (fixer) => {
+                        return fixer.replaceText(node.id, newTypeName);
+                    },
+                });
+            }
+        }
+        return {
+            FunctionDeclaration: checkFunctionParams,
+            FunctionExpression: checkFunctionParams,
+            ArrowFunctionExpression: checkFunctionParams,
+            TSMethodSignature: checkFunctionParams,
+            MethodDefinition: checkClassConstructor,
+            TSTypeAliasDeclaration: checkTypeDefinition,
+        };
+    },
+});
+//# sourceMappingURL=enforce-props-argument-name.js.map

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 {};