@blumintinc/eslint-plugin-blumint 1.20.8 → 1.20.10

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

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceQueryKeyTs = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * The canonical queryKeys module. The rule takes no options and already hard-codes
+ * this path as what makes a key valid, so the fixer writes the very same path
+ * instead of guessing one when a file has no queryKeys import to copy from.
+ */
+const DEFAULT_QUERY_KEYS_SOURCE = '@/util/routing/queryKeys';
 /**
  * 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
@@ -29,15 +35,26 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
         const queryKeyImports = new Map();
         const localUseRouterStateNames = new Set(['useRouterState']);
         const validQueryKeySources = new Set([
-            '@/util/routing/queryKeys',
+            DEFAULT_QUERY_KEYS_SOURCE,
             'src/util/routing/queryKeys',
         ]);
         const allowedQueryKeyFactories = new Set(['makeQueryKey', 'getQueryKey']);
+        const sourceCode = context.getSourceCode();
         /**
-         * Ensure a suggested constant is imported from queryKeys.ts and return combined fixes
+         * Reports are buffered until the whole file has been walked so the fixer can
+         * put every substituted constant into a single import instead of racing
+         * per-violation insertions that overlap and get dropped.
          */
-        function buildImportFixes(fixer, keyNode, suggestedConstant) {
-            return [fixer.replaceText(keyNode, suggestedConstant)];
+        const pendingReports = [];
+        /**
+         * `SourceCode#getScope` supersedes the deprecated `context.getScope`; the
+         * fallback keeps the rule working on ESLint versions that predate it.
+         */
+        function scopeOf(node) {
+            const scoped = sourceCode;
+            return typeof scoped.getScope === 'function'
+                ? scoped.getScope(node)
+                : context.getScope();
         }
         /**
          * Check if a source path refers to queryKeys.ts
@@ -46,6 +63,138 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             return (validQueryKeySources.has(source) ||
                 source.endsWith('/util/routing/queryKeys'));
         }
+        function importDeclarationsOf() {
+            return sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                typeof statement.source.value === 'string');
+        }
+        function isValueImportSpecifier(specifier) {
+            return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.importKind !== 'type');
+        }
+        /**
+         * A file that already imports the export under another name reaches it
+         * through that name; re-importing it would leave two bindings for one
+         * constant.
+         */
+        function localNameOf(constant) {
+            for (const declaration of importDeclarationsOf()) {
+                if (declaration.importKind === 'type' ||
+                    !isQueryKeysSource(String(declaration.source.value))) {
+                    continue;
+                }
+                for (const specifier of declaration.specifiers) {
+                    if (isValueImportSpecifier(specifier) &&
+                        specifier.imported.name === constant) {
+                        return specifier.local.name;
+                    }
+                }
+            }
+            return constant;
+        }
+        /**
+         * Decide whether the suggested constant can be substituted, and whether the
+         * substitution has to carry an import with it.
+         */
+        function resolveBinding(scope, constant) {
+            const variable = utils_1.ASTUtils.findVariable(scope, constant);
+            if (!variable) {
+                return 'missing';
+            }
+            const [definition] = variable.defs;
+            if (!definition) {
+                return 'conflict';
+            }
+            const definitionNode = definition.node;
+            if (definitionNode.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                definitionNode.importKind === 'type' ||
+                !isValidQueryKeyConstant(definitionNode.imported.name)) {
+                return 'conflict';
+            }
+            const declaration = definitionNode.parent;
+            if (!declaration ||
+                declaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+                declaration.importKind === 'type' ||
+                typeof declaration.source.value !== 'string' ||
+                !isQueryKeysSource(declaration.source.value)) {
+                return 'conflict';
+            }
+            return 'bound';
+        }
+        /**
+         * Make the substituted constants resolve: extend the file's queryKeys import
+         * when there is one to extend, otherwise add a fresh import statement.
+         */
+        function buildImportFix(fixer, constants) {
+            const importDeclarations = importDeclarationsOf();
+            const queryKeysDeclarations = importDeclarations.filter((declaration) => isQueryKeysSource(String(declaration.source.value)));
+            const reusable = queryKeysDeclarations.find((declaration) => declaration.importKind !== 'type' &&
+                declaration.specifiers.some(isValueImportSpecifier));
+            if (reusable) {
+                const namedSpecifiers = reusable.specifiers.filter(isValueImportSpecifier);
+                const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
+                return fixer.insertTextAfter(lastSpecifier, constants.map((constant) => `, ${constant}`).join(''));
+            }
+            // A namespace or type-only queryKeys import cannot take named value
+            // specifiers, but its path is proof of how this file reaches the module.
+            const source = queryKeysDeclarations.length
+                ? String(queryKeysDeclarations[0].source.value)
+                : DEFAULT_QUERY_KEYS_SOURCE;
+            const importText = `import { ${constants.join(', ')} } from '${source}';\n`;
+            const [firstImport] = importDeclarations;
+            if (firstImport) {
+                return fixer.insertTextBefore(firstImport, importText);
+            }
+            // Keep the import visually separated from the code it precedes unless the
+            // file already opens with a blank line.
+            const separator = /^\r?\n/.test(sourceCode.text) ? '' : '\n';
+            return fixer.insertTextBeforeRange([0, 0], `${importText}${separator}`);
+        }
+        function flushReports() {
+            const resolutions = new Map();
+            const missingConstants = [];
+            for (const report of pendingReports) {
+                if (!report.substitution) {
+                    continue;
+                }
+                const { constant, scope } = report.substitution;
+                const name = localNameOf(constant);
+                const state = resolveBinding(scope, name);
+                resolutions.set(report, { name, state });
+                if (state === 'missing' && !missingConstants.includes(name)) {
+                    missingConstants.push(name);
+                }
+            }
+            // The first applied substitution carries the import for every other one:
+            // its fix range then starts at the top of the file and ends before the
+            // remaining literals, so no two fixes of this rule overlap in a pass.
+            const importCarrier = pendingReports.find((report) => {
+                const resolution = resolutions.get(report);
+                return resolution !== undefined && resolution.state !== 'conflict';
+            });
+            for (const report of pendingReports) {
+                context.report({
+                    node: report.node,
+                    messageId: report.messageId,
+                    data: report.data,
+                    fix(fixer) {
+                        const { substitution } = report;
+                        const resolution = resolutions.get(report);
+                        if (!substitution ||
+                            !resolution ||
+                            resolution.state === 'conflict') {
+                            return null;
+                        }
+                        const fixes = [
+                            fixer.replaceText(substitution.keyNode, resolution.name),
+                        ];
+                        if (report === importCarrier && missingConstants.length > 0) {
+                            fixes.unshift(buildImportFix(fixer, missingConstants));
+                        }
+                        return fixes;
+                    },
+                });
+            }
+        }
         /**
          * Check if an identifier is a valid QUERY_KEY constant
          */
@@ -236,25 +385,27 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                                 if (!isValidQueryKeyUsage(keyValue)) {
                                     // Check if it contains invalid string literals
                                     if (containsInvalidStringLiteral(keyValue)) {
-                                        context.report({
+                                        // Only simple string literals can be auto-fixed
+                                        const suggestedConstant = keyValue.type === utils_1.AST_NODE_TYPES.Literal &&
+                                            typeof keyValue.value === 'string'
+                                            ? generateAutoFix(keyValue.value)
+                                            : null;
+                                        pendingReports.push({
                                             node: keyValue,
                                             messageId: 'enforceQueryKeyImport',
-                                            fix(fixer) {
-                                                // Only provide auto-fix for simple string literals
-                                                if (keyValue.type === utils_1.AST_NODE_TYPES.Literal &&
-                                                    typeof keyValue.value === 'string') {
-                                                    const suggestedConstant = generateAutoFix(keyValue.value);
-                                                    if (suggestedConstant) {
-                                                        return buildImportFixes(fixer, keyValue, suggestedConstant);
-                                                    }
+                                            substitution: suggestedConstant &&
+                                                keyValue.type === utils_1.AST_NODE_TYPES.Literal
+                                                ? {
+                                                    keyNode: keyValue,
+                                                    constant: suggestedConstant,
+                                                    scope: scopeOf(keyValue),
                                                 }
-                                                return null;
-                                            },
+                                                : undefined,
                                         });
                                     }
                                     else if (keyValue.type === utils_1.AST_NODE_TYPES.Identifier) {
                                         // Report variables that aren't from the correct source
-                                        context.report({
+                                        pendingReports.push({
                                             node: keyValue,
                                             messageId: 'enforceQueryKeyConstant',
                                             data: {
@@ -268,6 +419,9 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                     }
                 }
             },
+            'Program:exit'() {
+                flushReports();
+            },
         };
     },
 });

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

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 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 declare const enforceReactTypeNaming: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceReactTypeNaming = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const renameFixes_1 = require("../utils/renameFixes");
 // Types that should have lowercase variable names
 const LOWERCASE_TYPES = ['ReactNode', 'JSX.Element'];
 // Types that should have uppercase variable names
@@ -86,18 +87,45 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
                 (node.parent?.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                     node.parent.local.name !== node.parent.imported?.name));
         }
+        /**
+         * Builds the rename for a reported identifier: the declaration plus every
+         * in-file reference, rewriting only name tokens so the type annotation that
+         * triggered the report survives (Issue #1357).
+         *
+         * The variable is resolved by declaration identity rather than by name,
+         * because a shape like `function Content(Content: ReactNode)` declares two
+         * distinct symbols under one name and a name-based lookup picks the wrong
+         * one. When the symbol cannot be resolved the fix is withheld entirely — a
+         * partial rename is worse than no rename.
+         */
+        function buildRenameFixes(fixer, owner, declarationId, newName) {
+            const variable = context
+                .getDeclaredVariables(owner)
+                .find((candidate) => candidate.defs.some((def) => def.name === declarationId)) ?? null;
+            if (!variable) {
+                return null;
+            }
+            return (0, renameFixes_1.buildVariableRenameFixes)({
+                fixer,
+                sourceCode: context.getSourceCode(),
+                variable,
+                declarationId,
+                newName,
+            });
+        }
         /**
          * Check variable declarations for React type naming conventions
          */
         function checkVariableDeclaration(node) {
             if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            const id = node.id;
             // Skip destructured variables
-            if (isDestructured(node.id))
+            if (isDestructured(id))
                 return;
-            const variableName = node.id.name;
+            const variableName = id.name;
             // Get the type annotation
-            const typeAnnotation = node.id.typeAnnotation?.typeAnnotation;
+            const typeAnnotation = id.typeAnnotation?.typeAnnotation;
             const typeName = getTypeName(typeAnnotation);
             if (!typeName)
                 return;
@@ -105,44 +133,45 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
             if (LOWERCASE_TYPES.includes(typeName) && isUppercase(variableName)) {
                 const suggestion = toLowercase(variableName);
                 context.report({
-                    node: node.id,
+                    node: id,
                     messageId: 'reactNodeShouldBeLowercase',
                     data: {
                         type: typeName,
                         suggestion,
                     },
-                    fix: (fixer) => fixer.replaceText(node.id, suggestion),
+                    fix: (fixer) => buildRenameFixes(fixer, 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,
+                    node: id,
                     messageId: 'componentTypeShouldBeUppercase',
                     data: {
                         type: typeName,
                         suggestion,
                     },
-                    fix: (fixer) => fixer.replaceText(node.id, suggestion),
+                    fix: (fixer) => buildRenameFixes(fixer, node, id, suggestion),
                 });
             }
         }
         /**
          * Check function parameters for React type naming conventions
          */
-        function checkParameter(node) {
+        function checkParameter(node, owner) {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
+            const id = node;
             // Skip destructured parameters
-            if (isDestructured(node))
+            if (isDestructured(id))
                 return;
             // Skip default imports
-            if (isDefaultImport(node))
+            if (isDefaultImport(id))
                 return;
-            const paramName = node.name;
+            const paramName = id.name;
             // Get the type annotation
-            const typeAnnotation = node.typeAnnotation?.typeAnnotation;
+            const typeAnnotation = id.typeAnnotation?.typeAnnotation;
             const typeName = getTypeName(typeAnnotation);
             if (!typeName)
                 return;
@@ -150,26 +179,26 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
             if (LOWERCASE_TYPES.includes(typeName) && isUppercase(paramName)) {
                 const suggestion = toLowercase(paramName);
                 context.report({
-                    node,
+                    node: id,
                     messageId: 'reactNodeShouldBeLowercase',
                     data: {
                         type: typeName,
                         suggestion,
                     },
-                    fix: (fixer) => fixer.replaceText(node, suggestion),
+                    fix: (fixer) => buildRenameFixes(fixer, owner, id, 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,
+                    node: id,
                     messageId: 'componentTypeShouldBeUppercase',
                     data: {
                         type: typeName,
                         suggestion,
                     },
-                    fix: (fixer) => fixer.replaceText(node, suggestion),
+                    fix: (fixer) => buildRenameFixes(fixer, owner, id, suggestion),
                 });
             }
         }
@@ -182,7 +211,7 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
                         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);
+                    checkParameter(node, node.parent);
                 }
             },
         };

package/lib/rules/enforce-snapshot-state-narrowing.d.ts

@@ -1,10 +1,12 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'noFalsyCheck' | 'noRawTypeof';
 type Options = [
     {
         snapshotHooks?: string[];
         guardFunctions?: string[];
         excludeFiles?: string[];
+        guardImportSource?: string;
     }?
 ];
-export declare const enforceSnapshotStateNarrowing: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const enforceSnapshotStateNarrowing: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
 export {};