@blumintinc/eslint-plugin-blumint 1.20.27 → 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.27',
+        version: '1.20.28',
     },
     parseOptions: {
         ecmaVersion: 2020,

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.27",
+  "version": "1.20.28",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "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",