@blumintinc/eslint-plugin-blumint 1.21.4 → 1.21.6

package/lib/index.js

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

package/lib/rules/enforce-microdiff.d.ts

@@ -1,4 +1,4 @@
 import { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'enforceMicrodiff' | 'enforceMicrodiffImport';
+type MessageIds = 'enforceMicrodiff' | 'enforceMicrodiffManual' | 'enforceMicrodiffImport';
 export declare const enforceMicrodiff: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

package/lib/rules/enforce-microdiff.js

@@ -112,6 +112,30 @@ const COMPETING_DIFF_MODULES = new Set([
     // 'fast-deep-equal' and 'fast-deep-equal/es6' stay out of this set: they are
     // allowed alternatives to microdiff, so their imports survive the fix.
 ]);
+/**
+ * The competing libraries whose calls are reported but never rewritten, because
+ * microdiff answers a different question than either of them does.
+ *
+ * jsdiff (`diff`) is a Myers sequence diff. `diffArrays(a, b)` returns runs of
+ * `{value, added, removed, count}`, so equal inputs yield one *kept* run where
+ * microdiff returns the empty list — `changes.length === 0` flips meaning under
+ * the rename — and a consumer reading `.added`, `.removed`, `.value` or
+ * `.count` gets `.type`, `.path` and `.oldValue` instead. Neither loss is a
+ * compile error, so nothing downstream flags it. Its optional third argument is
+ * a comparator bag with no counterpart in `Partial<MicrodiffOptions>`, which is
+ * a compile error (TS2345).
+ *
+ * `fast-diff` diffs STRINGS. Its operands satisfy neither half of microdiff's
+ * `TData extends Record<string, unknown> | unknown[]` bound, so that arm cannot
+ * emit a rewrite that compiles at all (TS2345).
+ *
+ * Detection is unchanged — both keep their entries in `DIFF_FUNCTION_NAMES` and
+ * `COMPETING_DIFF_MODULES` — because reaching for either where a structural
+ * per-path diff is wanted is still the finding. Only the rewrite is withheld,
+ * and the import retirement with it: dropping the declaration while the calls
+ * it binds stay behind is what would leave the file with an unbound name.
+ */
+const UNCONVERTIBLE_DIFF_MODULES = new Set(['diff', 'fast-diff']);
 /**
  * A specifier that makes a bare `diff` resolve to microdiff's diff function:
  * its default export, or its named `diff` export, bound under the name the fix
@@ -162,7 +186,12 @@ function collectClaimableSpecifiers(program) {
                 .forEach((specifier) => claimable.add(specifier));
             return;
         }
-        if (COMPETING_DIFF_MODULES.has(source)) {
+        // A declaration no fix retires keeps every name it binds, so a `diff` it
+        // declares is not the fix's to write over: microdiff's import emitted
+        // beside a surviving `import { diff } from 'diff'` duplicates the binding
+        // (TS2300).
+        if (COMPETING_DIFF_MODULES.has(source) &&
+            !UNCONVERTIBLE_DIFF_MODULES.has(source)) {
             statement.specifiers.forEach((specifier) => claimable.add(specifier));
         }
     });
@@ -480,6 +509,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
         schema: [],
         messages: {
             enforceMicrodiff: 'Use the microdiff library for object and array comparison operations',
+            enforceMicrodiffManual: 'Use the microdiff library for object and array comparison operations. Convert this {{importSource}} call by hand: it returns a different result shape than the structural change list microdiff produces.',
             enforceMicrodiffImport: 'Import diff from microdiff instead of {{importSource}}',
         },
     },
@@ -777,6 +807,12 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             importSource,
                         },
                         fix(fixer) {
+                            // Every call this declaration serves is left for manual
+                            // conversion, so retiring it would strand each of them on a name
+                            // nothing binds.
+                            if (UNCONVERTIBLE_DIFF_MODULES.has(importSource)) {
+                                return null;
+                            }
                             // Decline rather than duplicate or shadow a `diff` this file
                             // already binds to something else, and rather than retire an
                             // import whose references no call fix rewrites. The report stands
@@ -853,6 +889,19 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             if (ALLOWED_DIFF_MODULES.has(importSource)) {
                                 return;
                             }
+                            // A library microdiff does not stand in for is reported without
+                            // the rename. The substitution would compile at some of these
+                            // call sites and answer a different question there, which is a
+                            // loss nothing downstream can flag.
+                            if (UNCONVERTIBLE_DIFF_MODULES.has(importSource)) {
+                                reportedNodes.add(node);
+                                context.report({
+                                    node,
+                                    messageId: 'enforceMicrodiffManual',
+                                    data: { importSource },
+                                });
+                                return;
+                            }
                             // Report it if it's from any other tracked library
                             reportedNodes.add(node);
                             context.report({
@@ -874,6 +923,21 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             if (!competingImport) {
                                 return;
                             }
+                            // The same withholding as above, reached by the other resolution
+                            // path: a default import and an unrecognised export name are both
+                            // bound here rather than tracked as specifiers, so gating only the
+                            // tracked branch would leave `import fastDiff from 'fast-diff'`
+                            // rewritten.
+                            const competingSource = String(competingImport.source.value);
+                            if (UNCONVERTIBLE_DIFF_MODULES.has(competingSource)) {
+                                reportedNodes.add(node);
+                                context.report({
+                                    node,
+                                    messageId: 'enforceMicrodiffManual',
+                                    data: { importSource: competingSource },
+                                });
+                                return;
+                            }
                             // Track this import name as used
                             usedImportNames.add(name);
                             // What the callee resolves to already settles this: the argument

package/lib/rules/flatten-push-calls.js

@@ -223,6 +223,206 @@ function canSafelyFix(group) {
         });
     });
 }
+/**
+ * `Array.prototype.push` is variadic, so merging consecutive appends onto one
+ * array preserves meaning. A method named `push` on any other receiver need not
+ * be: Next.js's `Router.push(url, as, options)` and react-router's
+ * `history.push(path, state)` are POSITIONAL, so folding two navigations into
+ * one call performs a single navigation with the address bar masked by the
+ * second argument. The merge is therefore gated on syntactic evidence that the
+ * receiver is an array, and stays silent without it — a missed consolidation
+ * costs far less than a fix that changes what the code does.
+ */
+const ARRAY_TYPE_NAMES = new Set(['Array', 'ReadonlyArray']);
+const ARRAY_FACTORY_METHODS = new Set(['from', 'of']);
+const ARRAY_RETURNING_METHODS = new Set([
+    'map',
+    'filter',
+    'slice',
+    'concat',
+    'split',
+]);
+/** Hooks whose array type argument describes the binding they hand back. */
+const ARRAY_STATE_HOOKS = new Set(['useState', 'useRef']);
+function isFunctionNode(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression);
+}
+function isArrayTypeNode(node) {
+    if (!node)
+        return false;
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSArrayType:
+        case utils_1.AST_NODE_TYPES.TSTupleType:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            return (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                ARRAY_TYPE_NAMES.has(node.typeName.name));
+        case utils_1.AST_NODE_TYPES.TSTypeOperator:
+            return (node.operator === 'readonly' && isArrayTypeNode(node.typeAnnotation));
+        /** A union counts only when every member is an array, so `T[] | undefined`
+         * — whose `push` can be absent — does not. */
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+            return node.types.every((member) => isArrayTypeNode(member));
+        default:
+            return false;
+    }
+}
+function isArrayAnnotation(annotation) {
+    return isArrayTypeNode(annotation?.typeAnnotation);
+}
+function hasArrayTypeArgument(call) {
+    return isArrayTypeNode(call.typeParameters?.params[0]);
+}
+function getCalleeName(call) {
+    const callee = unwrapExpression(call.callee);
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier)
+        return callee.name;
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name;
+    }
+    return null;
+}
+function isArrayStateHookCall(expression) {
+    if (!expression)
+        return false;
+    const node = unwrapExpression(expression);
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
+        return false;
+    const name = getCalleeName(node);
+    return (name !== null && ARRAY_STATE_HOOKS.has(name) && hasArrayTypeArgument(node));
+}
+/**
+ * A call whose RESULT is an array. The state hooks are deliberately absent:
+ * `useRef<T[]>()` hands back a ref object and `useState<T[]>()` a tuple, so
+ * only the destructured head of that tuple is an array.
+ */
+function isArrayProducingCall(call) {
+    const callee = unwrapExpression(call.callee);
+    if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+        callee.computed ||
+        callee.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    const object = unwrapExpression(callee.object);
+    if (object.type === utils_1.AST_NODE_TYPES.Identifier && object.name === 'Array') {
+        return ARRAY_FACTORY_METHODS.has(callee.property.name);
+    }
+    return ARRAY_RETURNING_METHODS.has(callee.property.name);
+}
+function isArrayInitializer(expression) {
+    if (!expression)
+        return false;
+    const node = unwrapExpression(expression);
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.ArrayExpression:
+            return true;
+        case utils_1.AST_NODE_TYPES.NewExpression:
+            return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'Array');
+        case utils_1.AST_NODE_TYPES.CallExpression:
+            return isArrayProducingCall(node);
+        default:
+            return false;
+    }
+}
+function isArrayDeclarator(declarator, name) {
+    if (declarator.id === name) {
+        return isArrayInitializer(declarator.init);
+    }
+    /**
+     * The head of a `useState<T[]>()` / `useRef<T[]>()` tuple holds the array
+     * itself. Every other destructured binding holds an ELEMENT of whatever was
+     * destructured, which says nothing about the binding.
+     */
+    return (declarator.id.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
+        declarator.id.elements[0] === name &&
+        isArrayStateHookCall(declarator.init));
+}
+function isArrayParameterElement(param, name) {
+    switch (param.type) {
+        case utils_1.AST_NODE_TYPES.AssignmentPattern:
+            return param.left === name && isArrayInitializer(param.right);
+        /** A rest parameter binds an array by construction. */
+        case utils_1.AST_NODE_TYPES.RestElement:
+            return param.argument === name;
+        case utils_1.AST_NODE_TYPES.TSParameterProperty:
+            return isArrayParameterElement(param.parameter, name);
+        default:
+            return false;
+    }
+}
+function isArrayParameter(fn, name) {
+    return fn.params.some((param) => isArrayParameterElement(param, name));
+}
+function hasDefinitionArrayEvidence(def) {
+    const name = def.name;
+    /** A binding introduced by anything but a plain name carries no annotation. */
+    if (name.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return false;
+    if (isArrayAnnotation(name.typeAnnotation))
+        return true;
+    if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        return isArrayDeclarator(def.node, name);
+    }
+    return isFunctionNode(def.node) && isArrayParameter(def.node, name);
+}
+function isArrayParameterProperty(param, name) {
+    const binding = param.parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern
+        ? param.parameter.left
+        : param.parameter;
+    if (binding.type !== utils_1.AST_NODE_TYPES.Identifier || binding.name !== name) {
+        return false;
+    }
+    return (isArrayAnnotation(binding.typeAnnotation) ||
+        (param.parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+            isArrayInitializer(param.parameter.right)));
+}
+function hasClassPropertyArrayEvidence(classBody, name) {
+    return classBody.body.some((member) => {
+        if (member.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+            if (getPropertyKey(member.key, Boolean(member.computed)) !== name) {
+                return false;
+            }
+            return (isArrayAnnotation(member.typeAnnotation) ||
+                isArrayInitializer(member.value));
+        }
+        if (member.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+            member.kind === 'constructor') {
+            return member.value.params.some((param) => param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
+                isArrayParameterProperty(param, name));
+        }
+        return false;
+    });
+}
+/**
+ * The class whose fields describe `this` at this position. A plain function
+ * rebinds `this` to whatever calls it, so fields declared around it say nothing
+ * about the receiver; an arrow function keeps the lexical `this`, and a method's
+ * own function expression is the class's.
+ */
+function findEnclosingClassBody(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.ClassBody)
+            return current;
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration)
+            return null;
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            const owner = current.parent;
+            const isClassMember = owner !== undefined &&
+                (owner.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+                    owner.type === utils_1.AST_NODE_TYPES.PropertyDefinition);
+            if (!isClassMember)
+                return null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
 function isPushCallStatement(statement, sourceCode) {
     if (statement.type !== utils_1.AST_NODE_TYPES.ExpressionStatement)
         return null;
@@ -332,6 +532,73 @@ exports.flattenPushCalls = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const sourceCode = context.getSourceCode();
+        /**
+         * Evidence is cached per binding rather than per receiver expression, so a
+         * long run of pushes onto one array resolves its declaration once.
+         */
+        const evidenceByVariable = new Map();
+        const evidenceByClassProperty = new Map();
+        let variablesByReference = null;
+        /**
+         * Resolution runs off the scope manager's own reference list rather than
+         * the scope of the visited node: `Program` yields the global scope, whose
+         * chain does not reach the module scope a top-level `const` lives in.
+         */
+        function resolveReference(identifier) {
+            if (!variablesByReference) {
+                const resolved = new Map();
+                sourceCode.scopeManager?.scopes.forEach((scope) => {
+                    scope.references.forEach((reference) => {
+                        resolved.set(reference.identifier, reference.resolved);
+                    });
+                });
+                variablesByReference = resolved;
+            }
+            return variablesByReference.get(identifier) ?? null;
+        }
+        function hasVariableArrayEvidence(variable) {
+            const cached = evidenceByVariable.get(variable);
+            if (cached !== undefined)
+                return cached;
+            const evidence = variable.defs.some((def) => hasDefinitionArrayEvidence(def));
+            evidenceByVariable.set(variable, evidence);
+            return evidence;
+        }
+        function hasThisPropertyArrayEvidence(receiver) {
+            const name = getPropertyKey(receiver.property, Boolean(receiver.computed));
+            if (name === null)
+                return false;
+            const classBody = findEnclosingClassBody(receiver);
+            if (!classBody)
+                return false;
+            const key = `${classBody.range[0]}:${name}`;
+            const cached = evidenceByClassProperty.get(key);
+            if (cached !== undefined)
+                return cached;
+            const evidence = hasClassPropertyArrayEvidence(classBody, name);
+            evidenceByClassProperty.set(key, evidence);
+            return evidence;
+        }
+        /**
+         * Whether the receiver is syntactically an array. Anything the source does
+         * not describe — an unresolved name, a member chain, a call result — counts
+         * as no evidence, which keeps the rule silent rather than guessing.
+         */
+        function hasArrayReceiverEvidence(receiver) {
+            const node = unwrapExpression(receiver);
+            if (node.type === utils_1.AST_NODE_TYPES.ArrayExpression)
+                return true;
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variable = resolveReference(node);
+                return variable !== null && hasVariableArrayEvidence(variable);
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                unwrapExpression(node.object).type ===
+                    utils_1.AST_NODE_TYPES.ThisExpression) {
+                return hasThisPropertyArrayEvidence(node);
+            }
+            return false;
+        }
         function buildChunks(call) {
             return call.arguments.map((arg) => ({
                 leading: sourceCode.getCommentsBefore(arg),
@@ -563,7 +830,11 @@ exports.flattenPushCalls = (0, createRule_1.createRule)({
                 return false;
             const totalArgs = group.reduce((count, entry) => count + entry.call.arguments.length, 0);
             const firstArgs = group[0].call.arguments.length;
-            return totalArgs > firstArgs && canSafelyFix(group);
+            if (totalArgs <= firstArgs || !canSafelyFix(group))
+                return false;
+            const receiver = group[0].call.callee
+                .object;
+            return hasArrayReceiverEvidence(receiver);
         }
         function reportViolation(group) {
             context.report({

package/lib/rules/global-const-style.js

@@ -306,16 +306,86 @@ const isWriteTarget = (node) => {
     }
 };
 /**
- * Whether the binding is written through anywhere in the file. Answered from
- * the scope manager's reference list rather than a textual search for the
- * name, so a same-named binding in another scope (`const arr` shadowed inside a
- * callback) contributes nothing, and a same-named method on an unrelated
- * receiver (`other.push(1)`) is never even visited.
+ * The declarator a reference initializes IN WHOLE — `OTHER` in
+ * `const OTHER = ITEMS` — or null for every other position. Such a declaration
+ * introduces a second name for one value, so whatever is done to that name is
+ * done to this binding.
+ *
+ * Type wrappers are climbed because they annotate a value without replacing it:
+ * `const OTHER = ITEMS!` and `const OTHER = ITEMS satisfies T` denote the same
+ * array as the bare form, and each breaks the same way once it is frozen. A
+ * cast that erases the element type (`ITEMS as any`) is climbed on the same
+ * terms, which withholds the assertion from a mutation the compiler would have
+ * tolerated — staying silent is the cheap error here, emitting a fix that stops
+ * the file compiling is not.
+ *
+ * A reference that is only PART of an initializer builds a fresh value rather
+ * than aliasing this one (`const COPY = [...ITEMS]`), and a destructuring id
+ * extracts a member rather than the whole, so neither is an alias here.
  */
-const isBindingMutated = (variable) => variable.references.some((reference) => {
-    const path = accessPathOf(reference.identifier);
-    return path !== null && (isMutatingMethodCall(path) || isWriteTarget(path));
-});
+const aliasDeclaratorOf = (identifier) => {
+    const value = outermostValueOf(identifier);
+    const declarator = value.parent;
+    if (declarator?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+        declarator.init !== value ||
+        declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    return declarator;
+};
+/**
+ * Whether the binding is written through anywhere in the file, under its own
+ * name or through an alias of it. Answered from the scope manager's reference
+ * list rather than a textual search for the name, so a same-named binding in
+ * another scope (`const arr` shadowed inside a callback) contributes nothing,
+ * and a same-named method on an unrelated receiver (`other.push(1)`) is never
+ * even visited.
+ *
+ * The walk follows aliases because a binding's own reference list is not where
+ * a mutation through one is recorded: in
+ * `const OTHER = ITEMS; OTHER.push(3);` the mutating call references `OTHER`, a
+ * separate variable this one never enrols, and reading only `ITEMS`'s
+ * references sees a plain read. Appending `as const` there emits TS2339 for an
+ * input that compiled (Issue #2324). Following is transitive — every hop names
+ * the one value — and `visited` keeps a chain that leads back on itself, which
+ * a redeclared `var` can build, from looping forever.
+ *
+ * The declaring KEYWORD is deliberately not screened. `as const` types the
+ * value `readonly`, and a binding takes its declared type from its initializer,
+ * so `let other = ITEMS; other.push(3);` is the same TS2339 as the `const`
+ * spelling; reassigning such a `let` does not recover mutability either,
+ * because the reassignment is then rejected against that same frozen type. A
+ * check keyed on `const` would leave the `let` spelling breaking builds under
+ * `--fix`.
+ */
+const isBindingMutated = (variable, declaredVariablesOf) => {
+    // Grown in place and walked by index: an alias found mid-walk is appended and
+    // reached by the same loop, so the traversal needs no recursion of its own.
+    const pending = [variable];
+    const visited = new Set(pending);
+    for (let index = 0; index < pending.length; index += 1) {
+        for (const reference of pending[index].references) {
+            const path = accessPathOf(reference.identifier);
+            if (path !== null) {
+                if (isMutatingMethodCall(path) || isWriteTarget(path)) {
+                    return true;
+                }
+                continue;
+            }
+            const declarator = aliasDeclaratorOf(reference.identifier);
+            if (!declarator) {
+                continue;
+            }
+            for (const alias of declaredVariablesOf(declarator)) {
+                if (!visited.has(alias)) {
+                    visited.add(alias);
+                    pending.push(alias);
+                }
+            }
+        }
+    }
+    return false;
+};
 /**
  * Walks the scope chain upward from `scope` (inclusive) and reports whether
  * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
@@ -531,6 +601,14 @@ exports.default = (0, createRule_1.createRule)({
             return (target.type === utils_1.AST_NODE_TYPES.Identifier &&
                 !PRIMITIVE_VALUE_GLOBALS.has(target.name));
         };
+        /**
+         * The bindings a declaration node introduces, as the scope manager records
+         * them. The mutation walk resolves an alias declarator through this rather
+         * than looking its name up the scope chain: the scope manager already holds
+         * the exact answer, while a name lookup would have to guess which scope a
+         * `var` was hoisted into.
+         */
+        const declaredVariablesOf = (node) => context.getDeclaredVariables(node);
         const describeValueKind = (node) => {
             const target = unwrapValueWrappers(node);
             if (target.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
@@ -722,7 +800,8 @@ exports.default = (0, createRule_1.createRule)({
                             const declaredVariable = context
                                 .getDeclaredVariables(declaration)
                                 .find((variable) => variable.name === name);
-                            return !declaredVariable || !isBindingMutated(declaredVariable);
+                            return (!declaredVariable ||
+                                !isBindingMutated(declaredVariable, declaredVariablesOf));
                         };
                         if (shouldHaveAsConst(init)) {
                             context.report({

package/lib/rules/no-try-catch-already-exists-in-transaction.d.ts

@@ -1 +1,2 @@
-export declare const noTryCatchAlreadyExistsInTransaction: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noAlreadyExistsCatchInTransaction", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noTryCatchAlreadyExistsInTransaction: TSESLint.RuleModule<"noAlreadyExistsCatchInTransaction", [], TSESLint.RuleListener>;

package/lib/rules/no-try-catch-already-exists-in-transaction.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noTryCatchAlreadyExistsInTransaction = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 const ALREADY_EXISTS_STRINGS = new Set(['already-exists', 'ALREADY_EXISTS']);
 const ALREADY_EXISTS_NUMBERS = new Set([6, '6']);
@@ -24,6 +25,118 @@ function isRunTransactionCall(node) {
     }
     return false;
 }
+/**
+ * The package surfaces whose `runTransaction` is the Firestore one.
+ *
+ * The bare name is not unique to Firestore: `firebase/database` exports a
+ * `runTransaction` for the Realtime Database, which re-applies its update
+ * function locally on conflict and carries no gRPC status codes, so
+ * `ALREADY_EXISTS` is not part of its error model and neither remedy this rule
+ * offers exists there — `runCreateForgivenessTransaction` is backend-Firestore
+ * only. Reporting an RTDB transaction leaves a developer with no way to comply.
+ */
+const FIRESTORE_MODULE_ROOTS = [
+    { packageSegments: ['firebase'], product: 'firestore' },
+    { packageSegments: ['firebase-admin'], product: 'firestore' },
+    { packageSegments: ['@firebase'], product: 'firestore' },
+    { packageSegments: ['@google-cloud'], product: 'firestore' },
+];
+/**
+ * Split a module source into path segments with any version suffix dropped, so
+ * a pinned specifier (`firebase@10/firestore`) reduces to the same root as the
+ * plain one. A `@` at the start of a segment marks a scope, not a version.
+ */
+function moduleSegments(source) {
+    return source.split('/').map((segment) => {
+        const versionIndex = segment.indexOf('@', 1);
+        return versionIndex === -1 ? segment : segment.slice(0, versionIndex);
+    });
+}
+/**
+ * Match the package root structurally rather than against one spelling: a deep
+ * entry point (`firebase/firestore/lite`), a build variant
+ * (`@firebase/firestore-compat`) and a pinned version all name the same
+ * product, and a trailing segment must not defeat the check.
+ */
+function isFirestoreModuleSource(source) {
+    const segments = moduleSegments(source);
+    return FIRESTORE_MODULE_ROOTS.some(({ packageSegments, product }) => {
+        if (!packageSegments.every((segment, index) => segments[index] === segment)) {
+            return false;
+        }
+        const productSegment = segments[packageSegments.length];
+        return (productSegment === product || !!productSegment?.startsWith(`${product}-`));
+    });
+}
+/**
+ * The module `name` is imported from, or null when the file declares the name
+ * itself (a local helper, a parameter) or nothing declares it at all.
+ */
+function importedSourceOf(scope, name) {
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, name);
+    if (!variable) {
+        return null;
+    }
+    for (const def of variable.defs) {
+        const specifier = def.node;
+        if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            specifier.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier &&
+            specifier.type !== utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            continue;
+        }
+        const declaration = specifier.parent;
+        if (declaration?.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            typeof declaration.source.value !== 'string') {
+            continue;
+        }
+        return declaration.source.value;
+    }
+    return null;
+}
+/**
+ * The identifier whose binding carries the call's provenance: the callee for
+ * `runTransaction(...)`, and the root of the member chain for
+ * `database.runTransaction(...)`, since the receiver is what an import names
+ * and the property alone matches every `<anything>.runTransaction`.
+ */
+function provenanceIdentifier(callee) {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee;
+    }
+    let current = callee;
+    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression ||
+        current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        current =
+            current.type === utils_1.AST_NODE_TYPES.MemberExpression
+                ? current.object
+                : current.expression;
+    }
+    return current.type === utils_1.AST_NODE_TYPES.Identifier ? current : null;
+}
+/**
+ * Whether a `runTransaction` call is the Firestore one this rule speaks about.
+ *
+ * The gate speaks only when it knows: a binding that resolves to an import is
+ * judged by its module source, and anything else — a bare call, a parameter, a
+ * local helper, a member call on an unresolvable receiver — keeps the rule's
+ * posture of reporting, since a name with no traceable origin is far more often
+ * Firestore (`db.runTransaction(...)`) than not.
+ */
+function isFirestoreTransactionCall(node, context) {
+    if (!isRunTransactionCall(node)) {
+        return false;
+    }
+    const carrier = provenanceIdentifier(unwrapChainExpression(node.callee));
+    if (!carrier) {
+        return true;
+    }
+    const source = importedSourceOf(ASTHelpers_1.ASTHelpers.getScope(context, node), carrier.name);
+    if (source === null) {
+        return true;
+    }
+    return isFirestoreModuleSource(source);
+}
 function getCallbackArgument(args) {
     for (const arg of args) {
         if (arg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
@@ -301,7 +414,7 @@ exports.noTryCatchAlreadyExistsInTransaction = (0, createRule_1.createRule)({
         }
         return {
             CallExpression(node) {
-                if (!isRunTransactionCall(node)) {
+                if (!isFirestoreTransactionCall(node, context)) {
                     return;
                 }
                 const callback = getCallbackArgument(node.arguments);
@@ -310,7 +423,7 @@ exports.noTryCatchAlreadyExistsInTransaction = (0, createRule_1.createRule)({
                 }
             },
             'CallExpression:exit'(node) {
-                if (!isRunTransactionCall(node)) {
+                if (!isFirestoreTransactionCall(node, context)) {
                     return;
                 }
                 const callback = getCallbackArgument(node.arguments);

package/lib/rules/prefer-sx-prop-over-system-props.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferSxPropOverSystemProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 /**
  * Matches Prettier's own default. The autofix rewrites JSX that a formatter
@@ -111,7 +112,12 @@ const MUI_SYSTEM_PROPS = new Set([
     'textTransform',
 ]);
 /**
- * Default MUI component names to check. The user can extend this via options.
+ * The MUI components this rule covers.
+ *
+ * The list narrows what provenance has already selected: an element is
+ * inspected only when it resolves to an `@mui/*` import AND names one of these,
+ * so a name here can never be the whole reason an element is rewritten. The
+ * `components` option replaces the list.
  */
 const DEFAULT_MUI_COMPONENTS = new Set([
     'Box',
@@ -229,6 +235,78 @@ function isUpperCase(name) {
         name[0] === name[0].toUpperCase() &&
         name[0] !== name[0].toLowerCase());
 }
+/**
+ * The package namespace every MUI distribution publishes under: `@mui/material`,
+ * `@mui/joy`, `@mui/system`, `@mui/lab` and their deep entry points
+ * (`@mui/material/Box`).
+ */
+const MUI_PACKAGE_PREFIX = '@mui/';
+const isMuiSource = (source) => source.startsWith(MUI_PACKAGE_PREFIX);
+/**
+ * The import that introduces `name`, or null when the file declares it itself
+ * (a local component, a parameter) or nothing declares it at all.
+ */
+function importBindingOf(scope, name) {
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, name);
+    if (!variable) {
+        return null;
+    }
+    for (const def of variable.defs) {
+        const specifier = def.node;
+        if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            specifier.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier &&
+            specifier.type !== utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            continue;
+        }
+        const declaration = specifier.parent;
+        if (declaration?.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            typeof declaration.source.value !== 'string') {
+            continue;
+        }
+        return {
+            source: declaration.source.value,
+            // A default or namespace import has no exported name to read, so the
+            // local name is the only thing that names the component.
+            exportedName: specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier
+                ? specifier.imported.name
+                : name,
+        };
+    }
+    return null;
+}
+/**
+ * The MUI export a JSX element names, or null when the element does not come
+ * from MUI.
+ *
+ * Provenance, not spelling, is what makes an element MUI: `Box`, `Button`,
+ * `Card` and `Avatar` are ordinary words that design systems, third-party
+ * packages and first-party wrappers use too, and this rule ships a fixer that
+ * moves props into an `sx` slot a non-MUI component has no reading for. On a
+ * wrapper forwarding `width`/`height` to an `<img>`, that rewrite type-checks,
+ * lints clean and silently drops the attributes.
+ *
+ * `<Ns.Box>` resolves through `Ns`, the namespace: the object carries the
+ * provenance, so reading the property alone matches every `<Anything.Box>`.
+ */
+function muiExportOf(node, scope) {
+    const { name } = node;
+    if (name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
+        const binding = importBindingOf(scope, name.name);
+        return binding && isMuiSource(binding.source) ? binding.exportedName : null;
+    }
+    if (name.type === utils_1.AST_NODE_TYPES.JSXMemberExpression) {
+        let object = name.object;
+        while (object.type === utils_1.AST_NODE_TYPES.JSXMemberExpression) {
+            object = object.object;
+        }
+        if (object.type !== utils_1.AST_NODE_TYPES.JSXIdentifier) {
+            return null;
+        }
+        const binding = importBindingOf(scope, object.name);
+        return binding && isMuiSource(binding.source) ? name.property.name : null;
+    }
+    return null;
+}
 /**
  * Convert a string value to a single-quoted JS string literal.
  * Used when building sx property values from JSX string attributes.
@@ -1023,9 +1101,14 @@ exports.preferSxPropOverSystemProps = (0, createRule_1.createRule)({
     },
     defaultOptions: [{}],
     create(context, [options]) {
-        const componentSet = options.components
+        // Naming a component here is the documented opt-in for a first-party
+        // wrapper that forwards its props to MUI. Such a wrapper is defined by
+        // living outside `@mui/*`, so the names the user lists are honored whatever
+        // introduced them.
+        const explicitComponents = options.components
             ? new Set(options.components)
-            : DEFAULT_MUI_COMPONENTS;
+            : null;
+        const componentSet = explicitComponents ?? DEFAULT_MUI_COMPONENTS;
         const extraAllowed = options.allowedProps
             ? new Set(options.allowedProps)
             : new Set();
@@ -1052,14 +1135,31 @@ exports.preferSxPropOverSystemProps = (0, createRule_1.createRule)({
             }
             return MUI_SYSTEM_PROPS.has(name) && !isAllowedProp(name);
         }
+        /**
+         * The MUI component this element is, or null when the rule leaves it alone.
+         * An element qualifies on two counts: it resolves to a component MUI
+         * exports, and that component is one the rule covers.
+         */
+        function targetedComponentOf(node) {
+            const writtenName = getComponentName(node);
+            if (!writtenName || !isUpperCase(writtenName)) {
+                return null;
+            }
+            if (explicitComponents?.has(writtenName)) {
+                return writtenName;
+            }
+            const muiExport = muiExportOf(node, ASTHelpers_1.ASTHelpers.getScope(context, node));
+            if (muiExport === null || !componentSet.has(muiExport)) {
+                return null;
+            }
+            // The export name, not the local one: an aliased `Box as MuiBox` is still
+            // MUI's `Box` for the covered-component and owned-prop lookups.
+            return muiExport;
+        }
         return {
             JSXOpeningElement(node) {
-                const componentName = getComponentName(node);
-                if (!componentName)
-                    return;
-                if (!isUpperCase(componentName))
-                    return;
-                if (!componentSet.has(componentName))
+                const componentName = targetedComponentOf(node);
+                if (componentName === null)
                     return;
                 const systemPropAttrs = [];
                 let sxAttr = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.21.4",
+  "version": "1.21.6",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,56 @@
 [
+  {
+    "version": "1.21.6",
+    "date": "2026-09-04T20:52:21.747Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          2324
+        ],
+        "summary": "follow alias chains when detecting mutation (closes #2324)"
+      },
+      {
+        "name": "no-try-catch-already-exists-in-transaction",
+        "changeType": "fix",
+        "issues": [
+          2325
+        ],
+        "summary": "gate on Firestore provenance (closes #2325)"
+      },
+      {
+        "name": "prefer-sx-prop-over-system-props",
+        "changeType": "fix",
+        "issues": [
+          2323
+        ],
+        "summary": "gate the rewrite on MUI provenance (closes #2323)"
+      }
+    ]
+  },
+  {
+    "version": "1.21.5",
+    "date": "2026-09-04T15:01:41.191Z",
+    "rules": [
+      {
+        "name": "enforce-microdiff",
+        "changeType": "fix",
+        "issues": [
+          2322
+        ],
+        "summary": "report jsdiff and fast-diff without rewriting them (closes #2322)"
+      },
+      {
+        "name": "flatten-push-calls",
+        "changeType": "fix",
+        "issues": [
+          2321
+        ],
+        "summary": "gate the merge on syntactic array evidence (closes #2321)"
+      }
+    ]
+  },
   {
     "version": "1.21.4",
     "date": "2026-09-04T11:47:38.427Z",