@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.0

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

@@ -3,60 +3,23 @@ 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',
+            description: 'Authoritative rule: parameters with types ending in "Props" should be named "props" (or prefixed variants when multiple Props params exist)',
             recommended: 'error',
         },
         fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    enforceDestructuring: {
-                        type: 'boolean',
-                    },
-                    ignoreExternalInterfaces: {
-                        type: 'boolean',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
         messages: {
-            usePropsForType: 'Use "Props" suffix in type name instead of "{{ typeSuffix }}"',
+            usePropsParameterName: 'Parameter with type "{{ typeName }}" should be named "props"',
+            usePropsParameterNameWithPrefix: 'Parameter with type "{{ typeName }}" should be named "{{ suggestedName }}"',
         },
     },
-    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;
-        }
+    defaultOptions: [],
+    create(context) {
         // Extract type name from a type annotation
         function getTypeName(typeAnnotation) {
             if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
@@ -67,137 +30,188 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
             }
             return null;
         }
-        // Check if a type name has a non-"Props" suffix
-        function hasNonPropsSuffix(typeName) {
-            if (typeName.endsWith('Props')) {
-                return null;
+        // Check if a type name ends with "Props"
+        function endsWithProps(typeName) {
+            return typeName.endsWith('Props');
+        }
+        // Generate suggested parameter name for Props types
+        function getSuggestedParameterName(typeName, allParams, currentParam) {
+            const currentId = getIdFromParam(currentParam);
+            const currentName = currentId?.name;
+            const existingNames = new Set(allParams
+                .map((p) => getIdFromParam(p))
+                .filter((id) => !!id && id.name !== currentName)
+                .map((id) => id.name));
+            if (typeName === 'Props') {
+                let candidate = 'props';
+                let suffix = 2;
+                while (existingNames.has(candidate)) {
+                    candidate = `props${suffix++}`;
+                }
+                return candidate;
             }
-            const suffixes = [
-                'Config',
-                'Settings',
-                'Options',
-                'Params',
-                'Parameters',
-                'Args',
-                'Arguments',
-            ];
-            for (const suffix of suffixes) {
-                if (typeName.endsWith(suffix)) {
-                    return suffix;
+            // Count how many parameters have Props types
+            const propsParams = allParams.filter((param) => {
+                if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    param.typeAnnotation &&
+                    param.typeAnnotation.typeAnnotation) {
+                    const paramTypeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                    return paramTypeName && endsWithProps(paramTypeName);
                 }
+                return false;
+            });
+            // If there's only one Props parameter, suggest "props"
+            if (propsParams.length <= 1) {
+                let candidate = 'props';
+                let suffix = 2;
+                while (existingNames.has(candidate)) {
+                    candidate = `props${suffix++}`;
+                }
+                return candidate;
             }
-            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`);
+            // If there are multiple Props parameters, use prefixed names
+            // For types like "UserProps", suggest "userProps"
+            const baseName = typeName.slice(0, -5); // Remove "Props"
+            const camelCaseBase = baseName.charAt(0).toLowerCase() + baseName.slice(1);
+            let candidate = `${camelCaseBase}Props`;
+            let i = 2;
+            while (existingNames.has(candidate)) {
+                candidate = `${camelCaseBase}Props${i++}`;
             }
-            return null;
+            return candidate;
         }
-        // Check function parameters
-        function checkFunctionParams(node) {
-            if (node.params.length !== 1) {
-                return; // Only check functions with a single parameter
+        // Check if parameter is destructured
+        function isDestructuredParameter(param) {
+            if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                param.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                return true;
             }
-            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;
+            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                (param.left.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    param.left.type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
+                return true;
             }
-            // 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),
-                        });
-                    }
+            if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                const inner = param.parameter;
+                if (inner.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    inner.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                    return true;
+                }
+                if (inner.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                    (inner.left.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                        inner.left.type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
+                    return true;
                 }
             }
+            return false;
         }
-        // Check class constructor parameters
-        function checkClassConstructor(node) {
-            if (node.kind !== 'constructor') {
-                return;
+        function getIdFromParam(param) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier)
+                return param;
+            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                param.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return param.left;
             }
-            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;
+            if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                const inner = param.parameter;
+                if (inner.type === utils_1.AST_NODE_TYPES.Identifier)
+                    return inner;
+                if (inner.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                    inner.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return inner.left;
+                }
             }
-            // 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),
-                        });
-                    }
+            if (param.type === utils_1.AST_NODE_TYPES.RestElement) {
+                if (param.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return param.argument;
                 }
             }
+            return null;
         }
-        // Check type definitions
-        function checkTypeDefinition(node) {
-            if (!node.id || !node.id.name) {
+        // Check function parameters
+        function checkFunctionParams(node) {
+            // Skip function expressions that are part of method definitions
+            // to avoid duplicate processing
+            if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression &&
+                node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                 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);
-                    },
-                });
-            }
+            const sourceCode = context.getSourceCode();
+            node.params.forEach((param) => {
+                if (isDestructuredParameter(param)) {
+                    return;
+                }
+                const id = getIdFromParam(param);
+                if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
+                    const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
+                    if (typeName && endsWithProps(typeName)) {
+                        const suggestedName = getSuggestedParameterName(typeName, node.params, param);
+                        if (id.name !== suggestedName) {
+                            const messageId = suggestedName === 'props'
+                                ? 'usePropsParameterName'
+                                : 'usePropsParameterNameWithPrefix';
+                            context.report({
+                                node: id,
+                                messageId,
+                                data: {
+                                    typeName,
+                                    suggestedName,
+                                },
+                                fix: (fixer) => {
+                                    const token = sourceCode.getFirstToken(id);
+                                    if (!token)
+                                        return null;
+                                    return fixer.replaceTextRange([token.range[0], token.range[1]], suggestedName);
+                                },
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        // Check class method parameters (including constructors)
+        function checkClassMethod(node) {
+            const method = node.value;
+            const sourceCode = context.getSourceCode();
+            method.params.forEach((param) => {
+                if (isDestructuredParameter(param)) {
+                    return;
+                }
+                const id = getIdFromParam(param);
+                if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
+                    const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
+                    if (typeName && endsWithProps(typeName)) {
+                        const suggestedName = getSuggestedParameterName(typeName, method.params, param);
+                        if (id.name !== suggestedName) {
+                            const messageId = suggestedName === 'props'
+                                ? 'usePropsParameterName'
+                                : 'usePropsParameterNameWithPrefix';
+                            context.report({
+                                node: id,
+                                messageId,
+                                data: {
+                                    typeName,
+                                    suggestedName,
+                                },
+                                fix: (fixer) => {
+                                    const token = sourceCode.getFirstToken(id);
+                                    if (!token)
+                                        return null;
+                                    return fixer.replaceTextRange([token.range[0], token.range[1]], suggestedName);
+                                },
+                            });
+                        }
+                    }
+                }
+            });
         }
         return {
             FunctionDeclaration: checkFunctionParams,
             FunctionExpression: checkFunctionParams,
             ArrowFunctionExpression: checkFunctionParams,
             TSMethodSignature: checkFunctionParams,
-            MethodDefinition: checkClassConstructor,
-            TSTypeAliasDeclaration: checkTypeDefinition,
+            MethodDefinition: checkClassMethod,
         };
     },
 });

package/lib/rules/enforce-props-naming-consistency.d.ts

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

package/lib/rules/enforce-props-naming-consistency.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforcePropsNamingConsistency = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
+    name: 'enforce-props-naming-consistency',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer naming single "Props"-typed parameters as "props"; enforcement defers to enforce-props-argument-name for multi-Props cases',
+            recommended: 'warn',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            usePropsName: 'Parameter with a type ending in "Props" should be named "props" instead of "{{ paramName }}"',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // 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 parameter should be named "props"
+        function shouldBeNamedProps(param) {
+            // Only check non-destructured parameters
+            if (param.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            // Check if the parameter has a type annotation
+            if (!param.typeAnnotation || !param.typeAnnotation.typeAnnotation) {
+                return false;
+            }
+            // Get the type name
+            const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+            if (!typeName) {
+                return false;
+            }
+            // Check if the type name ends with "Props"
+            return typeName.endsWith('Props');
+        }
+        // Check if a parameter name is already prefixed with "props"
+        function isPropsNameWithPrefix(paramName) {
+            return paramName.endsWith('Props') || paramName === 'props';
+        }
+        // Fix parameter name to "props"
+        function fixParameterName(fixer, param) {
+            return fixer.replaceText(param, 'props');
+        }
+        // Check function parameters
+        function checkFunctionParams(node) {
+            // Skip functions with multiple parameters that have Props types
+            const propsTypeParams = node.params.filter((param) => {
+                if (param.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return false;
+                if (!param.typeAnnotation || !param.typeAnnotation.typeAnnotation)
+                    return false;
+                const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                return typeName && typeName.endsWith('Props');
+            });
+            if (propsTypeParams.length > 1) {
+                return; // Skip functions with multiple Props parameters
+            }
+            for (const param of node.params) {
+                if (shouldBeNamedProps(param) &&
+                    param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    !isPropsNameWithPrefix(param.name)) {
+                    context.report({
+                        node: param,
+                        messageId: 'usePropsName',
+                        data: { paramName: param.name },
+                        fix: (fixer) => fixParameterName(fixer, param),
+                    });
+                }
+            }
+        }
+        // Check class constructor parameters
+        function checkClassConstructor(node) {
+            if (node.kind !== 'constructor') {
+                return;
+            }
+            const constructor = node.value;
+            // Skip constructors with multiple parameters that have Props types
+            const propsTypeParams = constructor.params.filter((param) => {
+                if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (!param.typeAnnotation || !param.typeAnnotation.typeAnnotation)
+                        return false;
+                    const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                    return typeName && typeName.endsWith('Props');
+                }
+                else if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
+                    param.parameter.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (!param.parameter.typeAnnotation ||
+                        !param.parameter.typeAnnotation.typeAnnotation)
+                        return false;
+                    const typeName = getTypeName(param.parameter.typeAnnotation.typeAnnotation);
+                    return typeName && typeName.endsWith('Props');
+                }
+                return false;
+            });
+            if (propsTypeParams.length > 1) {
+                return; // Skip constructors with multiple Props parameters
+            }
+            for (const param of constructor.params) {
+                if (shouldBeNamedProps(param) &&
+                    param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    !isPropsNameWithPrefix(param.name)) {
+                    context.report({
+                        node: param,
+                        messageId: 'usePropsName',
+                        data: { paramName: param.name },
+                        fix: (fixer) => fixParameterName(fixer, param),
+                    });
+                }
+                else if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
+                    param.parameter.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    shouldBeNamedProps(param.parameter) &&
+                    !isPropsNameWithPrefix(param.parameter.name)) {
+                    context.report({
+                        node: param.parameter,
+                        messageId: 'usePropsName',
+                        data: { paramName: param.parameter.name },
+                        fix: (fixer) => fixParameterName(fixer, param.parameter),
+                    });
+                }
+            }
+        }
+        return {
+            FunctionDeclaration: checkFunctionParams,
+            FunctionExpression: checkFunctionParams,
+            ArrowFunctionExpression: checkFunctionParams,
+            TSMethodSignature: checkFunctionParams,
+            MethodDefinition: checkClassConstructor,
+        };
+    },
+});
+//# sourceMappingURL=enforce-props-naming-consistency.js.map

package/lib/rules/enforce-querykey-ts.d.ts

@@ -0,0 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'enforceQueryKeyImport' | 'enforceQueryKeyConstant';
+/**
+ * Rule to enforce the use of centralized router state key constants imported from
+ * `src/util/routing/queryKeys.ts` instead of arbitrary string literals when calling
+ * router methods that accept key parameters.
+ */
+export declare const enforceQueryKeyTs: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};