@blumintinc/eslint-plugin-blumint 1.20.24 → 1.20.26

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -699,34 +699,20 @@ function getNextStart(body, index, parent, sourceCode) {
     const closingBraceOffset = parent.type === utils_1.AST_NODE_TYPES.BlockStatement ? 1 : 0;
     return parent.range[1] - closingBraceOffset;
 }
-function buildMoveFix(body, fromIndex, toIndex, parent, sourceCode, fixer) {
-    const text = sourceCode.getText();
-    if (toIndex < fromIndex) {
-        const segmentStart = getStartWithComments(body[toIndex], sourceCode);
-        const movingStart = getStartWithComments(body[fromIndex], sourceCode);
-        const segmentEnd = getNextStart(body, fromIndex, parent, sourceCode);
-        const before = text.slice(segmentStart, movingStart);
-        const moving = text.slice(movingStart, segmentEnd).replace(/[ \t]+$/u, '');
-        const newText = moving + before;
-        return fixer.replaceTextRange([segmentStart, segmentEnd], newText);
-    }
-    const segmentStart = getStartWithComments(body[fromIndex], sourceCode);
-    const movingEnd = getNextStart(body, fromIndex, parent, sourceCode);
-    const segmentEnd = getStartWithComments(body[toIndex], sourceCode);
-    const moving = text.slice(segmentStart, movingEnd).replace(/[ \t]+$/u, '');
-    const between = text.slice(movingEnd, segmentEnd);
-    const newText = between + moving;
-    return fixer.replaceTextRange([segmentStart, segmentEnd], newText);
-}
 function truncateWithEllipsis(text, max = 60) {
     return text.length <= max ? text : `${text.slice(0, max)}…`;
 }
-function reportOnce({ context, reportedStatements }, statement, messageId, data, fix) {
-    if (reportedStatements.has(statement)) {
+/**
+ * At most one violation per statement: a statement can qualify under several
+ * handlers with contradictory targets, so the first handler to claim it wins and
+ * the handler call order in `detectViolations` is the tie-break.
+ */
+function record(sink, statement, messageId, data, fromIndex, toIndex) {
+    if (sink.flagged.has(statement)) {
         return;
     }
-    reportedStatements.add(statement);
-    context.report({ node: statement, messageId, data, fix });
+    sink.flagged.add(statement);
+    sink.violations.push({ statement, messageId, data, fromIndex, toIndex });
 }
 function isGuardIfStatement(statement) {
     if (statement.type !== utils_1.AST_NODE_TYPES.IfStatement || statement.alternate) {
@@ -749,8 +735,8 @@ function isGuardIfStatement(statement) {
     }
     return false;
 }
-function handleGuardHoists(ruleContext, body, parent) {
-    const { sourceCode } = ruleContext;
+function handleGuardHoists(sink, body) {
+    const { sourceCode } = sink;
     body.forEach((statement, index) => {
         if (!isGuardIfStatement(statement)) {
             return;
@@ -770,10 +756,10 @@ function handleGuardHoists(ruleContext, body, parent) {
         if (targetIndex === index) {
             return;
         }
-        reportOnce(ruleContext, statement, 'moveGuardUp', { guard: truncateWithEllipsis(sourceCode.getText(statement.test)) }, (fixer) => buildMoveFix(body, index, targetIndex, parent, sourceCode, fixer));
+        record(sink, statement, 'moveGuardUp', { guard: truncateWithEllipsis(sourceCode.getText(statement.test)) }, index, targetIndex);
     });
 }
-function handleDerivedGrouping(ruleContext, body, parent) {
+function handleDerivedGrouping(sink, body) {
     const declaredIndices = new Map();
     /**
      * Each binding name → the declarator that introduced it. Sibling bindings of
@@ -782,10 +768,9 @@ function handleDerivedGrouping(ruleContext, body, parent) {
      * from `b` even though `a` separates `b` from its declaration.
      */
     const sourceDeclarators = new Map();
-    const { sourceCode } = ruleContext;
     body.forEach((statement, index) => {
         if (isVariableDeclaration(statement)) {
-            processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, sourceDeclarators, parent, sourceCode);
+            processVariableDeclaration(sink, statement, index, body, declaredIndices, sourceDeclarators);
         }
         trackDeclaredNames(statement, index, declaredIndices);
         trackSourceDeclarators(statement, sourceDeclarators);
@@ -794,11 +779,10 @@ function handleDerivedGrouping(ruleContext, body, parent) {
 function isVariableDeclaration(statement) {
     return statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration;
 }
-function processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, sourceDeclarators, parent, sourceCode) {
+function processVariableDeclaration(sink, statement, index, body, declaredIndices, sourceDeclarators) {
     const dependencies = collectDependencies(statement);
     const priorDependencies = findPriorDependencies(dependencies, declaredIndices);
-    if (priorDependencies.length === 0 ||
-        ruleContext.reportedStatements.has(statement)) {
+    if (priorDependencies.length === 0 || sink.flagged.has(statement)) {
         return;
     }
     const lastDependencyIndex = findLastDependencyIndex(priorDependencies, declaredIndices);
@@ -813,7 +797,7 @@ function processVariableDeclaration(ruleContext, statement, index, body, declare
     if (hasBlockers(body, lastDependencyIndex, index, priorDependencySet, declaredNames)) {
         return;
     }
-    reportDerivedGroupingViolation(ruleContext, statement, priorDependencies, declaredNames, body, index, lastDependencyIndex, parent, sourceCode);
+    reportDerivedGroupingViolation(sink, statement, priorDependencies, declaredNames, index, lastDependencyIndex);
 }
 function collectDependencies(statement) {
     const dependencies = new Set();
@@ -843,13 +827,13 @@ function hasBlockers(body, lastDependencyIndex, currentIndex, priorDependencySet
         statementDeclaresAny(between, declaredNames) ||
         statementReferencesAny(between, declaredNames));
 }
-function reportDerivedGroupingViolation(ruleContext, statement, priorDependencies, declaredNames, body, currentIndex, lastDependencyIndex, parent, sourceCode) {
+function reportDerivedGroupingViolation(sink, statement, priorDependencies, declaredNames, currentIndex, lastDependencyIndex) {
     const dependency = priorDependencies[0];
     const name = declaredNames.values().next().value ?? 'value';
-    reportOnce(ruleContext, statement, 'groupDerived', {
+    record(sink, statement, 'groupDerived', {
         dependency,
         name,
-    }, (fixer) => buildMoveFix(body, currentIndex, lastDependencyIndex + 1, parent, sourceCode, fixer));
+    }, currentIndex, lastDependencyIndex + 1);
 }
 function trackDeclaredNames(statement, index, declaredIndices) {
     const declared = getDeclaredNames(statement);
@@ -971,8 +955,7 @@ function isMutatedInLoop(body, usageIndex, nameSet) {
     }
     return statementMutatesAny(firstUsage, nameSet);
 }
-function handleLateDeclarations(ruleContext, body, parent) {
-    const { sourceCode } = ruleContext;
+function handleLateDeclarations(sink, body) {
     body.forEach((statement, index) => {
         if (!isLateDeclarationCandidate(statement)) {
             return;
@@ -1026,7 +1009,7 @@ function handleLateDeclarations(ruleContext, body, parent) {
         if (crossesImpureOrTracked) {
             return;
         }
-        reportOnce(ruleContext, statement, 'moveDeclarationCloser', { name }, (fixer) => buildMoveFix(body, index, usageIndex, parent, sourceCode, fixer));
+        record(sink, statement, 'moveDeclarationCloser', { name }, index, usageIndex);
     });
 }
 function extractCallExpression(expression) {
@@ -1327,8 +1310,8 @@ function isSideEffectExpression(statement) {
     }
     return Boolean(extractCallExpression(statement.expression));
 }
-function handleSideEffects(ruleContext, body, parent) {
-    const { sourceCode } = ruleContext;
+function handleSideEffects(sink, body) {
+    const { sourceCode } = sink;
     body.forEach((statement, index) => {
         if (!isSideEffectExpression(statement)) {
             return;
@@ -1357,15 +1340,211 @@ function handleSideEffects(ruleContext, body, parent) {
             return;
         }
         const effectText = truncateWithEllipsis(sourceCode.getText(statement).trim());
-        reportOnce(ruleContext, statement, 'moveSideEffect', { effect: effectText }, (fixer) => buildMoveFix(body, index, targetIndex, parent, sourceCode, fixer));
+        record(sink, statement, 'moveSideEffect', { effect: effectText }, index, targetIndex);
     });
 }
+/**
+ * Detection is pure over the statement order, so it scores a hypothetical
+ * reordering exactly as it scores the real one. Handler order is the tie-break for
+ * a statement several handlers claim — do not reorder these calls.
+ */
+function detectViolations(sourceCode, body) {
+    const sink = {
+        sourceCode,
+        flagged: new Set(),
+        violations: [],
+    };
+    handleGuardHoists(sink, body);
+    handleDerivedGrouping(sink, body);
+    handleLateDeclarations(sink, body);
+    handleSideEffects(sink, body);
+    return sink.violations;
+}
+/**
+ * Mirrors the rotation `moveSegment` performs on text, at statement granularity, so a
+ * candidate ordering can be scored without rewriting and reparsing the source. The
+ * two must stay in step: the search verifies the order that the fix emits.
+ */
+function applyMove(body, fromIndex, toIndex) {
+    const next = [...body];
+    const [moved] = next.splice(fromIndex, 1);
+    next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved);
+    return next;
+}
+/**
+ * Upper bound on candidate moves expanded per search node. Each candidate costs one
+ * full detection pass, so a node offering more violations than this has its tail
+ * ignored: the frontier stays bounded and the budget buys depth rather than width.
+ */
+const MAX_FIX_CANDIDATES = 12;
+/**
+ * Real code routinely needs a run of moves before every constraint holds: hoisting
+ * one `jest.mock` exposes the next, and interleaved `before`/`after` fixtures pass
+ * through orders with *more* violations than they started with before settling at
+ * zero. Satisfying every adjacency constraint at once therefore requires looking well
+ * past the first move.
+ *
+ * The block's violation count is the search's initial branching factor, so a lone
+ * violation starts a near-chain that can be followed far while a wide block cannot.
+ * Bodies too large for repeated detection are skipped outright, and `SEARCH_BUDGET`
+ * caps total detections whatever the shape — a block whose ordering cannot be settled
+ * inside the budget is reported without a fix.
+ */
+const SEARCH_DEPTH_CHAIN = 16;
+const SEARCH_DEPTH_BRANCHING = 6;
+const SEARCH_MAX_VIOLATIONS = 12;
+const SEARCH_MAX_STATEMENTS = 120;
+const SEARCH_BUDGET = 400;
+function searchDepthFor(violationCount, statementCount) {
+    if (statementCount > SEARCH_MAX_STATEMENTS) {
+        return 0;
+    }
+    if (violationCount === 1) {
+        return SEARCH_DEPTH_CHAIN;
+    }
+    if (violationCount <= SEARCH_MAX_VIOLATIONS) {
+        return SEARCH_DEPTH_BRANCHING;
+    }
+    return 0;
+}
+/**
+ * Statement identity is stable across reorderings, so the original indices of an
+ * order identify it uniquely and cheaply — which is what lets the search skip orders
+ * reachable by more than one sequence of moves.
+ */
+function orderKey(order, indices) {
+    return order.map((statement) => indices.get(statement)).join(',');
+}
+/**
+ * Shortest sequence of moves reaching an order with **zero** violations, or null when
+ * the search bounds contain no such order.
+ *
+ * Breadth-first for two reasons: the emitted fix is then the smallest reordering that
+ * satisfies every constraint, and a block whose single named move already suffices
+ * yields exactly that move.
+ *
+ * Violation count is not used to prune: an order that trades one violation for two
+ * can still be the only route to a clean order, so the frontier is bounded by move
+ * count and detection budget rather than by any notion of progress. Only the
+ * zero-violation goal test decides whether a fix is emitted at all.
+ */
+function findResolvingMoves(sourceCode, body, violations, maxMoves) {
+    if (maxMoves === 0) {
+        return null;
+    }
+    const indices = new Map(body.map((statement, index) => [statement, index]));
+    const seen = new Set([orderKey(body, indices)]);
+    const queue = [{ order: body, violations, moves: [] }];
+    let budget = SEARCH_BUDGET;
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (node.moves.length >= maxMoves) {
+            continue;
+        }
+        const candidates = Math.min(node.violations.length, MAX_FIX_CANDIDATES);
+        for (let candidate = 0; candidate < candidates; candidate += 1) {
+            if (budget <= 0) {
+                return null;
+            }
+            const { fromIndex, toIndex } = node.violations[candidate];
+            const order = applyMove(node.order, fromIndex, toIndex);
+            const key = orderKey(order, indices);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            budget -= 1;
+            const next = detectViolations(sourceCode, order);
+            const moves = [...node.moves, { fromIndex, toIndex }];
+            if (next.length === 0) {
+                return moves;
+            }
+            queue.push({ order, violations: next, moves });
+        }
+    }
+    return null;
+}
+/**
+ * Statement `i` owns the text from its own leading comments and indentation up to
+ * where statement `i + 1`'s begins, so the segments tile the block's statement region
+ * exactly and any reordering is a permutation of them.
+ */
+function collectSegments(body, parent, sourceCode) {
+    const text = sourceCode.getText();
+    const bounds = body.map((statement) => getStartWithComments(statement, sourceCode));
+    bounds.push(getNextStart(body, body.length - 1, parent, sourceCode));
+    return {
+        bounds,
+        segments: body.map((_, index) => text.slice(bounds[index], bounds[index + 1])),
+    };
+}
+/**
+ * Trailing spaces and tabs are dropped as a segment moves: that whitespace is the
+ * indentation of whatever used to follow the segment, not part of the segment itself.
+ * Keeping it would double the indentation at the segment's destination.
+ */
+function moveSegment(segments, fromIndex, toIndex) {
+    const next = [...segments];
+    const [moved] = next.splice(fromIndex, 1);
+    next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved.replace(/[ \t]+$/u, ''));
+    return next;
+}
+/**
+ * Emits an entire reordering as one fix by permuting the block's text segments.
+ *
+ * Only the span that actually changes is replaced. That keeps the fix disjoint from
+ * fixes in nested and sibling blocks — ESLint discards overlapping fixes — and makes
+ * a one-move reordering byte-identical to relocating that one statement.
+ */
+function buildReorderFix(body, moves, parent, sourceCode, fixer) {
+    const { bounds, segments } = collectSegments(body, parent, sourceCode);
+    const reordered = moves.reduce((current, move) => moveSegment(current, move.fromIndex, move.toIndex), segments);
+    let first = 0;
+    while (first < segments.length && reordered[first] === segments[first]) {
+        first += 1;
+    }
+    let last = segments.length - 1;
+    while (last > first && reordered[last] === segments[last]) {
+        last -= 1;
+    }
+    if (first > last) {
+        return null;
+    }
+    return fixer.replaceTextRange([bounds[first], bounds[last + 1]], reordered.slice(first, last + 1).join(''));
+}
+/**
+ * A fix is emitted only for a reordering the detector scores at zero violations, and
+ * the whole reordering ships as a single fix. Relocating one statement per report
+ * satisfies its own adjacency constraint while breaking another's, which under
+ * `--fix` oscillates or exhausts the pass budget (#1405).
+ *
+ * Convergence is structural rather than argued: the emitted order is verified clean
+ * by the same detector that produced the reports, and detection depends only on
+ * statement order, so a single pass settles the block. Blocks with no clean order in
+ * range are reported without a fix — a report the developer resolves beats a fix that
+ * leaves a different violation behind.
+ *
+ * The fix rides on the first report because the reordering resolves every violation
+ * in the block at once; a second fix would be redundant and would overlap this one.
+ */
 function handleBlock(ruleContext, node) {
-    const statements = node.body;
-    handleGuardHoists(ruleContext, statements, node);
-    handleDerivedGrouping(ruleContext, statements, node);
-    handleLateDeclarations(ruleContext, statements, node);
-    handleSideEffects(ruleContext, statements, node);
+    const { context, sourceCode } = ruleContext;
+    const body = node.body;
+    const violations = detectViolations(sourceCode, body);
+    if (violations.length === 0) {
+        return;
+    }
+    const moves = findResolvingMoves(sourceCode, body, violations, searchDepthFor(violations.length, body.length));
+    violations.forEach((violation, index) => {
+        context.report({
+            node: violation.statement,
+            messageId: violation.messageId,
+            data: violation.data,
+            fix: moves && index === 0
+                ? (fixer) => buildReorderFix(body, moves, node, sourceCode, fixer)
+                : null,
+        });
+    });
 }
 exports.logicalTopToBottomGrouping = (0, createRule_1.createRule)({
     name: 'logical-top-to-bottom-grouping',
@@ -1392,7 +1571,6 @@ exports.logicalTopToBottomGrouping = (0, createRule_1.createRule)({
         const ruleContext = {
             context,
             sourceCode,
-            reportedStatements: new WeakSet(),
         };
         const visitBlock = (node) => handleBlock(ruleContext, node);
         return {

package/lib/rules/no-array-length-in-deps.js

@@ -4,6 +4,7 @@ exports.noArrayLengthInDeps = 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");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 const DEFAULT_HASH_IMPORT = {
@@ -370,6 +371,15 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
         let importsPlanned = false;
         const perBlockDeclaredBases = new WeakMap();
         const perBlockBaseToVar = new WeakMap();
+        /**
+         * `useMemo` and the hash helper are imported by a single violation's fix,
+         * making that violation the file's import carrier. ESLint builds fixes
+         * before it applies inline disable directives, so a suppressed carrier
+         * takes both imports down with it while the surviving violations still
+         * emit `useMemo(() => stableHash(...))` — two unbound identifiers that no
+         * number of `--fix` passes can repair.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         return {
             CallExpression(node) {
                 if (!isHookCall(node))
@@ -404,7 +414,10 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                 const dependencies = lengthDeps
                     .map(({ element }) => sourceCode.getText(element))
                     .join(', ');
-                // Report once on the dependency array
+                // Report once on the dependency array. The report is emitted even when
+                // suppressed: ESLint discards it, and reporting keeps the user's
+                // disable directive "used" so `--report-unused-disable-directives`
+                // does not flag it.
                 context.report({
                     node: depsArg,
                     messageId: 'noArrayLengthInDeps',
@@ -412,6 +425,15 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         dependencies,
                     },
                     fix(fixer) {
+                        // A suppressed report is dropped together with its fix. Declining
+                        // to fix — and leaving the imports and the per-block declarations
+                        // unclaimed — passes the carrier slot to the first violation that
+                        // actually survives. Checked against the reported node so the
+                        // resolution matches ESLint's own, and before every other bail so
+                        // no shared state is touched.
+                        if (isReportSuppressed(depsArg)) {
+                            return null;
+                        }
                         // All bail checks precede any shared-state mutation so a skipped
                         // fix cannot make a later fix believe imports or declarations are
                         // already handled.