@blumintinc/eslint-plugin-blumint 1.20.135 → 1.20.137

package/lib/index.js

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

package/lib/rules/consistent-callback-naming.js

@@ -607,11 +607,27 @@ module.exports = (0, createRule_1.createRule)({
                             globalVar.references.forEach((ref) => references.add(ref));
                         }
                     }
+                    // A binding that leaves the module is one end of a cross-file
+                    // contract. Renaming `export const handleClick` to `click` strands
+                    // every `import { handleClick }` with TS2724, and a single-file fixer
+                    // cannot reach those importers — the same reasoning that already
+                    // withholds the JSX prop rename and the destructured one, which is
+                    // where `isExportedBinding` was first needed. The violation still
+                    // reports; only the rename is withheld.
+                    const declaredVariable = context
+                        .getDeclaredVariables(node)
+                        .find((v) => v.identifiers.includes(node.id));
+                    const leavesModule = declaredVariable
+                        ? isExportedBinding(declaredVariable)
+                        : isExportedDeclaration(node);
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',
                         data: { functionName },
                         fix(fixer) {
+                            if (leavesModule) {
+                                return null;
+                            }
                             // Remove 'handle' prefix and convert first character to lowercase
                             const newName = stripHandlePrefix(functionName);
                             // `const handleDelete = fn` would become `const delete = fn`,

package/lib/rules/enforce-assert-safe-object-key.js

@@ -256,6 +256,54 @@ function isNumericCall(node) {
         callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
         callee.object.name === 'Math');
 }
+/**
+ * The property names `assertSafe` exists to reject. A key that provably cannot
+ * spell one of these cannot reach the prototype surface, which is the entire
+ * hazard — so proving it is what earns an exemption, the same standard the
+ * numeric analysis already meets.
+ */
+const PROTOTYPE_REACHING_KEYS = ['__proto__', 'constructor', 'prototype'];
+/**
+ * Whether a template's FIXED text still leaves room to spell `target`.
+ *
+ * The producible set is `q0 + * + q1 + * + … + * + qN`, each `*` an arbitrary
+ * substitution. `target` is producible iff it starts with `q0`, ends with `qN`,
+ * and the interior quasis occur in order in between without overlapping. So
+ * `` `user-${id}` `` can never be `__proto__` (no such prefix) while
+ * `` `__pro${x}` `` can — with `x` = `'to__'`, which resolves to
+ * `Object.prototype` at runtime.
+ *
+ * Interior quasis are matched greedily from the left. That is sufficient
+ * because they are fixed strings: taking the earliest occurrence never consumes
+ * a character a later quasi needed, so no backtracking can succeed where the
+ * greedy pass fails.
+ *
+ * A template with no substitutions produces exactly one string and is a static
+ * key like any other string literal, so it is never treated as reaching.
+ */
+function templateCanSpell(quasis, target) {
+    if (quasis.length < 2) {
+        return false;
+    }
+    const first = quasis[0];
+    const last = quasis[quasis.length - 1];
+    if (!target.startsWith(first) || !target.endsWith(last)) {
+        return false;
+    }
+    const limit = target.length - last.length;
+    let cursor = first.length;
+    if (cursor > limit) {
+        return false;
+    }
+    for (const middle of quasis.slice(1, -1)) {
+        const at = target.indexOf(middle, cursor);
+        if (at < 0 || at + middle.length > limit) {
+            return false;
+        }
+        cursor = at + middle.length;
+    }
+    return true;
+}
 /**
  * A `: number` annotation on a binding name. Parameters and variable
  * declarators are the bindings that carry one, and TypeScript checks every
@@ -1133,19 +1181,34 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        // Only flag simple template literals that are just `${id}`
-                        // Complex templates with additional text like `prefix_${id}_suffix` are allowed
+                        // A template whose every substitution is provably numeric can only
+                        // widen into digits, and no dangerous property name is the string
+                        // form of a number — the same proof the identifier path accepts.
+                        const canWidenToText = property.expressions.some((expr) => !isStaticallyNumeric(expr));
+                        const quasis = property.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw);
+                        const reachesPrototype = canWidenToText &&
+                            PROTOTYPE_REACHING_KEYS.some((key) => templateCanSpell(quasis, key));
+                        // Fixed text on either side of the substitution can rule a property
+                        // name out — `user-${id}` is never `__proto__` — and the rule skips
+                        // a key it can prove harmless. What it must NOT do is assume that:
+                        // `__pro${x}` carries fixed text too and still reaches the
+                        // prototype (#1880).
+                        if (!reachesPrototype) {
+                            return;
+                        }
+                        // `${id}` alone is the whole key, so the remedy names the inner
+                        // expression and the fix wraps it directly. A template carrying
+                        // fixed text has no such inner key — the string it builds is the
+                        // key — so that whole template is what gets wrapped, which is the
+                        // shape the docs show for `assertSafe(`${id}_suffix`)`.
                         const isSimpleVarInterpolation = property.expressions.length === 1 &&
                             property.quasis.length === 2 &&
                             property.quasis[0].value.raw === '' &&
                             property.quasis[1].value.raw === '';
-                        if (!isSimpleVarInterpolation) {
-                            // Complex template literals with additional text are fine
-                            return;
-                        }
-                        const expr = property.expressions[0];
-                        const exprText = context.sourceCode.getText(expr);
-                        reportWrittenKey(written, property, exprText);
+                        const unwrapped = isSimpleVarInterpolation
+                            ? property.expressions[0]
+                            : property;
+                        reportWrittenKey(written, property, context.sourceCode.getText(unwrapped));
                         return;
                     }
                     // Check for direct variable usage (identifiers)

package/lib/rules/enforce-props-argument-name.js

@@ -340,6 +340,33 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
             });
         }
+        /**
+         * The member name a `this.<x>` access reads, whatever its spelling.
+         *
+         * Keying the check on the dot spelling alone left `this['settings']`
+         * invisible, so the rename shipped and stranded it — the class no longer had
+         * the member the getter reads (#1881). A computed access with a static
+         * string is the SAME member as the dot form, and the fixer cannot rewrite it
+         * either, so it has to count. `null` marks a genuinely dynamic key, which
+         * names no member statically.
+         */
+        function staticMemberName(node) {
+            if (!node.computed) {
+                return node.property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? node.property.name
+                    : null;
+            }
+            if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.property.value === 'string') {
+                return node.property.value;
+            }
+            if (node.property.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                node.property.expressions.length === 0 &&
+                node.property.quasis.length === 1) {
+                return node.property.quasis[0].value.cooked;
+            }
+            return null;
+        }
         // Determine whether renaming a constructor parameter property is unsafe to
         // autofix. A parameter property (`private readonly foo: T`) creates BOTH a
         // constructor-local binding and a `this.foo` class field, so a
@@ -355,8 +382,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
                 if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
-                    node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.property.name === name) {
+                    staticMemberName(node) === name) {
                     unsafe = true;
                     return;
                 }

package/lib/rules/enforce-props-naming-consistency.js

@@ -42,6 +42,33 @@ const getEnclosingClass = (node) => {
  * cannot be resolved through scope analysis, the fix is withheld whenever the
  * name occurs anywhere in the class other than at its declaration.
  */
+/**
+ * The member name a `this.<x>` access reads, whatever its spelling.
+ *
+ * Keying the check on the dot spelling alone left `this['settings']` invisible,
+ * so the rename shipped and stranded it — the class no longer had the member the
+ * getter reads (#1882, the sibling of #1881). A computed access with a static
+ * string is the SAME member as the dot form, and the fixer cannot rewrite it
+ * either, so it has to count. `null` marks a genuinely dynamic key, which names
+ * no member statically and therefore strands nothing.
+ */
+const staticMemberName = (node) => {
+    if (!node.computed) {
+        return node.property.type === utils_1.AST_NODE_TYPES.Identifier
+            ? node.property.name
+            : null;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.property.value === 'string') {
+        return node.property.value;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.property.expressions.length === 0 &&
+        node.property.quasis.length === 1) {
+        return node.property.quasis[0].value.cooked;
+    }
+    return null;
+};
 const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
     let unsafe = false;
     const visit = (node) => {
@@ -50,8 +77,7 @@ const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
         }
         if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
-            node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-            node.property.name === name) {
+            staticMemberName(node) === name) {
             unsafe = true;
             return;
         }

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

@@ -828,12 +828,31 @@ function truncateWithEllipsis(text, max = 60) {
  * 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) {
+function record(sink, statement, messageId, data, fromIndex, toIndex, relocatable = true) {
     if (sink.flagged.has(statement)) {
         return;
     }
     sink.flagged.add(statement);
-    sink.violations.push({ statement, messageId, data, fromIndex, toIndex });
+    sink.violations.push({
+        statement,
+        messageId,
+        data,
+        fromIndex,
+        toIndex,
+        relocatable,
+    });
+}
+/**
+ * The violations the reordering search is allowed to expand into moves, and the
+ * only ones its zero-violation goal test answers about.
+ *
+ * Screening here rather than at detection is what keeps the fix path identical to
+ * one that never saw an unrelocatable violation: the search's candidate moves, its
+ * budget and the order it certifies clean are all computed as if the report were
+ * absent, so adding a report can never redirect, weaken or block a fix.
+ */
+function relocatableViolations(violations) {
+    return violations.filter((violation) => violation.relocatable);
 }
 function isGuardIfStatement(statement) {
     if (statement.type !== utils_1.AST_NODE_TYPES.IfStatement || statement.alternate) {
@@ -1058,23 +1077,58 @@ function unwrappedInitOf(declarator) {
  *
  * The classification runs on the unwrapped initializer: an assertion is erased
  * before the code runs, so `1 as const` is exactly the movable literal `1` is.
+ *
+ * Every declarator must qualify, because the statement is diagnosed — and moved —
+ * as a whole. A sibling binding does not disqualify the statement: how many
+ * bindings a declaration introduces decides whether the fix may relocate it, not
+ * whether the declaration is far from the first use of what it declares (#1889).
  */
-function lateDeclarationCandidateOf(statement) {
+function lateDeclarationDeclaratorsOf(statement) {
     const declaration = variableDeclarationOf(statement);
-    if (!declaration || declaration.declarations.length !== 1) {
+    if (!declaration || declaration.declarations.length === 0) {
         return null;
     }
-    const [declarator] = declaration.declarations;
-    if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
-        return null;
+    const declarators = [];
+    for (const declarator of declaration.declarations) {
+        if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return null;
+        }
+        const init = unwrappedInitOf(declarator);
+        if (init &&
+            init.type !== utils_1.AST_NODE_TYPES.Identifier &&
+            init.type !== utils_1.AST_NODE_TYPES.Literal) {
+            return null;
+        }
+        declarators.push(declarator);
     }
-    const init = unwrappedInitOf(declarator);
-    if (init &&
-        init.type !== utils_1.AST_NODE_TYPES.Identifier &&
-        init.type !== utils_1.AST_NODE_TYPES.Literal) {
-        return null;
+    return declarators;
+}
+/**
+ * Whether the reordering fix may relocate this statement to satisfy a
+ * late-declaration report.
+ *
+ * The fix moves whole statements, so relocating `const x = 1, y = 2;` carries `y`
+ * along — past its own first use in the general case, and always further than the
+ * report asked for. Splitting the declaration is the developer's call, so a
+ * declaration with sibling bindings is reported and left where it stands.
+ */
+function isRelocatableLateDeclaration(statement) {
+    return lateDeclarationDeclaratorsOf(statement)?.length === 1;
+}
+/**
+ * The binding the report names: the one whose own first use is the group's.
+ *
+ * A statement's bindings share its position, so the declaration is late relative to
+ * whichever of them is read first; naming a sibling read later would point the
+ * reader at the wrong line.
+ */
+function earliestUsedDeclarator(declarators, body, afterIndex, usageIndex) {
+    if (declarators.length === 1) {
+        return declarators[0];
     }
-    return declarator;
+    const earliest = declarators.find((declarator) => findFirstUsageIndex(body, new Set([declarator.id.name]), afterIndex) ===
+        usageIndex);
+    return earliest ?? declarators[0];
 }
 const LOOP_TYPES = new Set([
     utils_1.AST_NODE_TYPES.ForStatement,
@@ -1110,17 +1164,18 @@ function isMutatedInLoop(body, usageIndex, nameSet) {
 }
 function handleLateDeclarations(sink, body) {
     body.forEach((statement, index) => {
-        const declarator = lateDeclarationCandidateOf(statement);
-        if (!declarator) {
+        const declarators = lateDeclarationDeclaratorsOf(statement);
+        if (!declarators) {
             return;
         }
-        const name = declarator.id.name;
         const dependencies = new Set();
-        const init = unwrappedInitOf(declarator);
-        if (init && init.type === utils_1.AST_NODE_TYPES.Identifier) {
-            dependencies.add(init.name);
-        }
-        const nameSet = new Set([name]);
+        declarators.forEach((declarator) => {
+            const init = unwrappedInitOf(declarator);
+            if (init && init.type === utils_1.AST_NODE_TYPES.Identifier) {
+                dependencies.add(init.name);
+            }
+        });
+        const nameSet = new Set(declarators.map((declarator) => declarator.id.name));
         const usageIndex = findFirstUsageIndex(body, nameSet, index + 1);
         if (usageIndex === -1 || usageIndex <= index + 1) {
             return;
@@ -1140,7 +1195,9 @@ function handleLateDeclarations(sink, body) {
             // Do not hop over another declaration that is used at the same index or earlier
             // if it is also a candidate for being moved.
             // This prevents circular swapping of related declarations (like resolve/reject pairs).
-            if (lateDeclarationCandidateOf(stmt)) {
+            // The test asks about *relocation*, so a declaration the fix will never move
+            // is not one of the two ends of such a swap and does not block the hop.
+            if (isRelocatableLateDeclaration(stmt)) {
                 const declaredNames = getDeclaredNames(stmt);
                 const firstUsageOfIntervening = findFirstUsageIndex(body, declaredNames, index + 1 + i + 1);
                 if (firstUsageOfIntervening !== -1 &&
@@ -1163,7 +1220,11 @@ function handleLateDeclarations(sink, body) {
         if (crossesImpureOrTracked) {
             return;
         }
-        record(sink, statement, 'moveDeclarationCloser', { name }, index, usageIndex);
+        const subject = earliestUsedDeclarator(declarators, body, index + 1, usageIndex);
+        // The same test `isRelocatableLateDeclaration` applies to an intervening
+        // statement, read off the declarators already in hand.
+        const relocatable = declarators.length === 1;
+        record(sink, statement, 'moveDeclarationCloser', { name: subject.id.name }, index, usageIndex, relocatable);
     });
 }
 /**
@@ -1655,8 +1716,12 @@ 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.
+ * Shortest sequence of moves reaching an order with **zero** relocatable violations,
+ * or null when the search bounds contain no such order.
+ *
+ * `violations` is pre-screened by `relocatableViolations`, and so is every detection
+ * the search performs: a violation whose statement the fix may not move is neither a
+ * candidate move nor a reason to reject an order, since no reordering can answer it.
  *
  * 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
@@ -1706,7 +1771,7 @@ function findResolvingMoves(sourceCode, body, violations, maxMoves) {
             }
             seen.add(key);
             budget -= 1;
-            const next = detectViolations(sourceCode, order);
+            const next = relocatableViolations(detectViolations(sourceCode, order));
             const moves = [...node.moves, { fromIndex, toIndex }];
             if (next.length === 0) {
                 return moves;
@@ -1765,10 +1830,15 @@ function buildReorderFix(body, moves, parent, sourceCode, fixer) {
     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).
+ * A fix is emitted only for a reordering the detector scores at zero relocatable
+ * 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).
+ *
+ * A violation no reordering may answer — a declaration whose sibling bindings the
+ * fix would drag along — is reported and otherwise invisible here: it does not
+ * carry the fix, does not veto one, and cannot keep the block from settling, since
+ * the fixed text scores it exactly as the input did.
  *
  * 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
@@ -1786,13 +1856,14 @@ function handleBlock(ruleContext, node) {
     if (violations.length === 0) {
         return;
     }
-    const moves = findResolvingMoves(sourceCode, body, violations, searchDepthFor(violations.length, body.length));
-    violations.forEach((violation, index) => {
+    const relocatable = relocatableViolations(violations);
+    const moves = findResolvingMoves(sourceCode, body, relocatable, searchDepthFor(relocatable.length, body.length));
+    violations.forEach((violation) => {
         context.report({
             node: violation.statement,
             messageId: violation.messageId,
             data: violation.data,
-            fix: moves && index === 0
+            fix: moves && violation === relocatable[0]
                 ? (fixer) => buildReorderFix(body, moves, node, sourceCode, fixer)
                 : null,
         });