@blumintinc/eslint-plugin-blumint 1.20.68 → 1.20.70

package/lib/rules/parallelize-async-operations.js

@@ -785,6 +785,61 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 return null;
             }
             const awaitArguments = awaitExpressions.map((expr) => sourceCode.getText(expr.argument));
+            const startPos = awaitNodes[0].range[0];
+            const endPos = awaitNodes[awaitNodes.length - 1].range[1];
+            // The replacement text is rebuilt from the awaited expressions alone, so
+            // a comment inside the replaced span has no representation in it and
+            // would be silently deleted. Deleting an eslint-disable-next-line
+            // directive re-enables the suppressed rule on the code that survives
+            // inside the Promise.all (#1589). Each span comment is therefore either
+            // re-hosted directly above the array element built from the statement it
+            // annotates, or the fix is declined so no comment is ever destroyed. The
+            // report fires either way.
+            const spanComments = sourceCode
+                .getAllComments()
+                .filter((comment) => comment.range[0] >= startPos && comment.range[1] <= endPos);
+            const hostedComments = awaitNodes.map(() => []);
+            if (spanComments.length > 0) {
+                // Re-hosting maps the comments preceding statement i onto element i,
+                // which requires the element list to line up 1:1 with the statement
+                // list.
+                if (awaitExpressions.length !== awaitNodes.length) {
+                    return null;
+                }
+                for (const comment of spanComments) {
+                    const hostIndex = awaitNodes.findIndex((node, index) => index > 0 &&
+                        comment.range[0] >= awaitNodes[index - 1].range[1] &&
+                        comment.range[1] <= node.range[0]);
+                    if (hostIndex === -1) {
+                        // The comment sits inside one of the merged statements. A comment
+                        // within the awaited expression itself travels verbatim with
+                        // getText; anywhere else (between `await` and its operand, or
+                        // around a declarator's `=`) has no slot in the rebuilt text.
+                        const isInsideArgument = awaitExpressions.some((expr) => comment.range[0] >= expr.argument.range[0] &&
+                            comment.range[1] <= expr.argument.range[1]);
+                        if (!isInsideArgument) {
+                            return null;
+                        }
+                        continue;
+                    }
+                    // A comment that shares the previous statement's last line is a
+                    // trailing comment (e.g. an eslint-disable-line directive) governing
+                    // THAT line; moving it above the next element would change which
+                    // line it applies to.
+                    if (comment.loc.start.line <= awaitNodes[hostIndex - 1].loc.end.line) {
+                        return null;
+                    }
+                    // A directive above `const x = await f();` may target the
+                    // declaration's identifier, which the rewrite moves into the
+                    // destructuring pattern on the Promise.all line — away from every
+                    // line the re-hosted directive could govern.
+                    if (/^\s*eslint-/u.test(comment.value) &&
+                        awaitNodes[hostIndex].type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                        return null;
+                    }
+                    hostedComments[hostIndex].push(comment);
+                }
+            }
             const idsText = [];
             const declKinds = new Set();
             let hasVariableDeclarations = false;
@@ -817,7 +872,17 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             // the contents of a template literal, where whitespace is significant
             // data rather than formatting and re-indenting would silently change the
             // produced string.
-            const elementsText = awaitArguments.join(`,\n${elementIndent}`);
+            const elementsText = awaitArguments
+                .map((argumentText, index) => {
+                // Each re-hosted comment lands on its own line directly above the
+                // element, which is the only placement where a disable-next-line
+                // directive keeps suppressing it.
+                const leadingText = (hostedComments[index] ?? [])
+                    .map((comment) => `${sourceCode.getText(comment)}\n${elementIndent}`)
+                    .join('');
+                return `${leadingText}${argumentText}`;
+            })
+                .join(`,\n${elementIndent}`);
             let promiseAllText;
             if (hasVariableDeclarations) {
                 if (declKinds.size !== 1) {
@@ -834,8 +899,6 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 // Simple Promise.all without variable assignments
                 promiseAllText = `await Promise.all([\n${elementIndent}${elementsText}\n${baseIndent}]);`;
             }
-            const startPos = awaitNodes[0].range[0];
-            const endPos = awaitNodes[awaitNodes.length - 1].range[1];
             return fixer.replaceTextRange([startPos, endPos], promiseAllText);
         }
         /**

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -62,6 +62,37 @@ function parenthesizeForUnion(text) {
     const needsParens = text.includes('=>') || /^new\b/.test(text) || /\bextends\b/.test(text);
     return needsParens ? `(${text})` : text;
 }
+/**
+ * How position-sensitive a comment is when the fix relocates it onto the
+ * generated Record:
+ *
+ * - `next-line`: suppresses exactly the following line
+ *   (`eslint-disable-next-line`, `@ts-expect-error`, `@ts-ignore`) — hosting
+ *   it anywhere but directly above the line it suppressed silently changes
+ *   which rules report.
+ * - `own-line`: suppresses its own line (`eslint-disable-line`) — must stay on
+ *   the same line as the value it annotates.
+ * - `range`: opens/closes a suppression region or configures the linter
+ *   (`eslint-disable`, `eslint-enable`, `eslint-env`, `eslint`, `global`,
+ *   `exported`) — ESLint honors these only in block-comment form, and
+ *   relocation can move the region boundary across reported lines, so the fix
+ *   is never attempted around one.
+ * - `none`: prose; content preservation suffices.
+ */
+function directiveKindOf(comment) {
+    const text = comment.value.trim();
+    if (/^(eslint-disable-next-line|@ts-expect-error|@ts-ignore)\b/.test(text)) {
+        return 'next-line';
+    }
+    if (/^eslint-disable-line\b/.test(text)) {
+        return 'own-line';
+    }
+    if (comment.type === utils_1.AST_TOKEN_TYPES.Block &&
+        /^(eslint-disable|eslint-enable|eslint-env|eslint\b|globals?\b|exported\b)/.test(text)) {
+        return 'range';
+    }
+    return 'none';
+}
 exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
     name: 'prefer-map-over-conditional-dispatch',
     meta: {
@@ -360,7 +391,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             }
             const stmt = stmts[0];
             if (stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-                return { kind: 'return', expr: stmt.argument };
+                return { kind: 'return', expr: stmt.argument, stmt };
             }
             if (stmt.type === utils_1.AST_NODE_TYPES.ExpressionStatement &&
                 stmt.expression.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
@@ -369,6 +400,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     kind: 'assign',
                     target: stmt.expression.left,
                     expr: stmt.expression.right,
+                    stmt,
                 };
             }
             return null;
@@ -504,13 +536,92 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             return match ? match[0] : '';
         }
         function buildRecordText(name, dText, vText, entries, baseIndent) {
-            const lines = entries.map((e) => `${baseIndent}  ${formatKey(e.key)}: ${e.valueText},`);
+            const lines = entries.flatMap((e) => {
+                const hosted = (e.leadingComments ?? []).map((comment) => `${baseIndent}  ${comment}`);
+                const trailing = e.trailingComments && e.trailingComments.length > 0
+                    ? ` ${e.trailingComments.join(' ')}`
+                    : '';
+                hosted.push(`${baseIndent}  ${formatKey(e.key)}: ${e.valueText},${trailing}`);
+                return hosted;
+            });
             return [
                 `const ${name}: Record<${dText}, ${vText}> = {`,
                 ...lines,
                 `${baseIndent}};`,
             ].join('\n');
         }
+        /**
+         * Decides where every comment inside the replaced construct lands on the
+         * generated Record, mutating `entries` with the hosted text. Comments
+         * inside a carried span (a branch value expression, the discriminant, the
+         * assignment target) survive verbatim inside the copied text; comments
+         * inside a dropped span (an unreachable default/tail) die together with
+         * the code they annotate, which is not an orphaning. Every other comment
+         * must be hosted onto a map entry — leading comments go on the line(s)
+         * directly above the entry, same-line trailing comments append after it.
+         * Returns false when a comment cannot be hosted without changing what it
+         * annotates or suppresses; the caller then withholds the autofix so a
+         * directive is never silently deleted or retargeted.
+         */
+        function planCommentHosting(args) {
+            const { container, carriedSpans, droppedSpans, anchors, entries } = args;
+            const ordered = [...anchors].sort((a, b) => a.range[0] - b.range[0]);
+            const hostLeading = (entry, text) => {
+                entry.leadingComments = [...(entry.leadingComments ?? []), text];
+            };
+            const hostTrailing = (entry, text) => {
+                entry.trailingComments = [...(entry.trailingComments ?? []), text];
+            };
+            for (const comment of sourceCode.getCommentsInside(container)) {
+                const [cStart, cEnd] = comment.range;
+                const within = (spans) => spans.some(([start, end]) => cStart >= start && cEnd <= end);
+                if (within(carriedSpans) || within(droppedSpans)) {
+                    continue;
+                }
+                const kind = directiveKindOf(comment);
+                if (kind === 'range') {
+                    return false;
+                }
+                const text = sourceCode.getText(comment);
+                // Same-line trailing (`doThing(); // note`): append to the entry line
+                // so an `eslint-disable-line` keeps suppressing the line its value
+                // lands on. The last matching anchor wins so a comment trailing two
+                // same-line statements attaches to the nearer one.
+                const trailingCandidates = ordered.filter((anchor) => anchor.endLine === comment.loc.start.line &&
+                    cStart >= anchor.range[1]);
+                const trailingAnchor = trailingCandidates[trailingCandidates.length - 1];
+                if (trailingAnchor) {
+                    if (kind === 'next-line') {
+                        // A trailing disable-next-line targets whatever follows the
+                        // statement; the generated map has no equivalent following line.
+                        return false;
+                    }
+                    if (kind === 'own-line' && trailingAnchor.entryCount > 1) {
+                        return false;
+                    }
+                    hostTrailing(entries[trailingAnchor.entryIndex], text);
+                    continue;
+                }
+                // A comment inside the value statement but outside the copied
+                // expression (`return /* why */ value;`) belongs to that branch.
+                const containingAnchor = ordered.find((anchor) => cStart >= anchor.range[0] && cEnd <= anchor.range[1]);
+                const leadingAnchor = containingAnchor ?? ordered.find((anchor) => anchor.range[0] >= cEnd);
+                if (!leadingAnchor) {
+                    return false;
+                }
+                if (kind === 'next-line') {
+                    // Host a line-targeted directive only when it provably targeted the
+                    // branch's value line, so relocation preserves — never widens or
+                    // drops — the suppression.
+                    if (leadingAnchor.entryCount > 1 ||
+                        leadingAnchor.startLine !== comment.loc.end.line + 1) {
+                        return false;
+                    }
+                }
+                hostLeading(entries[leadingAnchor.entryIndex], text);
+            }
+            return true;
+        }
         /**
          * Given ordered explicit branches + optional tail, resolve coverage against
          * the union's literal keys and (when full) the ordered Record entries.
@@ -564,20 +675,28 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (!flags.canPlaceFix) {
                 return 'the dispatch sits inside an expression-bodied function; extract the Record manually so it stays in scope';
             }
+            if (!flags.commentSafe) {
+                return 'a comment inside the dispatch cannot be carried onto the generated Record without changing what it annotates or suppresses — relocate the comment, then convert';
+            }
             return 'a collision-free lookup name could not be derived from the discriminant';
         }
         function report(node, analysis) {
-            const { entries, contributingValues, dText, form, assignTargetText, fullCoverage, hasNullish, canPlaceFix, } = analysis;
+            const { entries, contributingValues, dText, form, assignTargetText, fullCoverage, hasNullish, canPlaceFix, commentBlocked, } = analysis;
             const eagerSafe = contributingValues.every((expr) => !containsEagerUnsafe(expr));
             let name = null;
             // Name derivation is only needed for the autofix path.
-            if (fullCoverage && !hasNullish && eagerSafe && canPlaceFix) {
+            if (fullCoverage &&
+                !hasNullish &&
+                eagerSafe &&
+                canPlaceFix &&
+                !commentBlocked) {
                 name = deriveLookupName(discriminantOf(node));
             }
             const autofixable = fullCoverage &&
                 !hasNullish &&
                 eagerSafe &&
                 canPlaceFix &&
+                !commentBlocked &&
                 name !== null;
             if (!autofixable) {
                 context.report({
@@ -589,6 +708,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                             hasNullish,
                             eagerSafe,
                             canPlaceFix,
+                            commentSafe: !commentBlocked,
                         }),
                     },
                 });
@@ -700,7 +820,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     continue;
                 }
                 const value = extractBranchValue(c.consequent);
-                parsed.push({ tests: [...pending, c.test], value });
+                parsed.push({ tests: [...pending, c.test], value, caseNode: c });
                 pending = [];
             }
             if (pending.length > 0) {
@@ -714,6 +834,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             const explicit = [];
             let defaultValue;
             let hasDefault = false;
+            let defaultCaseNode = null;
             for (const branch of parsed) {
                 const literalTests = branch.tests.filter((t) => t !== null);
                 const isDefaultGroup = literalTests.length !== branch.tests.length;
@@ -724,6 +845,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     }
                     hasDefault = true;
                     defaultValue = branch.value;
+                    defaultCaseNode = branch.caseNode;
                     continue;
                 }
                 if (!branch.value) {
@@ -798,6 +920,57 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (isNarrowingExempt(node.discriminant, contributingValues)) {
                 return;
             }
+            // Comment hosting only gates the autofix path (partial coverage is
+            // already report-only), so it is planned for full coverage alone.
+            let commentBlocked = false;
+            if (coverage.fullCoverage) {
+                const tailUsed = coverage.remainingCount === 1 && defaultVal !== null;
+                const carriedSpans = [node.discriminant.range];
+                const droppedSpans = [];
+                const anchors = [];
+                let entryIndex = 0;
+                for (const branch of explicit) {
+                    carriedSpans.push(branch.value.expr.range);
+                    anchors.push({
+                        range: branch.value.stmt.range,
+                        startLine: branch.value.stmt.loc.start.line,
+                        endLine: branch.value.stmt.loc.end.line,
+                        entryIndex,
+                        entryCount: branch.keys.length,
+                    });
+                    entryIndex += branch.keys.length;
+                }
+                if (kind === 'assign' && explicit[0].value.kind === 'assign') {
+                    carriedSpans.push(explicit[0].value.target.range);
+                }
+                if (tailUsed && defaultVal) {
+                    carriedSpans.push(defaultVal.expr.range);
+                    anchors.push({
+                        range: defaultVal.stmt.range,
+                        startLine: defaultVal.stmt.loc.start.line,
+                        endLine: defaultVal.stmt.loc.end.line,
+                        entryIndex: coverage.entries.length - 1,
+                        entryCount: 1,
+                    });
+                }
+                else if (defaultCaseNode) {
+                    // The unreachable default is deleted wholesale; its comments —
+                    // including any directly above the `default:` label — annotate
+                    // deleted code and die with it.
+                    const caseIndex = node.cases.indexOf(defaultCaseNode);
+                    const droppedStart = caseIndex > 0
+                        ? node.cases[caseIndex - 1].range[1]
+                        : node.discriminant.range[1];
+                    droppedSpans.push([droppedStart, defaultCaseNode.range[1]]);
+                }
+                commentBlocked = !planCommentHosting({
+                    container: node,
+                    carriedSpans,
+                    droppedSpans,
+                    anchors,
+                    entries: coverage.entries,
+                });
+            }
             report(node, {
                 entries: coverage.entries,
                 contributingValues,
@@ -807,6 +980,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 fullCoverage: coverage.fullCoverage,
                 hasNullish,
                 canPlaceFix: true,
+                commentBlocked,
             });
         }
         // ---- Ternary form -------------------------------------------------------
@@ -906,6 +1080,47 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     crossesFunction = true;
                 }
             }
+            let commentBlocked = false;
+            if (coverage.fullCoverage) {
+                const tailUsed = coverage.remainingCount === 1;
+                const carriedSpans = [
+                    head.discNode.range,
+                    ...links.map((l) => l.expr.range),
+                ];
+                const droppedSpans = [];
+                const anchors = links.map((l, i) => ({
+                    range: l.expr.range,
+                    startLine: l.expr.loc.start.line,
+                    endLine: l.expr.loc.end.line,
+                    entryIndex: i,
+                    entryCount: 1,
+                }));
+                if (tailUsed) {
+                    carriedSpans.push(tailExpr.range);
+                    anchors.push({
+                        range: tailExpr.range,
+                        startLine: tailExpr.loc.start.line,
+                        endLine: tailExpr.loc.end.line,
+                        entryIndex: coverage.entries.length - 1,
+                        entryCount: 1,
+                    });
+                }
+                else {
+                    // The unreachable tail is deleted; comments between the last kept
+                    // consequent and the tail's end annotate deleted code.
+                    droppedSpans.push([
+                        links[links.length - 1].expr.range[1],
+                        tailExpr.range[1],
+                    ]);
+                }
+                commentBlocked = !planCommentHosting({
+                    container: node,
+                    carriedSpans,
+                    droppedSpans,
+                    anchors,
+                    entries: coverage.entries,
+                });
+            }
             discriminantMap.set(node, head.discNode);
             report(node, {
                 entries: coverage.entries,
@@ -915,6 +1130,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 fullCoverage: coverage.fullCoverage,
                 hasNullish,
                 canPlaceFix: !crossesFunction,
+                commentBlocked,
             });
         }
         // ---- if / else-if form --------------------------------------------------
@@ -935,6 +1151,10 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             }
             const links = [];
             let tail = null;
+            // The final else statement/block and the end of the consequent before
+            // it — the source region a dropped tail's comments die with.
+            let tailNode = null;
+            let tailPrevEnd = 0;
             let cur = node;
             while (cur) {
                 const link = equalityDiscriminant(cur.test);
@@ -960,6 +1180,8 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     return;
                 }
                 tail = tailValue;
+                tailNode = alt;
+                tailPrevEnd = cur.consequent.range[1];
                 cur = null;
             }
             if (links.length === 0) {
@@ -1012,6 +1234,48 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (isNarrowingExempt(head.discNode, contributingValues)) {
                 return;
             }
+            let commentBlocked = false;
+            if (coverage.fullCoverage) {
+                const tailUsed = coverage.remainingCount === 1 && tail !== null;
+                const carriedSpans = [head.discNode.range];
+                const droppedSpans = [];
+                const anchors = [];
+                links.forEach((link, i) => {
+                    carriedSpans.push(link.value.expr.range);
+                    anchors.push({
+                        range: link.value.stmt.range,
+                        startLine: link.value.stmt.loc.start.line,
+                        endLine: link.value.stmt.loc.end.line,
+                        entryIndex: i,
+                        entryCount: 1,
+                    });
+                });
+                if (kind === 'assign' && links[0].value.kind === 'assign') {
+                    carriedSpans.push(links[0].value.target.range);
+                }
+                if (tailUsed && tail) {
+                    carriedSpans.push(tail.expr.range);
+                    anchors.push({
+                        range: tail.stmt.range,
+                        startLine: tail.stmt.loc.start.line,
+                        endLine: tail.stmt.loc.end.line,
+                        entryIndex: coverage.entries.length - 1,
+                        entryCount: 1,
+                    });
+                }
+                else if (tailNode) {
+                    // The unreachable else is deleted; comments from the last kept
+                    // consequent through the else's end annotate deleted code.
+                    droppedSpans.push([tailPrevEnd, tailNode.range[1]]);
+                }
+                commentBlocked = !planCommentHosting({
+                    container: node,
+                    carriedSpans,
+                    droppedSpans,
+                    anchors,
+                    entries: coverage.entries,
+                });
+            }
             discriminantMap.set(node, head.discNode);
             report(node, {
                 entries: coverage.entries,
@@ -1022,6 +1286,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 fullCoverage: coverage.fullCoverage,
                 hasNullish,
                 canPlaceFix: true,
+                commentBlocked,
             });
         }
         return {

package/lib/rules/prefer-type-over-interface.js

@@ -47,6 +47,38 @@ function isInsideModuleAugmentation(node) {
     }
     return false;
 }
+/**
+ * Declaration merging is what `interface` can do and `type` cannot, so a name
+ * carrying more than one declaration is not a stylistic choice: rewriting one
+ * of the halves emits two declarations of the same name (TS2300) and silently
+ * splits the merged shape, so members that used to coexist no longer do.
+ *
+ * The check keys on the **declaring scope**, not on a count of the name across
+ * the file, because merging is a property of the declaration space. Two
+ * same-named interfaces in different function bodies or blocks are distinct
+ * types that never merge, and each of those still converts cleanly.
+ *
+ * Any second definition counts, not only another interface. `class A {}` and
+ * `enum A {}` occupy the same type-space slot a type alias would claim, so
+ * those conversions break the build too; `function A() {}` and
+ * `namespace A {}` are value-space only and would survive the rewrite, but
+ * they are rare enough that treating every co-declaration as merged costs
+ * almost nothing and keeps the rule from having to model TypeScript's merging
+ * table.
+ */
+function isMergedDeclaration(context, node) {
+    // The variable is located by the definition that points back at *this*
+    // declaration rather than by taking the first entry, so a parser that also
+    // surfaces the type parameters here cannot make the count read off the
+    // wrong name.
+    const declared = context
+        .getDeclaredVariables(node)
+        .find((variable) => variable.defs.some((definition) => definition.node === node));
+    // A scope manager that never registered the name tells us nothing about
+    // merging; falling through preserves the report rather than exempting on a
+    // missing signal.
+    return declared !== undefined && declared.defs.length > 1;
+}
 exports.preferTypeOverInterface = (0, createRule_1.createRule)({
     name: 'prefer-type-over-interface',
     meta: {
@@ -70,6 +102,12 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
                 if (isInsideModuleAugmentation(node)) {
                     return;
                 }
+                // Reporting without a fix would be unactionable here — the author
+                // cannot honour it without collapsing the merge by hand — and an
+                // unactionable report is what manufactures `eslint-disable` (#1568).
+                if (isMergedDeclaration(context, node)) {
+                    return;
+                }
                 context.report({
                     node,
                     messageId: 'preferType',

package/lib/rules/use-latest-callback.d.ts

@@ -1,3 +1,8 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export declare const useLatestCallback: TSESLint.RuleModule<"useLatestCallback", [], TSESLint.RuleListener>;
+type Options = [
+    {
+        printWidth?: number;
+    }
+];
+export declare const useLatestCallback: TSESLint.RuleModule<"useLatestCallback", Options, TSESLint.RuleListener>;
 export default useLatestCallback;