@blumintinc/eslint-plugin-blumint 1.20.43 → 1.20.45

package/lib/index.js

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

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -10,6 +10,7 @@ exports.enforceFirestoreDocRefGeneric = void 0;
  */
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 /**
  * @type {import('eslint').Rule.RuleModule}
  */
@@ -305,8 +306,64 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
             if (findVariableDeclaration(node)) {
                 return true;
             }
+            // Resolve the binding through the scope chain so that a typed collection
+            // stored in a variable still supplies the document generic to .doc().
+            if (isTypedCollectionBinding(node)) {
+                return true;
+            }
             return false;
         }
+        /**
+         * Resolves an identifier to its declaration and reports whether that
+         * declaration provably yields a typed CollectionReference.
+         *
+         * Deliberately conservative: only immutable (`const`) bindings with a
+         * single definition are followed, and only for one hop. An alias such as
+         * `const b = a;` is not resolved because chasing arbitrary dataflow
+         * syntactically produces unsound exemptions; `let`/`var` are refused
+         * because a later assignment can replace the value with an untyped
+         * collection. Anything unresolvable (parameters, imports, destructuring)
+         * keeps reporting, since the rule cannot prove the reference is typed.
+         */
+        function isTypedCollectionBinding(node) {
+            const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, node.name);
+            if (!variable || variable.defs.length !== 1) {
+                return false;
+            }
+            const def = variable.defs[0];
+            if (def.type !== 'Variable' ||
+                def.node.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                def.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+                def.parent.kind !== 'const') {
+                return false;
+            }
+            const declarator = def.node;
+            if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                declarator.id.typeAnnotation) {
+                return hasCollectionReferenceType(declarator.id.typeAnnotation.typeAnnotation);
+            }
+            return isTypedCollectionInitializer(declarator.init);
+        }
+        function isTypedCollectionInitializer(init) {
+            if (!init) {
+                return false;
+            }
+            // An explicit assertion states the schema just as an annotation does.
+            if (init.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                return hasCollectionReferenceType(init.typeAnnotation);
+            }
+            // Mirrors the chained `db.collection<T>('x').doc('y')` detection: the
+            // presence of the type argument is what matters here. An `any`/`{}`
+            // argument is already reported on the collection call itself, so it is
+            // not reported a second time on the derived document reference.
+            return (init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                init.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                init.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                init.callee.property.name === 'collection' &&
+                !!init.typeParameters &&
+                init.typeParameters.params.length > 0);
+        }
         function checkCallExpressionForCollectionReference(node) {
             // Check if this is a method call that returns CollectionReference
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {

package/lib/rules/enforce-mui-rounded-icons.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMuiRoundedIcons = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+const MUI_ICONS_BARREL = '@mui/icons-material';
+const MUI_ICONS_DEEP_PREFIX = `${MUI_ICONS_BARREL}/`;
 /**
  * Non-Rounded MUI variant suffixes. An icon imported as one of these variants
  * (e.g. `AddReactionOutlined`) maps to the Rounded variant of its BASE name
@@ -31,11 +33,39 @@ const ICONS_WITHOUT_ROUNDED = new Set([
     'X',
     'YouTube',
 ]);
+/**
+ * Names the @mui/icons-material barrel exports that are not icons, so a
+ * `*Rounded` sibling never exists for them. `SvgIconComponent` is the icon
+ * component *type*, reached through the same barrel as the icons themselves.
+ */
+const NON_ICON_EXPORTS = new Set(['SvgIconComponent']);
 /** Strips a trailing non-Rounded variant suffix to recover the base icon name. */
 const toBaseIconName = (iconName) => {
     const suffix = VARIANT_SUFFIXES.find((variant) => iconName.endsWith(variant));
     return suffix ? iconName.slice(0, -suffix.length) : iconName;
 };
+/**
+ * Single source of truth for both import forms: maps the name an icon is
+ * imported under to the Rounded name that should replace it, or null when the
+ * name needs no change — it is already Rounded, it is not an icon, or MUI ships
+ * that icon without a Rounded variant.
+ */
+const toRoundedIconName = (iconName) => {
+    if (!iconName ||
+        iconName.endsWith('Rounded') ||
+        NON_ICON_EXPORTS.has(iconName)) {
+        return null;
+    }
+    // Map a non-Rounded variant to its base icon so the suggestion/fix targets a
+    // name that actually exists.
+    const baseIconName = toBaseIconName(iconName);
+    // Brand icons have no Rounded variant — demanding one is a false positive and
+    // the fix would point at a name that does not exist.
+    if (ICONS_WITHOUT_ROUNDED.has(baseIconName)) {
+        return null;
+    }
+    return `${baseIconName}Rounded`;
+};
 exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     name: 'enforce-mui-rounded-icons',
     meta: {
@@ -52,41 +82,68 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        /** `import LogoutIcon from '@mui/icons-material/Logout'` — the icon is named by the module path. */
+        const checkDeepImport = (node, iconPath) => {
+            const iconName = iconPath.split('/').pop();
+            const roundedVariant = iconName ? toRoundedIconName(iconName) : null;
+            if (!roundedVariant) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: 'enforceRoundedVariant',
+                // The local binding is untouched: only the module the icon comes from
+                // changes.
+                fix: (fixer) => fixer.replaceText(node.source, `'${MUI_ICONS_DEEP_PREFIX}${roundedVariant}'`),
+            });
+        };
+        /** `import { Logout } from '@mui/icons-material'` — the icon is named by each specifier. */
+        const checkBarrelImport = (node) => {
+            // A type-only import names a type, and the barrel's type exports are not
+            // icons; nothing it introduces can be rendered.
+            if (node.importKind === 'type') {
+                return;
+            }
+            for (const specifier of node.specifiers) {
+                // Default and namespace imports name no individual icon.
+                if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                    specifier.importKind === 'type') {
+                    continue;
+                }
+                const importedName = specifier.imported.name;
+                const roundedVariant = toRoundedIconName(importedName);
+                if (!roundedVariant) {
+                    continue;
+                }
+                // An alias keeps the local binding independent of the imported name, so
+                // swapping the imported name is a self-contained edit. Without one, a
+                // fix would rename the binding and would have to rewrite every
+                // reference to it (shorthand properties, export specifiers, JSX) — so
+                // that form is reported without a fix rather than risking a corrupting
+                // edit.
+                const isAliased = specifier.local.name !== importedName;
+                context.report({
+                    node: specifier,
+                    messageId: 'enforceRoundedVariant',
+                    fix: isAliased
+                        ? (fixer) => fixer.replaceText(specifier.imported, roundedVariant)
+                        : null,
+                });
+            }
+        };
         return {
             ImportDeclaration(node) {
-                // Only check imports from @mui/icons-material
-                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.source.value === 'string' &&
-                    node.source.value.startsWith('@mui/icons-material/')) {
-                    const iconPath = node.source.value;
-                    // Skip if already using -Rounded variant
-                    if (iconPath.endsWith('Rounded')) {
-                        return;
-                    }
-                    // Extract the icon name from the path
-                    const iconName = iconPath.split('/').pop();
-                    // Skip if the icon name is not a string (shouldn't happen)
-                    if (!iconName) {
-                        return;
-                    }
-                    // Map a non-Rounded variant import to its base icon so the Rounded
-                    // suggestion/fix targets a name that actually exists.
-                    const baseIconName = toBaseIconName(iconName);
-                    // Brand icons have no Rounded variant — demanding one is a false
-                    // positive and the fix would point at a non-existent module.
-                    if (ICONS_WITHOUT_ROUNDED.has(baseIconName)) {
-                        return;
-                    }
-                    // Create the rounded variant name
-                    const roundedVariant = `${baseIconName}Rounded`;
-                    context.report({
-                        node,
-                        messageId: 'enforceRoundedVariant',
-                        fix: (fixer) => {
-                            // Replace the import path with the rounded variant
-                            return fixer.replaceText(node.source, `'@mui/icons-material/${roundedVariant}'`);
-                        },
-                    });
+                if (node.source.type !== utils_1.AST_NODE_TYPES.Literal ||
+                    typeof node.source.value !== 'string') {
+                    return;
+                }
+                const source = node.source.value;
+                if (source.startsWith(MUI_ICONS_DEEP_PREFIX)) {
+                    checkDeepImport(node, source);
+                    return;
+                }
+                if (source === MUI_ICONS_BARREL) {
+                    checkBarrelImport(node);
                 }
             },
         };

package/lib/rules/enforce-object-literal-as-const.js

@@ -115,14 +115,23 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                     node,
                     messageId: 'enforceAsConst',
                     fix(fixer) {
-                        const text = sourceCode.getText(argument);
-                        // If it's already a type assertion but not 'as const'
+                        // A literal already carrying an explicit assertion states a contract
+                        // the fix cannot preserve: `as const` produces a readonly,
+                        // literal-typed shape that is structurally different from the
+                        // asserted type, so rewriting `as SomeType` into `as const` silently
+                        // changes what the function returns and can break the signature the
+                        // assertion was written to satisfy. The diagnostic still holds — the
+                        // author may well want `as const` — but choosing between the two
+                        // types needs a human, so decline to fix (#1503).
+                        //
+                        // Any `TSAsExpression` reaching here is a non-`const` assertion; the
+                        // `as const` case returns before the report. The angle-bracket form
+                        // (`<SomeType>{...}`, a `TSTypeAssertion`) needs no branch here
+                        // because it is never detected above — tsc rejects testing for it.
                         if (argument.type === 'TSAsExpression') {
-                            // Get the expression part (before the 'as')
-                            const expressionText = sourceCode.getText(argument.expression);
-                            return fixer.replaceText(argument, `${expressionText} as const`);
+                            return null;
                         }
-                        return fixer.replaceText(argument, `${text} as const`);
+                        return fixer.replaceText(argument, `${sourceCode.getText(argument)} as const`);
                     },
                 });
             },

package/lib/rules/enforce-transform-memoization.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceTransformMemoization = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforceTransformMemoization = (0, createRule_1.createRule)({
     name: 'enforce-transform-memoization',
     meta: {
@@ -395,6 +396,14 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
                     !adaptValueNames.has(node.callee.name)) {
                     return;
                 }
+                // Every message this rule emits prescribes useMemo/useCallback, and a
+                // hook call is legal only inside a component or another hook. An
+                // adaptValue call at module scope, in a plain helper, or in a test body
+                // is not on a render path: nothing is "recreated on every render"
+                // there, and the prescribed fix would throw "Invalid hook call".
+                if (!ASTHelpers_1.ASTHelpers.isInsideComponentOrHook(node, context)) {
+                    return;
+                }
                 const optionsArg = node.arguments[0];
                 if (!optionsArg)
                     return;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "1.20.45",
+    "date": "2026-07-31T06:37:56.216Z",
+    "rules": [
+      {
+        "name": "enforce-mui-rounded-icons",
+        "changeType": "fix",
+        "issues": [
+          1502
+        ],
+        "summary": "examine barrel imports, not just deep ones (closes #1502)"
+      },
+      {
+        "name": "enforce-object-literal-as-const",
+        "changeType": "fix",
+        "issues": [
+          1503
+        ],
+        "summary": "stop the autofix destroying an existing type assertion (closes #1503)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.44",
+    "date": "2026-07-31T05:47:19.150Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-doc-ref-generic",
+        "changeType": "fix",
+        "issues": [
+          1498
+        ],
+        "summary": "honor a typed collection bound to a const (closes #1498)"
+      },
+      {
+        "name": "enforce-transform-memoization",
+        "changeType": "fix",
+        "issues": [
+          1497
+        ],
+        "summary": "only report inside a component or hook (closes #1497)"
+      }
+    ]
+  },
   {
     "version": "1.20.43",
     "date": "2026-07-31T04:38:54.532Z",