@blumintinc/eslint-plugin-blumint 1.20.33 → 1.20.34

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.33',
+        version: '1.20.34',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-global-constants.js

@@ -118,25 +118,63 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
         function hasIdentifiers(node) {
             return !!node && ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(node);
         }
-        function alreadyHasConst(program, constName) {
-            for (const stmt of program.body) {
-                if (stmt.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
-                    stmt.kind === 'const') {
-                    for (const d of stmt.declarations) {
-                        if (d.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            d.id.name === constName) {
-                            return true;
-                        }
-                    }
+        function classifyModuleBinding(variable) {
+            if (variable.defs.length !== 1) {
+                return { kind: 'blocked' };
+            }
+            const declarator = variable.defs[0].node;
+            if (declarator.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return { kind: 'blocked' };
+            }
+            const declaration = declarator.parent;
+            if (!declaration ||
+                declaration.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+                declaration.kind !== 'const' ||
+                declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                !declarator.init) {
+                return { kind: 'blocked' };
+            }
+            return {
+                kind: 'reusable',
+                initText: sourceCode.getText(declarator.init),
+            };
+        }
+        /**
+         * `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();
+        }
+        function resolveGeneratedName(scope, constName) {
+            let current = scope;
+            while (current) {
+                const variable = current.variables.find((v) => v.name === constName);
+                if (variable) {
+                    return current.block.type === utils_1.AST_NODE_TYPES.Program
+                        ? classifyModuleBinding(variable)
+                        : { kind: 'blocked' };
                 }
+                current = current.upper;
             }
-            return false;
+            // An unresolved reference elsewhere in the file points at an ambient
+            // global; declaring the name at module scope would capture it.
+            const globalScope = sourceCode.scopeManager?.globalScope;
+            if (globalScope?.through.some((ref) => ref.identifier.name === constName)) {
+                return { kind: 'blocked' };
+            }
+            return { kind: 'free' };
         }
-        function buildConstDeclarationLine(constName, initText) {
+        function buildInitializerText(initText) {
             const needsAsConst = /^(?:true|false|-?\d|\[|\{|[`'"])/.test(initText) &&
                 !/\bas const\b/.test(initText);
-            const initializer = needsAsConst ? `${initText} as const` : initText;
-            return `const ${constName} = ${initializer};`;
+            return needsAsConst ? `${initText} as const` : initText;
+        }
+        function buildConstDeclarationLine(constName, initText) {
+            return `const ${constName} = ${buildInitializerText(initText)};`;
         }
         function reportStaticDefaults(patterns, enclosingFn, nodeForReport) {
             if (!enclosingFn || !isComponentOrHookFunction(enclosingFn))
@@ -153,23 +191,52 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
             });
             if (staticDefaults.length === 0)
                 return;
+            const reportScope = scopeOf(nodeForReport);
             context.report({
                 node: nodeForReport,
                 messageId: 'extractDefaultToGlobalConstant',
                 fix(fixer) {
                     const fixes = [];
-                    const programNode = sourceCode.ast;
                     const declLines = [];
+                    // Names this fix commits to declaring, mapped to the initializer it
+                    // declares them with, so sibling defaults sharing a generated name
+                    // share the declaration instead of duplicating the binding.
+                    const scheduledInits = new Map();
                     for (const def of staticDefaults) {
                         const { assignment, localName } = def;
                         const right = assignment.right;
                         const rightText = sourceCode.getText(right);
                         const constName = `DEFAULT_${toUpperSnakeCase(localName)}`;
-                        if (!alreadyHasConst(programNode, constName)) {
-                            declLines.push(buildConstDeclarationLine(constName, rightText));
+                        const initText = buildInitializerText(rightText);
+                        const scheduled = scheduledInits.get(constName);
+                        if (scheduled !== undefined) {
+                            if (scheduled !== initText)
+                                continue;
+                            fixes.push(fixer.replaceText(right, constName));
+                            continue;
+                        }
+                        const resolution = resolveGeneratedName(reportScope, constName);
+                        if (resolution.kind === 'blocked') {
+                            // Declining leaves the report in place: the developer extracts
+                            // the constant by hand instead of the fixer corrupting the file.
+                            continue;
+                        }
+                        if (resolution.kind === 'reusable') {
+                            // Reuse is safe only when the existing constant holds the very
+                            // same value; `as const` may be present on either side.
+                            if (resolution.initText !== initText &&
+                                resolution.initText !== rightText) {
+                                continue;
+                            }
+                            fixes.push(fixer.replaceText(right, constName));
+                            continue;
                         }
+                        declLines.push(buildConstDeclarationLine(constName, rightText));
+                        scheduledInits.set(constName, initText);
                         fixes.push(fixer.replaceText(right, constName));
                     }
+                    if (fixes.length === 0)
+                        return null;
                     if (declLines.length > 0) {
                         const program = sourceCode.ast;
                         const constSection = declLines.length === 1

package/lib/rules/prefer-global-router-state-key.js

@@ -151,6 +151,31 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
                         isQueryKeysSource(declaration.source.value));
                 }));
         }
+        /**
+         * Whether every declaration of a visible binding is the namespace or
+         * default import of queryKeys.ts that a qualified `alias.CONSTANT` fix
+         * reaches the constant through. The alias only carries the module's
+         * exports where it still resolves to that import at the reference: an inner
+         * `const QueryKeys = {…}` captures the emitted reference, the member access
+         * type-checks against the object, and the router key silently becomes that
+         * object's value instead of the shared constant.
+         */
+        function bindsQueryKeysModule(variable) {
+            return (variable.defs.length > 0 &&
+                variable.defs.every((def) => {
+                    const specifier = def.node;
+                    if (specifier.type !== utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier &&
+                        specifier.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                        return false;
+                    }
+                    const declaration = specifier.parent;
+                    return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                        declaration.importKind !== 'type' &&
+                        declaration.source.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof declaration.source.value === 'string' &&
+                        isQueryKeysSource(declaration.source.value));
+                }));
+        }
         /**
          * `SourceCode#getScope` supersedes the deprecated `context.getScope`; the
          * fallback keeps the rule working on ESLint versions that predate it.
@@ -391,21 +416,41 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
                                                         const replacementText = localName
                                                             ? localName
                                                             : formatConstantReference(importAlias, suggestedConstant);
+                                                        // An already-imported constant is referenced by its
+                                                        // own local name, so the alias leads the emitted
+                                                        // text only when no such import exists.
+                                                        const referenceAlias = localName
+                                                            ? undefined
+                                                            : importAlias;
+                                                        // Both hazards below turn on what the emitted text's
+                                                        // leading name resolves to where it is written, so
+                                                        // the scope chain is entered at the literal rather
+                                                        // than at module scope.
+                                                        const scopeAtLiteral = ASTHelpers_1.ASTHelpers.getScope(context, keyValue);
+                                                        // The qualified `alias.CONSTANT` form claims no name
+                                                        // of its own, yet it reaches the module's exports
+                                                        // only while the alias still resolves to that import
+                                                        // here. An inner binding of the alias captures it
+                                                        // silently — the member access type-checks against
+                                                        // whatever the local holds — so the router key would
+                                                        // become that value instead of the constant.
+                                                        if (referenceAlias) {
+                                                            const aliasBinding = ASTHelpers_1.ASTHelpers.findVariableInScope(scopeAtLiteral, referenceAlias);
+                                                            if (!aliasBinding ||
+                                                                !bindsQueryKeysModule(aliasBinding)) {
+                                                                return null;
+                                                            }
+                                                        }
                                                         // A binding that already owns the emitted name
                                                         // makes both halves of the edit wrong: the inserted
                                                         // import becomes a second declaration of it
                                                         // (TS2440/TS2300), and a shadowing local or
                                                         // parameter captures the bare reference with no
-                                                        // diagnostic at all. Resolving through the scope
-                                                        // chain at the literal rather than the module scope
-                                                        // is what exposes such a shadow. Declining leaves
-                                                        // the report in place for the author to resolve.
-                                                        // The qualified `alias.CONSTANT` form reaches the
-                                                        // constant through the alias and claims no name of
-                                                        // its own.
-                                                        const visibleBinding = importAlias
+                                                        // diagnostic at all. Declining leaves the report in
+                                                        // place for the author to resolve.
+                                                        const visibleBinding = referenceAlias
                                                             ? null
-                                                            : ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, keyValue), replacementText);
+                                                            : ASTHelpers_1.ASTHelpers.findVariableInScope(scopeAtLiteral, replacementText);
                                                         const bindingIsQueryKeyImport = visibleBinding !== null &&
                                                             bindsQueryKeyConstant(visibleBinding, suggestedConstant);
                                                         if (visibleBinding && !bindingIsQueryKeyImport) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.33",
+  "version": "1.20.34",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.34",
+    "date": "2026-07-30T16:15:43.598Z",
+    "rules": [
+      {
+        "name": "enforce-global-constants",
+        "changeType": "fix",
+        "issues": [
+          1455
+        ],
+        "summary": "decline the autofix when the generated name is taken (closes #1455)"
+      },
+      {
+        "name": "prefer-global-router-state-key",
+        "changeType": "fix",
+        "issues": [
+          1456
+        ],
+        "summary": "decline the autofix when a shadow captures the emitted reference (closes #1456)"
+      }
+    ]
+  },
   {
     "version": "1.20.33",
     "date": "2026-07-30T14:50:36.025Z",