@blumintinc/eslint-plugin-blumint 1.20.32 → 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.32',
+        version: '1.20.34',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-fieldpath-syntax-in-docsetter.js

@@ -119,31 +119,99 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
         function needsQuoting(key) {
             return key.includes('.') || !/^(?:[$_A-Za-z][$\w]*)$/u.test(key);
         }
-        // Helper function to convert an object to FieldPath syntax
-        function convertToFieldPathSyntax(node, sourceCode, preflattened) {
-            const idProperty = node.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                prop.key.name === 'id');
-            const flattenedProperties = {
-                ...(preflattened ?? flattenObject(node, sourceCode)),
-            };
-            if (idProperty && idProperty.type === utils_1.AST_NODE_TYPES.Property) {
-                delete flattenedProperties['id'];
+        // Collect the FieldPath entries a nested property flattens into, or bail out
+        // when flattening would silently drop payload data (spreads, computed keys,
+        // accessors/methods, unsupported key literals) or would produce nothing at
+        // all. Bailing leaves the report in place so the developer flattens by hand
+        // instead of receiving a fix that deletes fields or emits invalid syntax.
+        function collectFieldPathEntries(obj, prefix, sourceCode) {
+            const entries = [];
+            for (const property of obj.properties) {
+                if (property.type !== utils_1.AST_NODE_TYPES.Property ||
+                    property.computed ||
+                    property.method ||
+                    property.kind !== 'init') {
+                    return null;
+                }
+                const keyText = getPropertyKeyText(property);
+                if (keyText === undefined) {
+                    return null;
+                }
+                const fullKey = `${prefix}.${keyText}`;
+                if (property.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const nestedEntries = collectFieldPathEntries(property.value, fullKey, sourceCode);
+                    if (!nestedEntries) {
+                        return null;
+                    }
+                    entries.push(...nestedEntries);
+                    continue;
+                }
+                entries.push([fullKey, sourceCode.getText(property.value)]);
+            }
+            return entries.length > 0 ? entries : null;
+        }
+        function getLineIndent(line) {
+            return /^[\t ]*/u.exec(line)?.[0] ?? '';
+        }
+        // Indentation of the property when it is the first thing on its line, which
+        // is the indentation the replacement text must reuse to keep the surrounding
+        // lines byte-identical. Returns null for properties sharing a line with
+        // other code, where the replacement stays inline.
+        function getOwnLineIndent(property, sourceCode) {
+            const line = sourceCode.lines[property.loc.start.line - 1] ?? '';
+            const linePrefix = line.slice(0, property.loc.start.column);
+            return /^[\t ]*$/u.test(linePrefix) ? linePrefix : null;
+        }
+        function printComment(comment) {
+            return comment.type === utils_1.AST_TOKEN_TYPES.Line
+                ? `//${comment.value}`
+                : `/*${comment.value}*/`;
+        }
+        // Render the dot-path replacement for a single nested property. Comments
+        // living inside the property are re-emitted ahead of the flattened entries
+        // so directives such as eslint-disable-next-line keep covering the rewritten
+        // code rather than being destroyed by the fix.
+        function renderFlattenedProperty(property, entries, sourceCode) {
+            const comments = sourceCode.getCommentsInside(property);
+            const commentTexts = comments.map(printComment);
+            const printedEntries = entries.map(([key, value]) => `${needsQuoting(key) ? `'${key}'` : key}: ${value}`);
+            const ownLineIndent = getOwnLineIndent(property, sourceCode);
+            // A carried line comment would swallow the rest of the line, so anything
+            // holding one has to be laid out across multiple lines
+            const carriesLineComment = comments.some((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Line);
+            if (ownLineIndent === null && !carriesLineComment) {
+                return [...commentTexts, printedEntries.join(', ')].join(' ');
             }
-            const entries = Object.entries(flattenedProperties);
-            const propertyComma = ',';
-            // Start with the id property if it exists
-            let result = '{\n';
-            if (idProperty && idProperty.type === utils_1.AST_NODE_TYPES.Property) {
-                result += `  id: ${sourceCode.getText(idProperty.value)}${propertyComma}\n`;
+            const indent = ownLineIndent ??
+                `${getLineIndent(sourceCode.lines[property.loc.start.line - 1] ?? '')}  `;
+            const separator = `\n${indent}`;
+            return [...commentTexts, printedEntries.join(`,${separator}`)].join(separator);
+        }
+        // Replace only the properties that actually need flattening, leaving every
+        // other property, its comments, and the original indentation untouched
+        function buildFieldPathFixes(node, sourceCode, fixer) {
+            const fixes = [];
+            for (const property of node.properties) {
+                if (property.type !== utils_1.AST_NODE_TYPES.Property ||
+                    property.computed ||
+                    property.method ||
+                    property.kind !== 'init' ||
+                    property.value.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    continue;
+                }
+                const keyText = getPropertyKeyText(property);
+                // Root-level numeric keys model array-style buckets rather than
+                // Firestore document fields, so they are never flattened
+                if (keyText === undefined || isNumericKey(property)) {
+                    continue;
+                }
+                const entries = collectFieldPathEntries(property.value, keyText, sourceCode);
+                if (!entries) {
+                    continue;
+                }
+                fixes.push(fixer.replaceTextRange(property.range, renderFlattenedProperty(property, entries, sourceCode)));
             }
-            // Add the flattened properties (always include trailing commas for multiline objects)
-            entries.forEach(([key, value]) => {
-                const printedKey = needsQuoting(key) ? `'${key}'` : key;
-                result += `  ${printedKey}: ${value}${propertyComma}\n`;
-            });
-            result += '}';
-            return result;
+            return fixes;
         }
         function getPropertyKeyText(property) {
             if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -208,7 +276,6 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
             return {
                 topLevelKey: propertyKeyText ?? 'nested field',
                 exampleFieldPath,
-                flattenedProperties,
             };
         }
         return {
@@ -251,8 +318,8 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
                         exampleFieldPath: violationDetails.exampleFieldPath,
                     },
                     fix(fixer) {
-                        const newText = convertToFieldPathSyntax(firstArg, sourceCode, violationDetails.flattenedProperties);
-                        return fixer.replaceText(firstArg, newText);
+                        const fixes = buildFieldPathFixes(firstArg, sourceCode, fixer);
+                        return fixes.length > 0 ? fixes : null;
                     },
                 });
             },

package/lib/rules/enforce-firestore-set-merge.d.ts

@@ -1 +1,2 @@
-export declare const enforceFirestoreSetMerge: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferSetMerge", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceFirestoreSetMerge: TSESLint.RuleModule<"preferSetMerge", [], TSESLint.RuleListener>;

package/lib/rules/enforce-firestore-set-merge.js

@@ -4,6 +4,69 @@ exports.enforceFirestoreSetMerge = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const disableDirectives_1 = require("../utils/disableDirectives");
+const FIRESTORE_MODULES = new Set(['firebase/firestore', 'firebase-admin']);
+const UPDATE_DOC = 'updateDoc';
+const SET_DOC = 'setDoc';
+const MERGE_ARGUMENT = ', { merge: true }';
+function isFirestoreDynamicImport(node) {
+    if (node?.type !== utils_1.AST_NODE_TYPES.AwaitExpression) {
+        return false;
+    }
+    const imported = node.argument;
+    return (imported.type === utils_1.AST_NODE_TYPES.ImportExpression &&
+        imported.source.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof imported.source.value === 'string' &&
+        FIRESTORE_MODULES.has(imported.source.value));
+}
+/**
+ * Reads a binding's origin off the AST rather than off a traversal flag, so the
+ * verdict is re-derived on every pass of a multi-pass `--fix` — including the
+ * passes that run after a previous pass inserted the `setDoc` binding.
+ */
+function firestoreBindingOf(def) {
+    const { node } = def;
+    if (node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        const declaration = node.parent;
+        if (declaration?.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            !FIRESTORE_MODULES.has(declaration.source.value) ||
+            declaration.importKind === 'type' ||
+            node.importKind === 'type') {
+            return null;
+        }
+        return {
+            imported: node.imported.name,
+            node,
+            entries: declaration.specifiers,
+        };
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+        isFirestoreDynamicImport(node.init)) {
+        const property = def.name.parent;
+        if (property?.type !== utils_1.AST_NODE_TYPES.Property ||
+            property.parent !== node.id ||
+            property.value !== def.name ||
+            property.computed ||
+            property.key.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return null;
+        }
+        return {
+            imported: property.key.name,
+            node: property,
+            entries: node.id.properties,
+        };
+    }
+    return null;
+}
+function isComma(token) {
+    return token?.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ',';
+}
+/** Whether every declaration of a visible binding is the given firestore export. */
+function bindsFirestoreExport(variable, imported) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => firestoreBindingOf(def)?.imported === imported));
+}
 exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     name: 'enforce-firestore-set-merge',
     meta: {
@@ -22,7 +85,18 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
         const updateAliases = new Set();
+        /**
+         * The `setDoc` binding rides on one violation's fix, which makes that
+         * violation the file's import carrier. ESLint calls `fix()` before it
+         * applies inline disable directives, so a suppressed carrier takes the
+         * binding down with it while the surviving violations still emit
+         * `setDoc(…)`. Resolving suppression up front passes the carrier slot to the
+         * first violation that actually survives.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        let plannedSetDocBinding = false;
         function isFirestoreUpdateCall(node) {
             // Check if it's a set() call with merge: true
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -118,7 +192,7 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             }
             if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
                 // Check if it's a setDoc() call with merge: true
-                if (node.callee.name === 'setDoc') {
+                if (node.callee.name === SET_DOC) {
                     const lastArg = node.arguments[node.arguments.length - 1];
                     if (lastArg?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                         const hasMergeTrue = lastArg.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
@@ -135,87 +209,190 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             }
             return false;
         }
-        function convertUpdateToSetMerge(node, sourceCode) {
+        /**
+         * A spread hides how many arguments the call really passes, so the options
+         * object cannot be positioned.
+         */
+        function hasSpreadArgument(node) {
+            return node.arguments.some((argument) => argument.type === utils_1.AST_NODE_TYPES.SpreadElement);
+        }
+        /**
+         * `ref.update(…)` becomes `ref.set(…, { merge: true })` by editing only the
+         * method name and the tail of the argument list. Re-emitting the call from
+         * the text of each argument dropped everything between them — comments
+         * included, and a dropped `eslint-disable` silently re-enables the rule it
+         * was suppressing — and dropped every argument past the second outright.
+         */
+        function fixUpdateMethod(fixer, node, callee) {
+            if (callee.computed ||
+                callee.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
             const args = node.arguments;
-            if (args.length === 0)
-                return '';
-            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                const object = sourceCode.getText(node.callee.object);
-                if (object.includes('transaction')) {
-                    const docRef = sourceCode.getText(args[0]);
-                    const data = sourceCode.getText(args[1]);
-                    return `${object}.set(${docRef}, ${data}, { merge: true })`;
+            const lastArgument = args[args.length - 1];
+            if (!lastArgument || hasSpreadArgument(node)) {
+                return null;
+            }
+            const objectText = sourceCode.getText(callee.object);
+            // BatchManager takes a single descriptor object, so its arguments are
+            // genuinely restructured rather than extended.
+            if (objectText.includes('batchManager')) {
+                if (args.length < 2) {
+                    return null;
                 }
-                if (object.includes('batchManager')) {
-                    const docRef = sourceCode.getText(args[0]);
-                    const data = sourceCode.getText(args[1]);
-                    return `${object}.set({
-          ref: ${docRef},
-          data: ${data},
+                return [
+                    fixer.replaceText(node, `${objectText}.set({
+          ref: ${sourceCode.getText(args[0])},
+          data: ${sourceCode.getText(args[1])},
           merge: true,
-        })`;
+        })`),
+                ];
+            }
+            return [
+                fixer.replaceText(callee.property, 'set'),
+                fixer.insertTextAfter(lastArgument, MERGE_ARGUMENT),
+            ];
+        }
+        /**
+         * Drops a binding whose last reference this fix rewrites, so `--fix` does not
+         * leave an unused import behind. Only the entry and the comma separating it
+         * from a sibling go, and only when nothing else lives in that span: a comment
+         * between the entry and its comma belongs to a neighbour as often as to the
+         * entry, and an unused specifier is inert where a deleted comment is not.
+         * A list that would end up empty is left alone too, since emptying it means
+         * rewriting the whole declaration.
+         */
+        function removeBinding(fixer, binding) {
+            if (binding.entries.length < 2) {
+                return [];
+            }
+            const before = sourceCode.getTokenBefore(binding.node, {
+                includeComments: true,
+            });
+            if (isComma(before)) {
+                return [fixer.removeRange([before.range[0], binding.node.range[1]])];
+            }
+            const after = sourceCode.getTokenAfter(binding.node, {
+                includeComments: true,
+            });
+            if (!isComma(after)) {
+                return [];
+            }
+            // Stopping at whatever follows the comma — comment or token — keeps a
+            // directive that documents the next entry attached to it.
+            const next = sourceCode.getTokenAfter(after, { includeComments: true });
+            return [
+                fixer.removeRange([
+                    binding.node.range[0],
+                    next ? next.range[0] : after.range[1],
+                ]),
+            ];
+        }
+        /**
+         * `updateDoc(ref, data)` becomes `setDoc(ref, data, { merge: true })`, which
+         * only works if `setDoc` is bound. The import edit and the call rewrite ship
+         * as one fix array: they sit in disjoint ranges, and a multi-rule `--fix`
+         * that applied one without the other would leave the file with an unbound
+         * name.
+         */
+        function fixUpdateDocCall(fixer, node, callee) {
+            if (isReportSuppressed(node)) {
+                return null;
+            }
+            const lastArgument = node.arguments[node.arguments.length - 1];
+            if (!lastArgument || hasSpreadArgument(node)) {
+                return null;
+            }
+            const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+            const updateVariable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, callee.name);
+            if (!updateVariable || updateVariable.defs.length !== 1) {
+                return null;
+            }
+            const updateBinding = firestoreBindingOf(updateVariable.defs[0]);
+            if (!updateBinding || updateBinding.imported !== UPDATE_DOC) {
+                return null;
+            }
+            // A `setDoc` that means something else makes both halves of the edit
+            // wrong: an added import collides with the declaration (TS2440/TS2300),
+            // and a narrower-scope shadow rebinds the emitted call to the local value
+            // with no diagnostic at all. Resolving from the call's own scope chain
+            // catches both, and declining before the binding is scheduled leaves the
+            // carrier slot to a violation whose scope is safe.
+            const setDocVariable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, SET_DOC);
+            if (setDocVariable && !bindsFirestoreExport(setDocVariable, SET_DOC)) {
+                return null;
+            }
+            // Rewriting the last reference to `updateDoc` frees its binding site, so
+            // the entry is renamed in place — and an alias disappears together with
+            // the reference that used it. Any other reference keeps the old name
+            // alive: adding `setDoc` alongside it is then the only safe edit, because
+            // a multi-rule `--fix` can drop a sibling violation's fix and strand that
+            // reference on a binding this one just removed.
+            const reads = updateVariable.references.filter((reference) => reference.isRead());
+            const isSoleReference = reads.length === 1 && reads[0].identifier === callee;
+            const fixes = [];
+            if (!setDocVariable) {
+                if (!plannedSetDocBinding) {
+                    fixes.push(isSoleReference
+                        ? fixer.replaceText(updateBinding.node, SET_DOC)
+                        : fixer.insertTextAfter(updateBinding.node, `, ${SET_DOC}`));
+                    plannedSetDocBinding = true;
                 }
-                const data = sourceCode.getText(args[0]);
-                return `${object}.set(${data}, { merge: true })`;
             }
-            // For updateDoc from firebase/firestore
-            const docRef = sourceCode.getText(args[0]);
-            const data = args.length > 1 ? sourceCode.getText(args[1]) : '{}';
-            return `setDoc(${docRef}, ${data}, { merge: true })`;
+            else if (isSoleReference) {
+                fixes.push(...removeBinding(fixer, updateBinding));
+            }
+            fixes.push(fixer.replaceText(callee, SET_DOC));
+            // `setDoc` takes the document data between the reference and the options,
+            // so a call that passed no data gets an empty object to merge.
+            fixes.push(fixer.insertTextAfter(lastArgument, node.arguments.length > 1 ? MERGE_ARGUMENT : `, {}${MERGE_ARGUMENT}`));
+            return fixes;
         }
         return {
             ImportDeclaration(node) {
-                if (node.source.value === 'firebase/firestore' ||
-                    node.source.value === 'firebase-admin') {
+                if (FIRESTORE_MODULES.has(node.source.value)) {
                     node.specifiers.forEach((specifier) => {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
-                            if (specifier.imported.name === 'updateDoc') {
+                            if (specifier.imported.name === UPDATE_DOC) {
                                 updateAliases.add(specifier.local.name);
                             }
                         }
                     });
                 }
             },
-            ImportExpression(node) {
-                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
-                    (node.source.value === 'firebase/firestore' ||
-                        node.source.value === 'firebase-admin')) {
-                    // Dynamic imports are handled in VariableDeclarator
-                }
-            },
             VariableDeclarator(node) {
-                if (node.init?.type === utils_1.AST_NODE_TYPES.AwaitExpression &&
-                    node.init.argument.type === utils_1.AST_NODE_TYPES.ImportExpression) {
-                    const importSource = node.init.argument.source;
-                    if (importSource.type === utils_1.AST_NODE_TYPES.Literal &&
-                        (importSource.value === 'firebase/firestore' ||
-                            importSource.value === 'firebase-admin')) {
-                        // Handle destructured imports
-                        if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-                            node.id.properties.forEach((prop) => {
-                                if (prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    prop.key.name === 'updateDoc') {
-                                    if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                        updateAliases.add(prop.value.name);
-                                    }
-                                }
-                            });
+                if (!isFirestoreDynamicImport(node.init)) {
+                    return;
+                }
+                // Handle destructured imports
+                if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    node.id.properties.forEach((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === UPDATE_DOC &&
+                            prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            updateAliases.add(prop.value.name);
                         }
-                    }
+                    });
                 }
             },
             CallExpression(node) {
-                if (isFirestoreUpdateCall(node)) {
-                    context.report({
-                        node,
-                        messageId: 'preferSetMerge',
-                        fix(fixer) {
-                            const newText = convertUpdateToSetMerge(node, context.sourceCode);
-                            return fixer.replaceText(node, newText);
-                        },
-                    });
+                if (!isFirestoreUpdateCall(node)) {
+                    return;
                 }
+                context.report({
+                    node,
+                    messageId: 'preferSetMerge',
+                    fix(fixer) {
+                        if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                            return fixUpdateMethod(fixer, node, node.callee);
+                        }
+                        if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            return fixUpdateDocCall(fixer, node, node.callee);
+                        }
+                        return null;
+                    },
+                });
             },
         };
     },

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