@blumintinc/eslint-plugin-blumint 1.20.134 → 1.20.136

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -248,6 +248,27 @@ function declaredTypeNode(node) {
 function checksExcessProperties(typeNode) {
     return typeNode !== null && !UNCHECKED_ANNOTATION_TYPES.has(typeNode.type);
 }
+/** `as const` declares no members of its own, so it pins no name. */
+function isConstAssertionType(typeNode) {
+    return (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeNode.typeName.name === 'const');
+}
+/**
+ * An `as T` / `<T>` whose target type declares members the value must still
+ * have. Renaming one of them makes the assertion uncomparable (TS2352), so the
+ * name is dictated by `T` rather than chosen by the author — the same reasoning
+ * the annotation arms use, applied to the check an assertion actually performs.
+ */
+function isCheckedTypeAssertion(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.TSAsExpression &&
+        node.type !== utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+        return false;
+    }
+    const { typeAnnotation } = node;
+    return (checksExcessProperties(typeAnnotation) &&
+        !isConstAssertionType(typeAnnotation));
+}
 function isFunctionNode(node) {
     return (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
         node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
@@ -310,10 +331,18 @@ const EXPRESSION_ASSERTION_TYPES = new Set([
  * members, and climbs THROUGH assertion wrappers, which change no runtime value
  * and so cannot detach a literal from the declared type it is assigned to
  * (#1597) — `enforce-object-literal-as-const` ships in the same recommended
- * config and appends `as const` to exactly these literals by `--fix`. An
- * assertion is transparent, never itself a signal: `{...} as T` still reports,
- * because an `as` clause does not reject undeclared members the way an
- * annotation does. The walk stops at anything else.
+ * config and appends `as const` to exactly these literals by `--fix`.
+ *
+ * An `as T` is itself a signal when `T` declares members. It is true that an
+ * `as` clause does not reject EXCESS members the way an annotation does
+ * (`{ orderBy, extra } as Q` compiles; `const c: Q = { orderBy, extra }` is
+ * TS2322) — but the operation being gated is a RENAME, which removes a REQUIRED
+ * member, and that an assertion does reject: `{ order } as Q` is TS2352 when `Q`
+ * requires `orderBy`. Reasoning from excess properties alone made the rule
+ * demand a rename that does not compile (#1885). `as const` is the exception
+ * and stays transparent, declaring no members of its own.
+ *
+ * The walk stops at anything else.
  */
 function hasConformanceSignal(node) {
     let current = node;
@@ -330,6 +359,19 @@ function hasConformanceSignal(node) {
             checksExcessProperties(parent.typeAnnotation)) {
             return true;
         }
+        // An `as T` DOES pin the member names it requires, even though it does not
+        // reject excess ones. The two are different checks: excess-property
+        // checking is what an annotation adds, but a RENAME removes a REQUIRED
+        // member, and that breaks comparability — `{ beta: 1 } as T` is TS2352 when
+        // `T` requires `alpha`. Reasoning from excess properties alone made the rule
+        // demand a rename that does not compile (#1885). `as const` stays
+        // transparent: it declares no members of its own, and
+        // `enforce-object-literal-as-const` appends one to exactly these literals.
+        if (isCheckedTypeAssertion(parent) &&
+            parent
+                .expression === current) {
+            return true;
+        }
         if (EXPRESSION_ASSERTION_TYPES.has(parent.type)) {
             current = parent;
             continue;

package/lib/rules/no-useless-usememo-primitives.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUselessUsememoPrimitives = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const tsTypeClassifier_1 = require("../utils/tsTypeClassifier");
 const DEFAULT_OPTIONS = {
     ignoreCallExpressions: true,
@@ -381,24 +382,44 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
                         valueKind,
                     },
                     fix(fixer) {
+                        const expressionText = sourceCode.getText(returnedExpression);
                         // Inlining replaces the entire useMemo(...) call with the returned
                         // expression's text, so any comment inside the call but outside
                         // that expression — an eslint-disable-next-line directive on the
                         // return statement among them — has no representation in the
-                        // replacement and would be silently destroyed, changing which
-                        // rules report on the file (#1591). The inlined expression lands
-                        // mid-line (e.g. `const label = <expr>;`), where a -next-line
-                        // directive cannot be hosted, so the autofix declines and leaves
-                        // the report for a manual fix.
+                        // replacement. Dropping one changes which rules report on the file
+                        // (#1591), and declining the fix whenever one is present makes a
+                        // comment decide whether the rule rewrites at all (#1877). Both are
+                        // avoided by carrying every such comment into the replacement,
+                        // where the directives among them keep the line relationship they
+                        // were written with.
                         const strandedComments = sourceCode
                             .getCommentsInside(node)
                             .filter((comment) => comment.range[0] < returnedExpression.range[0] ||
                             comment.range[1] > returnedExpression.range[1]);
-                        if (strandedComments.length > 0) {
-                            return null;
+                        if (strandedComments.length === 0) {
+                            return fixer.replaceText(node, `(${expressionText})`);
                         }
-                        const replacement = `(${sourceCode.getText(returnedExpression)})`;
-                        return fixer.replaceText(node, replacement);
+                        // A comment inside the call lies wholly on one side of the
+                        // expression, since a comment is a token and cannot straddle a
+                        // node; keeping each on its own side preserves what it annotates.
+                        const toSegment = (comment) => ({
+                            text: sourceCode.text.slice(comment.range[0], comment.range[1]),
+                            breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+                        });
+                        const isBefore = (comment) => comment.range[0] < returnedExpression.range[0];
+                        const segments = [
+                            ...strandedComments.filter(isBefore).map(toSegment),
+                            { text: expressionText, breakAfter: false },
+                            ...strandedComments
+                                .filter((comment) => !isBefore(comment))
+                                .map(toSegment),
+                        ];
+                        // The call can start mid-line, so the indentation of the line it
+                        // opens on is the only anchor the carried comments have.
+                        const startLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
+                        const indent = /^[\t ]*/.exec(startLine)?.[0] ?? '';
+                        return fixer.replaceText(node, (0, replacementSegments_1.joinSegments)(segments, indent));
                     },
                 });
             },

package/lib/rules/no-usememo-for-pass-by-value.js

@@ -7,6 +7,7 @@ exports.noUsememoForPassByValue = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const typescript_1 = __importDefault(require("typescript"));
 const createRule_1 = require("../utils/createRule");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const DEFAULT_EXPENSIVE_PATTERNS = [
     'compute',
     'calculate',
@@ -280,37 +281,109 @@ function removeCompleteImport(importDeclaration, sourceCode, fixer) {
     }
     return fixer.removeRange([start, removalEnd]);
 }
-function removePartialImport(importDeclaration, remainingSpecifiers, sourceCode, fixer) {
-    const defaultSpecifier = remainingSpecifiers.find((candidate) => candidate.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
-    const namespaceSpecifier = remainingSpecifiers.find((candidate) => candidate.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
-    const namedSpecifiers = remainingSpecifiers.filter((candidate) => candidate.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
-    const pieces = [];
-    if (defaultSpecifier) {
-        pieces.push(sourceCode.getText(defaultSpecifier));
-    }
-    if (namespaceSpecifier) {
-        pieces.push(sourceCode.getText(namespaceSpecifier));
-    }
-    if (namedSpecifiers.length > 0) {
-        pieces.push(`{ ${namedSpecifiers
-            .map((candidate) => sourceCode.getText(candidate))
-            .join(', ')} }`);
-    }
-    const importPrefix = importDeclaration.importKind === 'type' ? 'import type ' : 'import ';
-    const newImport = `${importPrefix}${pieces.join(', ')} from ${sourceCode.getText(importDeclaration.source)};`;
-    return fixer.replaceText(importDeclaration, newImport);
+/**
+ * Removing the last binding removes the whole declaration, but a comment
+ * written inside it (between the braces, around the source) must not go with
+ * it: the declaration's span is re-emitted as just those comments, each kept in
+ * order, with a line break appended when the last one would otherwise swallow
+ * whatever follows the declaration on its line.
+ */
+function removeCompleteImportPreservingComments(importDeclaration, sourceCode, fixer) {
+    const comments = sourceCode.getCommentsInside(importDeclaration);
+    if (comments.length === 0) {
+        return removeCompleteImport(importDeclaration, sourceCode, fixer);
+    }
+    const text = sourceCode.getText();
+    const carried = comments
+        .map((comment) => text.slice(comment.range[0], comment.range[1]))
+        .join('\n');
+    const suffix = (0, replacementSegments_1.requiresLineBreakAfter)(comments[comments.length - 1])
+        ? '\n'
+        : '';
+    return fixer.replaceText(importDeclaration, `${carried}${suffix}`);
+}
+function isCommaToken(token) {
+    return (token !== null &&
+        token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+        token.value === ',');
 }
-function getImportRemovalFix(specifier, sourceCode, fixer) {
+/**
+ * Deletes the `useMemo` specifier and one adjacent comma while other NAMED
+ * specifiers remain. Only the tokens being retired are edited — never the
+ * declaration re-emitted from its parts — so every comment elsewhere in the
+ * declaration survives verbatim. When nothing but whitespace separates the
+ * retired tokens from their neighbour the removal range swallows that
+ * whitespace too; when a comment sits in between, the tokens are removed
+ * individually around it.
+ */
+function removeSpecifierFixes(specifier, sourceCode, fixer) {
+    const commaAfter = sourceCode.getTokenAfter(specifier);
+    if (isCommaToken(commaAfter)) {
+        const nextToken = sourceCode.getTokenAfter(commaAfter);
+        if (nextToken && !sourceCode.commentsExistBetween(specifier, nextToken)) {
+            return [fixer.removeRange([specifier.range[0], nextToken.range[0]])];
+        }
+        return [fixer.remove(specifier), fixer.removeRange(commaAfter.range)];
+    }
+    const commaBefore = sourceCode.getTokenBefore(specifier);
+    if (isCommaToken(commaBefore)) {
+        if (!sourceCode.commentsExistBetween(commaBefore, specifier)) {
+            return [fixer.removeRange([commaBefore.range[0], specifier.range[1]])];
+        }
+        return [fixer.removeRange(commaBefore.range), fixer.remove(specifier)];
+    }
+    return [fixer.remove(specifier)];
+}
+/**
+ * Deletes the whole `{ useMemo }` group — braces, specifier and the comma
+ * joining it to the default specifier — when `useMemo` is the only named
+ * binding but a default import keeps the declaration alive. As above, comments
+ * inside the group survive by shrinking the edit to the individual tokens.
+ */
+function removeNamedGroupFixes(specifier, sourceCode, fixer) {
+    const openBrace = sourceCode.getTokenBefore(specifier, {
+        filter: (token) => token.value === '{',
+    });
+    const closeBrace = sourceCode.getTokenAfter(specifier, {
+        filter: (token) => token.value === '}',
+    });
+    if (!openBrace || !closeBrace) {
+        return [fixer.remove(specifier)];
+    }
+    const commaBefore = sourceCode.getTokenBefore(openBrace);
+    const start = isCommaToken(commaBefore) ? commaBefore : openBrace;
+    if (!sourceCode.commentsExistBetween(start, closeBrace)) {
+        return [fixer.removeRange([start.range[0], closeBrace.range[1]])];
+    }
+    const fixes = [];
+    if (start !== openBrace) {
+        fixes.push(fixer.removeRange(start.range));
+    }
+    fixes.push(fixer.removeRange(openBrace.range), fixer.remove(specifier));
+    const trailingComma = sourceCode.getTokenAfter(specifier);
+    if (isCommaToken(trailingComma)) {
+        fixes.push(fixer.removeRange(trailingComma.range));
+    }
+    fixes.push(fixer.removeRange(closeBrace.range));
+    return fixes;
+}
+function getImportRemovalFixes(specifier, sourceCode, fixer) {
     const importDeclaration = specifier.parent;
     if (!importDeclaration ||
         importDeclaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
-        return null;
+        return [];
     }
     const remainingSpecifiers = importDeclaration.specifiers.filter((candidate) => candidate !== specifier);
     if (remainingSpecifiers.length === 0) {
-        return removeCompleteImport(importDeclaration, sourceCode, fixer);
+        return [
+            removeCompleteImportPreservingComments(importDeclaration, sourceCode, fixer),
+        ];
+    }
+    const hasOtherNamedSpecifiers = remainingSpecifiers.some((candidate) => candidate.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+    if (!hasOtherNamedSpecifiers) {
+        return removeNamedGroupFixes(specifier, sourceCode, fixer);
     }
-    return removePartialImport(importDeclaration, remainingSpecifiers, sourceCode, fixer);
+    return removeSpecifierFixes(specifier, sourceCode, fixer);
 }
 function getReplacementText(callback, sourceCode) {
     const returnedExpression = getReturnedExpression(callback);
@@ -323,6 +396,23 @@ function getReplacementText(callback, sourceCode) {
     }
     return sourceCode.getText(returnedExpression);
 }
+/**
+ * Comments inside the `useMemo(...)` span but outside the returned expression.
+ *
+ * The fix replaces the whole call with the text of the returned expression, so
+ * the callback wrapper, the `return` keyword, the dependency array and every
+ * piece of trivia between them disappear. A comment sitting in any of those
+ * places has no surviving anchor in the replacement, so the fixer carries it
+ * into the replacement instead (#1877). A comment inside the returned
+ * expression needs no carrying: its text is copied verbatim with the
+ * expression.
+ */
+function strandedCommentsOf(node, returnedExpression, sourceCode) {
+    return sourceCode
+        .getCommentsInside(node)
+        .filter((comment) => comment.range[0] < returnedExpression.range[0] ||
+        comment.range[1] > returnedExpression.range[1]);
+}
 function isSafeAtomicExpression(expression) {
     switch (expression.type) {
         case utils_1.AST_NODE_TYPES.Identifier:
@@ -555,16 +645,80 @@ exports.noUsememoForPassByValue = (0, createRule_1.createRule)({
                 return null;
             }
             const needsParentheses = shouldParenthesizeReplacement(node, returnedExpression, sourceCode);
-            const replacement = needsParentheses
-                ? `(${replacementText})`
-                : replacementText;
+            const strandedComments = strandedCommentsOf(node, returnedExpression, sourceCode);
+            const fixes = [];
+            if (strandedComments.length === 0) {
+                fixes.push(fixer.replaceText(node, needsParentheses ? `(${replacementText})` : replacementText));
+            }
+            else {
+                // Carrying must not change the non-comment token stream: whether the
+                // replacement is parenthesized is decided by the expression's context
+                // exactly as in the comment-free fix, never by the comments themselves.
+                // The call can start mid-line, so the indentation of the line it opens
+                // on is the only anchor the carried comments have.
+                const startLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
+                const indent = /^[\t ]*/.exec(startLine)?.[0] ?? '';
+                const text = sourceCode.getText();
+                const toSegment = (comment) => ({
+                    text: text.slice(comment.range[0], comment.range[1]),
+                    breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+                });
+                // A stranded comment lies wholly on one side of the expression, since
+                // a comment is a token and cannot straddle a node; keeping each on its
+                // own side preserves what it annotates.
+                const isBefore = (comment) => comment.range[0] < returnedExpression.range[0];
+                const leadingComments = strandedComments.filter(isBefore);
+                const trailingComments = strandedComments.filter((comment) => !isBefore(comment));
+                if (needsParentheses) {
+                    // Inside parentheses a newline can never trigger ASI, so every
+                    // comment — line comments and -next-line directives included — can
+                    // ride within the replacement on a line of its own.
+                    const segments = [
+                        ...leadingComments.map(toSegment),
+                        { text: replacementText, breakAfter: false },
+                        ...trailingComments.map(toSegment),
+                    ];
+                    fixes.push(fixer.replaceText(node, (0, replacementSegments_1.joinSegments)(segments, indent)));
+                }
+                else {
+                    // Without parentheses a line break between a restricted keyword
+                    // (`return`, `throw`, `yield`) and the expression would change the
+                    // program through ASI, so a leading comment that demands its own
+                    // line is hoisted onto a full line of its own ABOVE the line the
+                    // call starts on. That insertion can never split a token pair, and
+                    // it lands a `-next-line` directive exactly one line above the
+                    // statement that now hosts its subject. Everything else stays
+                    // inline: a block comment beside the expression, and a trailing
+                    // line-bound comment followed by a line break, which is safe after
+                    // the expression has begun.
+                    const hoistedComments = leadingComments.filter(replacementSegments_1.requiresLineBreakAfter);
+                    if (hoistedComments.length > 0) {
+                        const lineStartIndex = sourceCode.getIndexFromLoc({
+                            line: node.loc.start.line,
+                            column: 0,
+                        });
+                        const hoisted = hoistedComments
+                            .map((comment) => `${indent}${text.slice(comment.range[0], comment.range[1])}\n`)
+                            .join('');
+                        fixes.push(fixer.insertTextBeforeRange([lineStartIndex, lineStartIndex], hoisted));
+                    }
+                    const segments = [
+                        ...leadingComments
+                            .filter((comment) => !(0, replacementSegments_1.requiresLineBreakAfter)(comment))
+                            .map(toSegment),
+                        { text: replacementText, breakAfter: false },
+                        ...trailingComments.map(toSegment),
+                    ];
+                    const body = (0, replacementSegments_1.joinSegmentBody)(segments, indent);
+                    const trailing = segments[segments.length - 1].breakAfter
+                        ? `\n${indent}`
+                        : '';
+                    fixes.push(fixer.replaceText(node, `${body}${trailing}`));
+                }
+            }
             const specifier = getRemovableImportSpecifier(node, imports, sourceCode);
-            const fixes = [fixer.replaceText(node, replacement)];
             if (specifier) {
-                const removal = getImportRemovalFix(specifier, sourceCode, fixer);
-                if (removal) {
-                    fixes.push(removal);
-                }
+                fixes.push(...getImportRemovalFixes(specifier, sourceCode, fixer));
             }
             return fixes;
         }

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

@@ -4,6 +4,7 @@ exports.parallelizeAsyncOperations = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 // Anchored at the end of the path so multi-part suffixes such as
 // `EventRegistry.integration.test.ts` are recognized while production modules
 // that merely contain the word (`testHelpers.ts`, `latest.ts`, `contest/Thing.ts`)
@@ -91,7 +92,15 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             return {};
         }
         const sourceCode = context.sourceCode;
-        const sideEffectMatchers = (options?.sideEffectPatterns ?? []).map((pattern) => typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern);
+        // Compiling with a bare `new RegExp` throws while the rule is being built,
+        // which aborts the whole lint run — every file, every other rule — with a
+        // message naming neither this option nor the offending pattern. The schema
+        // admits any string, so `'**'` reaches here from a valid config.
+        const declaredPatterns = options?.sideEffectPatterns ?? [];
+        const sideEffectMatchers = [
+            ...(0, compilePatternOption_1.compilePatternOption)('parallelize-async-operations', 'sideEffectPatterns', declaredPatterns.filter((pattern) => typeof pattern === 'string'), 'i'),
+            ...declaredPatterns.filter((pattern) => typeof pattern !== 'string'),
+        ];
         const reportedRanges = new Set();
         /**
          * Checks if a node is an await expression

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

@@ -377,6 +377,26 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             return 'ok';
         }
         // ---- AST helpers --------------------------------------------------------
+        /**
+         * The expression an optional chain wraps: ESTree hangs a `ChainExpression`
+         * above the OUTERMOST link of `a?.b`, so a shape test written against
+         * `MemberExpression` sees a different node for a spelling that asks the same
+         * question here. `?.` changes nothing this rule decides on shape — the
+         * generated lookup copies the discriminant's source text verbatim
+         * (`RESULT_BY_KIND[a?.b]`), so the optional link survives the fix intact, and
+         * whether the chain can produce `undefined` is answered by the discriminant's
+         * TYPE (`hasNullish`), never by its shape. Reading the raw node instead made
+         * the narrowing carve-out unreachable and turned a `?.` on a discriminated
+         * union into a false positive whose remedy does not compile (#1867).
+         *
+         * Only one unwrap is needed: inner links of the same chain are plain
+         * `MemberExpression`s carrying `optional`, not nested `ChainExpression`s.
+         */
+        function unwrapChain(node) {
+            return node.type === utils_1.AST_NODE_TYPES.ChainExpression
+                ? node.expression
+                : node;
+        }
         /** Whether a discriminant expression is an identifier or a call-free,
          * non-optional member chain (safe to collapse repeated evaluations). */
         function isValidDiscriminant(node) {
@@ -576,14 +596,15 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 .toUpperCase();
         }
         function deriveLookupName(discriminant) {
+            const target = unwrapChain(discriminant);
             let key = null;
-            if (discriminant.type === utils_1.AST_NODE_TYPES.Identifier) {
-                key = discriminant.name;
+            if (target.type === utils_1.AST_NODE_TYPES.Identifier) {
+                key = target.name;
             }
-            else if (discriminant.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                !discriminant.computed &&
-                discriminant.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                key = discriminant.property.name;
+            else if (target.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !target.computed &&
+                target.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                key = target.property.name;
             }
             if (!key) {
                 return null;
@@ -894,12 +915,19 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
          * would lose (hoisting `this.obj.data` out of the switch drops the narrowing
          * and the emitted code no longer typechecks), so a `this`-rooted chain is
          * matched against `this` reads in the kept branches.
+         *
+         * `obj?.tag` narrows identically too — TypeScript discriminates a union
+         * through an optional chain — so the discriminant is unwrapped before its
+         * shape is read. A nullable discriminant is exactly where `?.` gets written,
+         * and reading the `ChainExpression` as "not a member access" skipped this
+         * carve-out entirely (#1867).
          */
         function isNarrowingExempt(discriminant, keptValues) {
-            if (discriminant.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+            const chain = unwrapChain(discriminant);
+            if (chain.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
                 return false;
             }
-            const root = chainRootName(discriminant);
+            const root = chainRootName(chain);
             if (!root) {
                 return false;
             }