@blumintinc/eslint-plugin-blumint 1.20.168 → 1.20.170

package/lib/index.js

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

package/lib/rules/enforce-dynamic-firebase-imports.d.ts

@@ -1,5 +1,8 @@
-import { TSESLint, TSESTree } from '@typescript-eslint/utils';
-declare const enforceFirebaseImports: TSESLint.RuleModule<"noDynamicImport", never[], {} | {
-    ImportDeclaration(node: TSESTree.ImportDeclaration): void;
-}>;
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        printWidth?: number;
+    }
+];
+declare const enforceFirebaseImports: TSESLint.RuleModule<"noDynamicImport", Options, TSESLint.RuleListener>;
 export default enforceFirebaseImports;

package/lib/rules/enforce-dynamic-firebase-imports.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const isFunctionNode = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
     node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
     node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
@@ -65,6 +66,236 @@ const TEST_FILE_DIRECTORY = /(^|\/)(__tests__|__mocks__)\//;
 const isNeverBundled = (filename) => filename.endsWith('.d.ts') ||
     TEST_FILE_SUFFIX.test(filename) ||
     TEST_FILE_DIRECTORY.test(filename);
+/**
+ * Prettier's own default. The fixer authors a whole statement that a formatter
+ * owns, so a line it emits past this width is rewritten on the next
+ * `prettier --write` — and fails `prettier --check` in the meantime.
+ */
+const DEFAULT_PRINT_WIDTH = 80;
+/**
+ * The file's own nesting step, taken as the most common indentation increase
+ * between consecutive lines. Reading it from the source keeps emitted code in
+ * the author's units instead of assuming a two-space, space-indented file.
+ */
+const indentUnitOf = (sourceCode) => {
+    const blockComments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Block)
+        .map((comment) => comment.range);
+    // A block comment's interior lines carry the comment's own alignment, which
+    // is not a nesting step of the file; counting them makes a JSDoc-heavy file
+    // look 1-space indented.
+    const continuesBlockComment = (offset) => blockComments.some(([start, end]) => start < offset && offset < end);
+    const frequencies = new Map();
+    let previous = '';
+    let offset = 0;
+    for (const line of sourceCode.getText().split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        if (line.trim() === '' || continuesBlockComment(lineStart)) {
+            continue;
+        }
+        const indent = /^[ \t]*/.exec(line)?.[0] ?? '';
+        if (indent.length > previous.length && indent.startsWith(previous)) {
+            const delta = indent.slice(previous.length);
+            frequencies.set(delta, (frequencies.get(delta) ?? 0) + 1);
+        }
+        previous = indent;
+    }
+    let unit = '  ';
+    let best = 0;
+    for (const [delta, count] of frequencies) {
+        if (count > best) {
+            unit = delta;
+            best = count;
+        }
+    }
+    return unit;
+};
+/**
+ * A per-line transform moving text written at `fromIndent` to `toIndent`, or
+ * null when neither indentation is a prefix of the other (tabs against spaces),
+ * where no delta can be applied without corrupting the layout.
+ */
+const lineShifterBetween = (fromIndent, toIndent) => {
+    if (fromIndent === toIndent) {
+        return (line) => line;
+    }
+    if (fromIndent.startsWith(toIndent)) {
+        const removed = fromIndent.slice(toIndent.length);
+        return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
+    }
+    if (toIndent.startsWith(fromIndent)) {
+        const added = toIndent.slice(fromIndent.length);
+        return (line) => `${added}${line}`;
+    }
+    return null;
+};
+/**
+ * Ranges whose interior line breaks carry string data rather than formatting.
+ * A multi-line template literal evaluates to the whitespace written inside it,
+ * so shifting those lines would silently change the value the code produces.
+ */
+const stringDataRangesOf = (sourceCode, node) => sourceCode
+    .getTokens(node)
+    .filter((token) => (token.type === utils_1.AST_TOKEN_TYPES.Template ||
+    token.type === utils_1.AST_TOKEN_TYPES.String) &&
+    token.loc.start.line !== token.loc.end.line)
+    .map((token) => token.range);
+/**
+ * The source spanned by `range` with its continuation lines moved from the
+ * depth they were written at to `toIndent`, or null when that move is not
+ * expressible.
+ *
+ * An expression spliced out of a concise body lands one nesting level deeper
+ * once the arrow gains a block, so every line after the first would otherwise
+ * keep the column it had at the shallower depth (issue #2057). The first line
+ * is excluded because it is spliced in directly after `return `, where it has
+ * no indentation of its own left to adjust.
+ */
+const reindentedRange = (sourceCode, range, stringData, fromIndent, toIndent) => {
+    const text = sourceCode.getText().slice(range[0], range[1]);
+    if (!text.includes('\n')) {
+        return text;
+    }
+    const shiftLine = lineShifterBetween(fromIndent, toIndent);
+    if (!shiftLine) {
+        return null;
+    }
+    const carriesStringData = (offset) => stringData.some(([start, end]) => start < offset && offset < end);
+    let offset = range[0];
+    return text
+        .split('\n')
+        .map((line, index) => {
+        const lineStart = offset;
+        offset += line.length + 1;
+        if (index === 0 || line.trim() === '' || carriesStringData(lineStart)) {
+            return line;
+        }
+        return shiftLine(line);
+    })
+        .join('\n');
+};
+/**
+ * Type syntax that wraps an expression without changing where its parentheses
+ * are needed, so an object literal behind one is still an object literal for
+ * the purposes of {@link wrapsObjectLiteral}.
+ */
+const TYPE_WRAPPER_EXPRESSIONS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+/**
+ * Whether the parentheses around a concise body exist only to keep its leading
+ * brace from parsing as a block.
+ *
+ * Those are the parentheses `return` makes dead, since a return argument is
+ * already an expression position. Every other parenthesized body keeps them:
+ * a broken-open binary expression or a multi-line JSX element is printed
+ * parenthesized in return position too, so dropping them there would trade one
+ * formatter rewrite for another.
+ */
+const wrapsObjectLiteral = (node) => {
+    let current = node;
+    while (TYPE_WRAPPER_EXPRESSIONS.has(current.type)) {
+        current = current
+            .expression;
+    }
+    return current.type === utils_1.AST_NODE_TYPES.ObjectExpression;
+};
+const propertyText = (property) => property.value === undefined
+    ? property.key
+    : `${property.key}: ${property.value}`;
+/** Everything a broken-open `await import(...)` keeps on the line before its argument. */
+const IMPORT_CALL_HEAD = 'await import(';
+/**
+ * Prettier expands an object pattern of more than two properties as soon as one
+ * of them is renamed, whatever the line would otherwise measure
+ * (`isComplexDestructuring`). A renamed specifier and the `default:` entry are
+ * both non-shorthand, so the emitted pattern has to answer that rule as well as
+ * the width to survive `prettier --check`.
+ */
+const isComplexPattern = (binding) => binding.kind === 'pattern' &&
+    binding.properties.length > 2 &&
+    binding.properties.some((property) => property.value !== undefined);
+/**
+ * One property of an expanded pattern. A renamed binding whose own line
+ * overflows breaks after its `:`, which is the last break point the pattern
+ * has; a shorthand one has none, so it is printed as is — exactly what Prettier
+ * does with a name too long for the line it lands on.
+ */
+const printProperty = (property, indent, indentUnit, printWidth) => {
+    const inline = `${indent}${propertyText(property)},`;
+    if (property.value === undefined || inline.length <= printWidth) {
+        return inline;
+    }
+    return `${indent}${property.key}:\n${indent}${indentUnit}${property.value},`;
+};
+const inlineBindingOf = (binding) => binding.kind === 'name'
+    ? binding.name
+    : `{ ${binding.properties.map(propertyText).join(', ')} }`;
+const inlineInitializerOf = (initializer) => initializer.kind === 'import'
+    ? `${IMPORT_CALL_HEAD}'${initializer.path}')`
+    : initializer.text;
+/** The whole declaration on one line, with no break opportunity taken. */
+const printInline = (declaration) => `const ${inlineBindingOf(declaration.binding)} = ${inlineInitializerOf(declaration.initializer)};`;
+/**
+ * Prints the declaration in the shape Prettier prints it at `indent`.
+ *
+ * The specifier list and the module path both come from the source import, so
+ * the one-line form has no length bound and overflows on ordinary firebaseCloud
+ * paths. Wrapping unconditionally is the mirror failure: Prettier collapses an
+ * expanded destructuring pattern, argument list or assignment back onto one line
+ * as soon as it fits, so the width — not the shape of the input — decides.
+ *
+ * Every branch below is a shape Prettier itself emits, so there is no
+ * precondition that can fail and no line the measurement rejects yet still gets
+ * printed.
+ */
+const printDeclaration = (declaration, indent, indentUnit, printWidth) => {
+    const { binding, initializer } = declaration;
+    const oneLine = printInline(declaration);
+    if (indent.length + oneLine.length <= printWidth) {
+        return oneLine;
+    }
+    const inlineHead = `const ${inlineBindingOf(binding)} =`;
+    // An expanded pattern moves the `=` onto the closing brace's line, so it is
+    // that line — not the head — the initializer is measured against.
+    const expanded = binding.kind === 'pattern' &&
+        (isComplexPattern(binding) ||
+            indent.length + inlineHead.length > printWidth)
+        ? {
+            text: `const {\n${binding.properties
+                .map((property) => printProperty(property, `${indent}${indentUnit}`, indentUnit, printWidth))
+                .join('\n')}\n${indent}} =`,
+            tail: '} =',
+        }
+        : { text: inlineHead, tail: inlineHead };
+    const inlineInitializer = inlineInitializerOf(initializer);
+    const tailColumn = indent.length + expanded.tail.length;
+    // The initializer still fits after an expanded pattern's `} =`.
+    if (tailColumn + inlineInitializer.length + 2 <= printWidth) {
+        return `${expanded.text} ${inlineInitializer};`;
+    }
+    // Prettier breaks the call's argument before it breaks after the `=`, so long
+    // as the call head still fits on the line the `=` sits on.
+    const rhsIndent = `${indent}${indentUnit}`;
+    if (initializer.kind === 'import' &&
+        tailColumn + IMPORT_CALL_HEAD.length + 1 <= printWidth) {
+        return `${expanded.text} ${IMPORT_CALL_HEAD}\n${rhsIndent}'${initializer.path}'\n${indent});`;
+    }
+    // Nothing fits beside the `=`: the initializer takes the next line, and
+    // breaks its own argument there when even that line overflows. A module path
+    // wider than the line it lands on is emitted as is — Prettier cannot break a
+    // string literal either, so that is already its output.
+    if (initializer.kind === 'import' &&
+        rhsIndent.length + inlineInitializer.length + 1 > printWidth) {
+        return `${expanded.text}\n${rhsIndent}${IMPORT_CALL_HEAD}\n${rhsIndent}${indentUnit}'${initializer.path}'\n${rhsIndent});`;
+    }
+    return `${expanded.text}\n${rhsIndent}${inlineInitializer};`;
+};
 const enforceFirebaseImports = (0, createRule_1.createRule)({
     name: 'enforce-dynamic-firebase-imports',
     meta: {
@@ -75,14 +306,37 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
         },
         fixable: 'code',
         hasSuggestions: true,
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    printWidth: {
+                        type: 'number',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             noDynamicImport: 'Static import from firebaseCloud path "{{importPath}}" eagerly bundles Firebase code into the initial client chunk, which inflates startup time and prevents lazy loading. Load it at the call site instead, inside an async function body (e.g., `const { export } = await import(\'{{importPath}}\')`). Keep it out of module scope: a top-level `await import(...)` defers nothing and does not parse once the module is compiled to CommonJS.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [{}],
+    create(context, [options]) {
         const sourceCode = context.getSourceCode();
+        const printWidth = typeof options.printWidth === 'number' && options.printWidth > 0
+            ? options.printWidth
+            : DEFAULT_PRINT_WIDTH;
+        // Derived once per file rather than per fix: every fix in a file shares the
+        // author's nesting step.
+        let cachedIndentUnit = null;
+        const fileIndentUnit = () => {
+            if (cachedIndentUnit === null) {
+                cachedIndentUnit = indentUnitOf(sourceCode);
+            }
+            return cachedIndentUnit;
+        };
         // Normalize Windows backslash separators so the forward-slash directory
         // checks match on every platform. Without this, `getFilename()` returns
         // `C:\repo\src\hooks\__tests__\Foo.ts` on Windows and the exemption
@@ -124,38 +378,63 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     : `${spec.imported.name} as ${spec.local.name}`)
                     .join(', ');
                 const destructureEntry = (spec) => spec.imported.name === spec.local.name
-                    ? spec.local.name
-                    : `${spec.imported.name}: ${spec.local.name}`;
-                const buildValueStatements = () => {
+                    ? { key: spec.local.name }
+                    : { key: spec.imported.name, value: spec.local.name };
+                /**
+                 * The declarations to relocate, as structure rather than text: the line
+                 * they land on is only known at the insertion site, and its width is
+                 * what decides their printed shape.
+                 */
+                const buildDeclarations = () => {
                     if (namespaceSpecifier) {
                         const nsLocal = namespaceSpecifier.local.name;
-                        const statements = [
-                            `const ${nsLocal} = await import('${importPath}');`,
+                        const declarations = [
+                            {
+                                binding: { kind: 'name', name: nsLocal },
+                                initializer: { kind: 'import', path: importPath },
+                            },
                         ];
                         if (defaultSpecifier) {
-                            statements.push(`const ${defaultSpecifier.local.name} = ${nsLocal}.default;`);
+                            declarations.push({
+                                binding: { kind: 'name', name: defaultSpecifier.local.name },
+                                initializer: {
+                                    kind: 'expression',
+                                    text: `${nsLocal}.default`,
+                                },
+                            });
                         }
                         if (namedSpecifiers.length > 0) {
-                            statements.push(`const { ${namedSpecifiers
-                                .map(destructureEntry)
-                                .join(', ')} } = ${nsLocal};`);
+                            declarations.push({
+                                binding: {
+                                    kind: 'pattern',
+                                    properties: namedSpecifiers.map(destructureEntry),
+                                },
+                                initializer: { kind: 'expression', text: nsLocal },
+                            });
                         }
-                        return statements;
+                        return declarations;
                     }
-                    const destructureParts = [
+                    const destructureProperties = [
                         ...(defaultSpecifier
-                            ? [`default: ${defaultSpecifier.local.name}`]
+                            ? [{ key: 'default', value: defaultSpecifier.local.name }]
                             : []),
                         ...namedSpecifiers.map(destructureEntry),
                     ];
                     // A side-effect import binds nothing, so there is no declaration to
                     // relocate — the awaited call would have to stay at module scope.
-                    return destructureParts.length > 0
+                    return destructureProperties.length > 0
                         ? [
-                            `const { ${destructureParts.join(', ')} } = await import('${importPath}');`,
+                            {
+                                binding: {
+                                    kind: 'pattern',
+                                    properties: destructureProperties,
+                                },
+                                initializer: { kind: 'import', path: importPath },
+                            },
                         ]
                         : [];
                 };
+                const printAt = (declarations, indent) => declarations.map((declaration) => printDeclaration(declaration, indent, fileIndentUnit(), printWidth));
                 /**
                  * An `ImportDeclaration` only ever sits at module scope, so rewriting
                  * it in place can only ever produce a module-scope `await import(...)`
@@ -194,6 +473,34 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     return target;
                 };
                 const indentationAt = (line) => /^[ \t]*/.exec(sourceCode.lines[line - 1] ?? '')?.[0] ?? '';
+                const commentSegment = (comment) => ({
+                    text: sourceCode.getText().slice(comment.range[0], comment.range[1]),
+                    breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+                });
+                /**
+                 * The comments written inside the import, as one run of text to
+                 * re-emit ahead of the relocated declaration.
+                 *
+                 * The declaration is removed — or, in the type-only branch, re-authored
+                 * from its parts — wholesale, so a comment inside it has no anchor in
+                 * the replacement. Its subject survives, though: every value specifier
+                 * reappears in the emitted destructuring pattern, so the comment has
+                 * somewhere to go and dropping it would be the fixer writing text it
+                 * does not own. Declining instead would only let a comment decide
+                 * whether the rewrite happens at all, which is the same violation seen
+                 * from the other side (#1877), so the comments are carried (#2056).
+                 *
+                 * A `//` comment swallows whatever follows it on its line, so the run
+                 * breaks wherever `requiresLineBreakAfter` says it must, and the
+                 * declaration always begins on the line after it.
+                 */
+                const carriedImportComments = (indent) => {
+                    const comments = sourceCode.getCommentsInside(node);
+                    if (comments.length === 0) {
+                        return null;
+                    }
+                    return (0, replacementSegments_1.joinSegmentBody)(comments.map(commentSegment), indent);
+                };
                 /**
                  * Consumes the import's own trailing whitespace, and its line break
                  * when the import owns the line, so the removal strands neither a blank
@@ -216,38 +523,100 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     }
                     return cursor;
                 };
+                /**
+                 * The span of source the concise body's `return` takes as its argument.
+                 *
+                 * It is copied out of the file rather than reprinted from the AST,
+                 * because the parentheses around an object literal are not part of the
+                 * literal's node and a broken-open expression's own line breaks are not
+                 * recoverable from it. The one thing left behind is a parenthesis pair
+                 * that exists solely to keep a leading brace from parsing as a block:
+                 * `return` already supplies an expression position, so those are dead
+                 * and a formatter strips them (#2057). Any other parenthesized body
+                 * keeps its parentheses — a broken-open binary expression and a
+                 * multi-line JSX element are printed parenthesized in return position
+                 * too.
+                 */
+                const returnedExpressionRange = (arrow, arrowToken) => {
+                    const first = sourceCode.getTokenAfter(arrowToken);
+                    const last = sourceCode.getLastToken(arrow);
+                    const disambiguatingParens = !!first &&
+                        !!last &&
+                        first.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                        first.value === '(' &&
+                        last.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+                        last.value === ')' &&
+                        first.range[1] <= arrow.body.range[0] &&
+                        last.range[0] >= arrow.body.range[1] &&
+                        wrapsObjectLiteral(arrow.body);
+                    return disambiguatingParens
+                        ? [arrow.body.range[0], arrow.body.range[1]]
+                        : [first ? first.range[0] : arrowToken.range[1], arrow.range[1]];
+                };
                 /**
                  * Gives a concise-bodied arrow the block its declaration needs, turning
                  * the returned expression into an explicit `return`.
                  *
-                 * The expression is spliced verbatim out of the source rather than
-                 * reprinted from the AST: the parentheses around an object literal are
-                 * not part of its node, and a comment sitting between `=>` and the
-                 * expression belongs to neither, so both survive only by copying the
-                 * text the arrow already owns.
+                 * The expression moves one nesting level deeper on the way in, so its
+                 * continuation lines are shifted by that delta rather than spliced at
+                 * the column they were written at — everything a multi-line concise
+                 * body holds would otherwise land under-indented inside the block it
+                 * gains (#2057). Lines whose breaks belong to a template literal are
+                 * left alone: their whitespace is the string's own value.
+                 *
+                 * A comment written between `=>` and the expression annotates neither
+                 * node, so it is carried across explicitly. One that cannot share a
+                 * line with what follows takes a line of its own ABOVE the `return`:
+                 * after `return` a line break — or a block comment carrying one, which
+                 * the grammar reads as a line terminator — triggers ASI and silently
+                 * replaces the returned value with `undefined` (#1963).
                  */
-                const blockifyConciseBody = (fixer, arrow, statements) => {
+                const blockifyConciseBody = (fixer, arrow, declarations) => {
                     const arrowToken = sourceCode.getTokenBefore(arrow.body, {
                         filter: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '=>',
                     });
                     if (!arrowToken) {
                         return null;
                     }
-                    const expression = sourceCode
-                        .getText()
-                        .slice(arrowToken.range[1], arrow.range[1])
-                        .trim();
                     const indent = indentationAt(arrow.loc.start.line);
-                    const bodyIndent = `${indent}  `;
-                    const lines = [...statements, `return ${expression};`]
-                        .map((statement) => `\n${bodyIndent}${statement}`)
+                    const bodyIndent = `${indent}${fileIndentUnit()}`;
+                    const range = returnedExpressionRange(arrow, arrowToken);
+                    const expression = reindentedRange(sourceCode, range, stringDataRangesOf(sourceCode, arrow), indentationAt(sourceCode.getLocFromIndex(range[0]).line), bodyIndent);
+                    // Tab-indented source under a space-indented block, or the reverse,
+                    // admits no expressible delta; the body would land mangled, so the
+                    // fix is withheld and the report stands.
+                    if (expression === null) {
+                        return null;
+                    }
+                    const outer = sourceCode
+                        .getCommentsInside(arrow)
+                        .filter((comment) => comment.range[0] >= arrowToken.range[1] &&
+                        (comment.range[1] <= range[0] || comment.range[0] >= range[1]));
+                    const leading = outer.filter((comment) => comment.range[1] <= range[0]);
+                    const trailing = outer.filter((comment) => comment.range[0] >= range[1]);
+                    const hoisted = leading.filter(replacementSegments_1.requiresOwnLine);
+                    const statement = `return ${(0, replacementSegments_1.joinSegmentBody)([
+                        ...leading
+                            .filter((comment) => !(0, replacementSegments_1.requiresOwnLine)(comment))
+                            .map(commentSegment),
+                        { text: `${expression};`, breakAfter: false },
+                        ...trailing.map(commentSegment),
+                    ], bodyIndent)}`;
+                    const carried = carriedImportComments(bodyIndent);
+                    const lines = [
+                        ...(carried === null ? [] : [carried]),
+                        ...printAt(declarations, bodyIndent),
+                        ...hoisted.map((comment) => commentSegment(comment).text),
+                        statement,
+                    ]
+                        .map((emitted) => `\n${bodyIndent}${emitted}`)
                         .join('');
                     return fixer.replaceTextRange([arrowToken.range[1], arrow.range[1]], ` {${lines}\n${indent}}`);
                 };
                 const buildFix = (fixer) => {
                     const target = findRelocationTarget();
-                    const statements = buildValueStatements();
-                    if (!target || statements.length === 0) {
+                    const declarations = buildDeclarations();
+                    if (!target || declarations.length === 0) {
                         return null;
                     }
                     // Type-only specifiers are erased at compile time, so they stay where
@@ -257,7 +626,7 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                         : fixer.removeRange([node.range[0], removalEnd()]);
                     if (target.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
                         target.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-                        const blockified = blockifyConciseBody(fixer, target, statements);
+                        const blockified = blockifyConciseBody(fixer, target, declarations);
                         return blockified ? [importEdit, blockified] : null;
                     }
                     const body = target.body;
@@ -277,15 +646,29 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     const neighbour = following ?? lastDirective;
                     // A body written on one line keeps its shape; a multi-line body gets
                     // the declaration on its own line at the body's own indentation.
-                    const insertion = following && following.loc.start.line === anchorLine
-                        ? ` ${statements.join(' ')}`
-                        : statements
-                            .map((statement) => {
-                            const indent = neighbour
-                                ? indentationAt(neighbour.loc.start.line)
-                                : `${indentationAt(target.loc.start.line)}  `;
-                            return `\n${indent}${statement}`;
-                        })
+                    //
+                    // The one-line body is the single emission the print width does not
+                    // govern: a block body holding statements is a shape no formatter
+                    // prints on one line at all, so there is no width at which the
+                    // author's layout survives and no wrapped form that would restore it.
+                    // Breaking the declaration open there would abandon that layout
+                    // without buying anything. Every other emission lands on a fresh line
+                    // whose column is known, and is printed against it.
+                    const inlineBody = Boolean(following && following.loc.start.line === anchorLine);
+                    const bodyIndent = neighbour && !inlineBody
+                        ? indentationAt(neighbour.loc.start.line)
+                        : `${indentationAt(target.loc.start.line)}${fileIndentUnit()}`;
+                    // A carried comment forces the multi-line form even for a one-line
+                    // body: a `//` comment appended to that line would swallow the rest
+                    // of it, and the comment-free emission is unchanged either way.
+                    const carried = carriedImportComments(bodyIndent);
+                    const insertion = inlineBody && carried === null
+                        ? ` ${declarations.map(printInline).join(' ')}`
+                        : [
+                            ...(carried === null ? [] : [carried]),
+                            ...printAt(declarations, bodyIndent),
+                        ]
+                            .map((statement) => `\n${bodyIndent}${statement}`)
                             .join('');
                     return [
                         importEdit,

package/lib/rules/enforce-firestore-rules-get-access.d.ts

@@ -1,3 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'useGetAccess' | 'requireGetDefault';
-export declare const enforceFirestoreRulesGetAccess: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+type Options = [
+    {
+        printWidth?: number;
+    }
+];
+export declare const enforceFirestoreRulesGetAccess: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
 export {};