@blumintinc/eslint-plugin-blumint 1.20.27 → 1.20.29

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.29',
     },
     parseOptions: {
         ecmaVersion: 2020,

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

@@ -83,6 +83,11 @@ const renameWouldCollide = (variable, newName) => {
     }
     return false;
 };
+// `undefined`, `NaN` and `Infinity` parse as identifiers but denote primitive
+// values rather than a binding being aliased, so they stay subject to the
+// naming check exactly like the literals they stand in for. Every other bare
+// identifier initializer is an alias (see `isBindingAlias`).
+const PRIMITIVE_VALUE_GLOBALS = new Set(['undefined', 'NaN', 'Infinity']);
 // Next.js recognizes these export names by their literal identifier, so
 // renaming them to UPPER_SNAKE_CASE silently breaks the framework contract
 // (e.g. `export const config` controls the API-route body parser / runtime).
@@ -139,6 +144,26 @@ exports.default = (0, createRule_1.createRule)({
             }
             return false;
         };
+        /**
+         * A bare identifier initializer (`export const toUsernameSlugStamp =
+         * toKvStamp;`) aliases an existing binding instead of declaring a
+         * configuration value, so the rule's premise does not hold: the alias
+         * inherits whatever convention its target follows, and a callable — the
+         * dominant case, since aliasing a re-exported function is the idiom — is
+         * always camelCase. Renaming one is also destructive, because the point of
+         * such a re-export is preserving a name importers depend on and a
+         * single-file fixer cannot rewrite them (Issue #1418).
+         *
+         * The check unwraps assertions so a type-pinned alias (`x as Foo`,
+         * `x as const`) is treated the same as the bare form. A `MemberExpression`
+         * (`Foo.bar`) is deliberately not covered — it keeps whatever behavior
+         * `isDynamicValue` already gives it.
+         */
+        const isBindingAlias = (node) => {
+            const target = unwrapAssertions(node);
+            return (target.type === utils_1.AST_NODE_TYPES.Identifier &&
+                !PRIMITIVE_VALUE_GLOBALS.has(target.name));
+        };
         const describeValueKind = (node) => {
             const target = unwrapAssertions(node);
             if (target.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
@@ -209,8 +234,9 @@ exports.default = (0, createRule_1.createRule)({
                     }
                     const { name } = declaration.id;
                     const init = declaration.init;
-                    // Skip if no initializer or if it's a dynamic value or class instance
-                    if (!init || isDynamicValue(init)) {
+                    // Skip if no initializer, if it's a dynamic value or class instance,
+                    // or if it merely aliases another binding
+                    if (!init || isDynamicValue(init) || isBindingAlias(init)) {
                         return;
                     }
                     const sourceCode = context.sourceCode;

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.29",
+    "date": "2026-07-30T08:31:47.570Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          1418
+        ],
+        "summary": "exempt bare-identifier binding aliases (closes #1418)"
+      }
+    ]
+  },
+  {
+    "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",