@blumintinc/eslint-plugin-blumint 1.20.26 → 1.20.28

package/lib/index.js

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

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

@@ -681,8 +681,27 @@ function findEarliestSafeIndex(body, startIndex, dependencies, { allowHooks }) {
     }
     return targetIndex;
 }
-function getStartWithComments(statement, sourceCode) {
+/**
+ * A comment sharing a line with the code before it annotates that code, so it belongs
+ * to the preceding statement even though it lexically precedes this one. Counting it as
+ * this statement's leading comment cuts the segment boundary mid-line, which strands
+ * the comment against the wrong statement as soon as either one moves.
+ *
+ * Comments from the first own-line one onward are this statement's: a run of own-line
+ * comments directly above it reads as its preamble.
+ */
+function getLeadingComments(statement, sourceCode) {
     const comments = sourceCode.getCommentsBefore(statement);
+    const ownLine = comments.findIndex((comment) => {
+        const previous = sourceCode.getTokenBefore(comment, {
+            includeComments: true,
+        });
+        return !previous || previous.loc.end.line < comment.loc.start.line;
+    });
+    return ownLine === -1 ? [] : comments.slice(ownLine);
+}
+function getStartWithComments(statement, sourceCode) {
+    const comments = getLeadingComments(statement, sourceCode);
     const start = comments.length === 0 ? statement.range[0] : comments[0].range[0];
     const text = sourceCode.getText();
     let cursor = start - 1;

package/lib/rules/require-image-optimized.d.ts

@@ -1,7 +1,6 @@
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useImageOptimized", {
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [{
     componentPath: string;
-}[], {
-    JSXElement(node: any): void;
-    ImportDeclaration(node: any): void;
-}>;
+}];
+declare const _default: TSESLint.RuleModule<"useImageOptimized", Options, TSESLint.RuleListener>;
 export = _default;

package/lib/rules/require-image-optimized.js

@@ -1,5 +1,113 @@
 "use strict";
+const utils_1 = require("@typescript-eslint/utils");
+const path_1 = require("path");
 const createRule_1 = require("../utils/createRule");
+const DEFAULT_COMPONENT_PATH = 'src/components/image/ImageOptimized';
+/** The JSX name the fixer writes, and the named export it comes from. */
+const COMPONENT_NAME = 'ImageOptimized';
+/**
+ * `jest.mock` is the hoisted form; `doMock`/`setMock` register the same factory
+ * at call time. A factory handed to any of them *implements* the module, so an
+ * `<img>` inside one is the optimized component rather than a consumer of it.
+ */
+const MOCK_REGISTRARS = new Set(['mock', 'doMock', 'setMock']);
+/**
+ * Final segment of a module specifier or file path, extension stripped, so a
+ * relative import (`../image/ImageOptimized`), a manual mock
+ * (`../image/__mocks__/ImageOptimized`) and the configured path all reduce to
+ * the same module identity.
+ */
+const moduleNameOf = (specifier) => (0, path_1.basename)(specifier, (0, path_1.extname)(specifier));
+/** Module specifier of a `jest.mock` call, when it is statically knowable. */
+const staticSpecifierOf = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+        return node.value;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        return node.quasis[0].value.cooked;
+    }
+    return null;
+};
+const isComponentMockCall = (node, componentModule) => {
+    const { callee } = node;
+    if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        return false;
+    }
+    const { object, property } = callee;
+    if (object.type !== utils_1.AST_NODE_TYPES.Identifier || object.name !== 'jest') {
+        return false;
+    }
+    if (property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        !MOCK_REGISTRARS.has(property.name)) {
+        return false;
+    }
+    const [specifier] = node.arguments;
+    if (!specifier) {
+        return false;
+    }
+    const modulePath = staticSpecifierOf(specifier);
+    return !!modulePath && moduleNameOf(modulePath) === componentModule;
+};
+const isInsideComponentMock = (node, componentModule) => {
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            isComponentMockCall(current, componentModule)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** A type-only binding cannot be rendered, so it is no basis for a fix. */
+const isTypeOnlyImport = (definition) => {
+    const { node } = definition;
+    if (node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return (node.importKind === 'type' ||
+            node.parent?.importKind ===
+                'type');
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return (node.parent?.importKind ===
+            'type');
+    }
+    return false;
+};
+const isBoundAsValue = (scope, name) => {
+    const variable = utils_1.ASTUtils.findVariable(scope, name);
+    return (!!variable &&
+        variable.defs.length > 0 &&
+        variable.defs.some((definition) => !isTypeOnlyImport(definition)));
+};
+/**
+ * Local name the component is imported under, when it is aliased away from
+ * `ImageOptimized`. Reusing the alias keeps the fix bound to a real import
+ * instead of introducing a second, unimported name.
+ */
+const aliasedLocalName = (program, componentModule) => {
+    for (const statement of program.body) {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            statement.importKind === 'type' ||
+            typeof statement.source.value !== 'string' ||
+            moduleNameOf(statement.source.value) !== componentModule) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                return specifier.local.name;
+            }
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.imported.name === COMPONENT_NAME &&
+                specifier.importKind !== 'type') {
+                return specifier.local.name;
+            }
+        }
+    }
+    return null;
+};
 module.exports = (0, createRule_1.createRule)({
     name: 'require-image-optimized',
     meta: {
@@ -17,7 +125,7 @@ module.exports = (0, createRule_1.createRule)({
                     componentPath: {
                         type: 'string',
                         description: 'The import path for the ImageOptimized component',
-                        default: 'src/components/image/ImageOptimized',
+                        default: DEFAULT_COMPONENT_PATH,
                     },
                 },
                 additionalProperties: false,
@@ -27,38 +135,65 @@ module.exports = (0, createRule_1.createRule)({
             useImageOptimized: 'Use ImageOptimized from {{ componentPath }} instead of {{ component }}. The shared wrapper handles responsive sizing, lazy loading, and blur placeholders so images stay optimized and do not hurt Core Web Vitals. Replace this usage with ImageOptimized to send the asset through the optimization pipeline.',
         },
     },
-    defaultOptions: [{ componentPath: 'src/components/image/ImageOptimized' }],
+    defaultOptions: [{ componentPath: DEFAULT_COMPONENT_PATH }],
     create(context) {
-        const options = context.options[0] || {
-            componentPath: 'src/components/image/ImageOptimized',
-        };
-        const sourceCode = context.sourceCode;
+        const componentPath = context.options[0]?.componentPath || DEFAULT_COMPONENT_PATH;
+        const sourceCode = context.getSourceCode();
+        const componentModule = moduleNameOf(componentPath);
+        /**
+         * The component's own module and its manual mock implement the wrapper, so
+         * every image primitive they reach for is the implementation detail the
+         * rule exists to centralize, not a violation of it.
+         */
+        const isComponentImplementationFile = moduleNameOf(context.getFilename()) === componentModule;
         return {
             // Handle JSX img elements
             JSXElement(node) {
-                if (node.openingElement.name.name === 'img') {
-                    context.report({
-                        node,
-                        messageId: 'useImageOptimized',
-                        data: {
-                            componentPath: options.componentPath,
-                            component: 'img tag',
-                        },
-                        fix(fixer) {
-                            const attributes = node.openingElement.attributes
-                                .map((attr) => sourceCode.getText(attr))
-                                .join(' ');
-                            return fixer.replaceText(node, `<ImageOptimized ${attributes} />`);
-                        },
-                    });
+                const elementName = node.openingElement.name;
+                if (elementName.type !== utils_1.AST_NODE_TYPES.JSXIdentifier ||
+                    elementName.name !== 'img') {
+                    return;
+                }
+                if (isComponentImplementationFile ||
+                    isInsideComponentMock(node, componentModule)) {
+                    return;
                 }
+                const scope = context.getScope();
+                const localName = isBoundAsValue(scope, COMPONENT_NAME)
+                    ? COMPONENT_NAME
+                    : aliasedLocalName(sourceCode.ast, componentModule);
+                context.report({
+                    node,
+                    messageId: 'useImageOptimized',
+                    data: {
+                        componentPath,
+                        component: 'img tag',
+                    },
+                    fix(fixer) {
+                        // Swapping in an unimported name would strand the reference, and
+                        // picking an import path for it is a product decision the rule
+                        // cannot make; reporting without fixing keeps the file valid.
+                        if (!localName) {
+                            return null;
+                        }
+                        const attributes = node.openingElement.attributes
+                            .map((attribute) => sourceCode.getText(attribute))
+                            .join(' ');
+                        return fixer.replaceText(node, `<${localName}${attributes ? ` ${attributes}` : ''} />`);
+                    },
+                });
             },
             // Handle next/image imports and usage
             ImportDeclaration(node) {
+                if (isComponentImplementationFile) {
+                    return;
+                }
                 if (node.source.value === 'next/image' && node.specifiers.length > 0) {
-                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === 'ImportDefaultSpecifier' ||
-                        spec.type === 'ImportSpecifier') &&
-                        (spec.local.name === 'Image' || spec.imported?.name === 'Image'));
+                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                        spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier) &&
+                        (spec.local.name === 'Image' ||
+                            (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                                spec.imported.name === 'Image')));
                     if (imageSpecifier) {
                         const localName = imageSpecifier.local.name;
                         // Report the import
@@ -66,11 +201,11 @@ module.exports = (0, createRule_1.createRule)({
                             node,
                             messageId: 'useImageOptimized',
                             data: {
-                                componentPath: options.componentPath,
+                                componentPath,
                                 component: 'next/image',
                             },
                             fix(fixer) {
-                                return fixer.replaceText(node, `import ${localName} from '${options.componentPath}';`);
+                                return fixer.replaceText(node, `import ${localName} from '${componentPath}';`);
                             },
                         });
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.28",
+    "date": "2026-07-30T07:59:36.776Z",
+    "rules": [
+      {
+        "name": "require-image-optimized",
+        "changeType": "fix",
+        "issues": [
+          1417
+        ],
+        "summary": "exempt the component's own implementation and decline unbound fixes (closes #1417)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.27",
+    "date": "2026-07-30T06:36:11.493Z",
+    "rules": [
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          1416
+        ],
+        "summary": "keep a trailing comment with the statement it annotates (closes #1416)"
+      }
+    ]
+  },
   {
     "version": "1.20.26",
     "date": "2026-07-30T06:12:23.979Z",