@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -7,11 +7,11 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer useMemo over useEffect + useState for pure computations. Using useEffect to update state with a pure computation causes unnecessary re-renders.',
+            description: 'Prefer useMemo over useEffect + useState for pure computations to avoid extra render cycles and stale derived state.',
             recommended: 'error',
         },
         messages: {
-            preferUseMemo: 'Prefer useMemo over useEffect + useState for pure computations to avoid unnecessary re-renders',
+            preferUseMemo: 'Derived state "{{stateName}}" is computed inside useEffect and copied into React state even though the value comes from a pure calculation. That extra render cycle and state indirection make components re-render more and risk stale snapshots when dependencies change. Compute the value with useMemo (or inline in render) and read it directly instead of mirroring it into state.',
         },
         schema: [],
     },
@@ -84,7 +84,8 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
             if (initialValue &&
                 isIdentifierReference(initialValue) &&
                 isIdentifierReference(setterArgument) &&
-                initialValue.name === setterArgument.name) {
+                initialValue.name ===
+                    setterArgument.name) {
                 return true;
             }
             // If the initial value is a function that references a prop and the setter argument
@@ -111,7 +112,9 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
                         const stateName = node.id.elements[0].name;
                         const setterName = node.id.elements[1].name;
                         const initialValue = node.init.arguments[0] || null;
-                        stateSetters.set(setterName, { stateName, initialValue });
+                        // keep a reference to the defining identifier node
+                        const defId = node.id.elements[1];
+                        stateSetters.set(setterName, { stateName, initialValue, defId });
                     }
                 }
             },
@@ -133,7 +136,20 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
                             statement.expression.callee.type === 'Identifier') {
                             const setterName = statement.expression.callee.name;
                             const stateInfo = stateSetters.get(setterName);
-                            if (stateInfo && statement.expression.arguments.length === 1) {
+                            // Verify the setter identifier resolves to the tracked binding
+                            const calleeId = statement.expression
+                                .callee;
+                            const scope = context.getScope();
+                            const variable = scope.set.get(calleeId.name) ||
+                                scope.upper?.set.get(calleeId.name);
+                            const defNode = variable?.defs?.[0]?.name;
+                            if (!stateInfo ||
+                                !defNode ||
+                                defNode.type !== 'Identifier' ||
+                                defNode.name !== stateInfo.defId.name) {
+                                return;
+                            }
+                            if (statement.expression.arguments.length === 1) {
                                 const computation = statement.expression.arguments[0];
                                 // Skip if this is a state synchronization pattern
                                 if (isStateSynchronization(stateInfo.initialValue, computation)) {
@@ -145,6 +161,9 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
                                     context.report({
                                         node,
                                         messageId: 'preferUseMemo',
+                                        data: {
+                                            stateName: stateInfo.stateName,
+                                        },
                                     });
                                 }
                             }

package/lib/rules/react-usememo-should-be-component.d.ts

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

package/lib/rules/react-usememo-should-be-component.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reactUseMemoShouldBeComponent = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ARRAY_RETURNING_METHODS = new Set([
+    'map',
+    'flatMap',
+    'filter',
+    'concat',
+    'slice',
+]);
 /**
  * Checks if a node is a JSX element or fragment
  */
@@ -24,6 +31,99 @@ const isJsxElement = (node) => {
     return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
         node.type === utils_1.AST_NODE_TYPES.JSXFragment);
 };
+/**
+ * True if the resolved variable is referenced inside a JSX prop (attribute or spread).
+ */
+const isUsedAsComponentProp = (context, variableName, node) => {
+    // Find containing function for proper scope acquisition
+    let current = node;
+    let fn;
+    while (current?.parent) {
+        current = current.parent;
+        if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            fn = current;
+            break;
+        }
+    }
+    const sourceCode = context.getSourceCode();
+    const scopeManager = sourceCode.scopeManager;
+    const scope = scopeManager &&
+        ((fn && scopeManager.acquire(fn)) || scopeManager.acquire(node));
+    if (!scopeManager || !scope) {
+        return true;
+    }
+    const variable = scope.variables.find((v) => v.name === variableName) ??
+        scope.upper?.variables.find((v) => v.name === variableName) ??
+        null;
+    if (!variable) {
+        return true;
+    }
+    for (const ref of variable.references) {
+        let p = ref.identifier.parent ?? null;
+        while (p) {
+            if (p.type === utils_1.AST_NODE_TYPES.JSXAttribute ||
+                p.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute) {
+                return true;
+            }
+            p = p.parent;
+        }
+    }
+    return false;
+};
+const isUsedAsJsxChild = (context, variableName, node) => {
+    // Traverse the nearest function (or program) to see if the identifier appears
+    // as a JSX child expression.
+    const sourceCode = context.getSourceCode();
+    let container = sourceCode.ast;
+    let current = node;
+    while (current?.parent) {
+        current = current.parent;
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+            container = current;
+            break;
+        }
+    }
+    let found = false;
+    const visited = new Set();
+    const visit = (n) => {
+        if (found || visited.has(n))
+            return;
+        visited.add(n);
+        if (n.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+            n.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
+            n.expression.name === variableName &&
+            n.parent &&
+            (n.parent.type === utils_1.AST_NODE_TYPES.JSXElement ||
+                n.parent.type === utils_1.AST_NODE_TYPES.JSXFragment) &&
+            n.parent.children.includes(n)) {
+            found = true;
+            return;
+        }
+        for (const key of Object.keys(n)) {
+            if (key === 'parent')
+                continue;
+            const value = n[key];
+            if (!value)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child && typeof child.type === 'string') {
+                        visit(child);
+                    }
+                }
+            }
+            else if (value && typeof value.type === 'string') {
+                visit(value);
+            }
+        }
+    };
+    visit(container);
+    return found;
+};
 /**
  * Checks if a variable is used multiple times in a component
  */
@@ -149,28 +249,13 @@ const containsJsxInFunction = (node) => {
     if (body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
         return containsJsxInBlockStatement(body);
     }
-    // Check for array methods returning JSX
+    // Check for array methods returning arrays (do not flag arrays of JSX)
     if (body.type === utils_1.AST_NODE_TYPES.CallExpression) {
         if (body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-            // Check array methods like map, filter, find, etc.
-            const arrayMethods = [
-                'map',
-                'filter',
-                'find',
-                'findIndex',
-                'some',
-                'every',
-                'reduce',
-            ];
-            if (arrayMethods.includes(body.callee.property.name) &&
-                body.arguments.length > 0) {
-                const callback = body.arguments[0];
-                if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
-                    containsJsxInFunction(callback)) {
-                    return true;
-                }
+            if (ARRAY_RETURNING_METHODS.has(body.callee.property.name)) {
+                // Returning an array (even if its elements are JSX) should not be flagged
+                return false;
             }
         }
         // Check for IIFE
@@ -239,70 +324,27 @@ const containsJsxInExpression = (node) => {
             }
             return containsJsxInObject(node);
         case utils_1.AST_NODE_TYPES.CallExpression:
-            // Special case for array methods that return data structures with JSX
+            // Do not flag arrays of JSX: common array-producing patterns
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.property.name === 'map' &&
-                node.arguments.length > 0) {
-                const callback = node.arguments[0];
-                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                    // Check if the callback returns an object with both JSX and non-JSX properties
-                    if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement &&
-                        callback.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        let hasNonJsxProperties = false;
-                        let hasJsxProperties = false;
-                        for (const property of callback.body.properties) {
-                            if (property.type === utils_1.AST_NODE_TYPES.Property && property.value) {
-                                if (isJsxElement(property.value)) {
-                                    hasJsxProperties = true;
-                                }
-                                else if (property.value.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
-                                    hasNonJsxProperties = true;
-                                }
-                            }
-                        }
-                        // If the object has both JSX and non-JSX properties, it's likely a data object
-                        if (hasNonJsxProperties && hasJsxProperties) {
-                            return false;
-                        }
-                    }
-                    // For other cases, check if the function returns JSX directly
-                    return containsJsxInFunction(callback);
+                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (ARRAY_RETURNING_METHODS.has(node.callee.property.name)) {
+                    return false;
                 }
             }
+            // Array.from(...) returns an array as well
+            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.object.name === 'Array' &&
+                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.property.name === 'from') {
+                return false;
+            }
             // Check if it's an IIFE
             if (node.callee.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                 node.callee.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                 return containsJsxInFunction(node.callee);
             }
-            // Check array methods
-            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const arrayMethods = [
-                    'filter',
-                    'find',
-                    'findIndex',
-                    'some',
-                    'every',
-                    'reduce',
-                ];
-                if (arrayMethods.includes(node.callee.property.name) &&
-                    node.arguments.length > 0) {
-                    const callback = node.arguments[0];
-                    if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                        return containsJsxInFunction(callback);
-                    }
-                }
-            }
-            // Check arguments for JSX
-            for (const arg of node.arguments) {
-                if (arg.type !== utils_1.AST_NODE_TYPES.SpreadElement &&
-                    containsJsxInExpression(arg)) {
-                    return true;
-                }
-            }
+            // Do not flag based on JSX in arguments of non-IIFE calls
             return false;
         case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
         case utils_1.AST_NODE_TYPES.FunctionExpression:
@@ -371,8 +413,15 @@ const containsJsxInBlockStatement = (node) => {
         // Check variable declarations for JSX
         if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
             for (const declarator of statement.declarations) {
-                if (declarator.init && containsJsxInExpression(declarator.init)) {
-                    return true;
+                if (declarator.init) {
+                    // Ignore nested function expressions (helpers/callbacks) even if they return JSX
+                    if (declarator.init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        declarator.init.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                        continue;
+                    }
+                    if (containsJsxInExpression(declarator.init)) {
+                        return true;
+                    }
                 }
             }
         }
@@ -441,7 +490,7 @@ exports.reactUseMemoShouldBeComponent = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            useMemoShouldBeComponent: 'useMemo returning JSX should be extracted into a separate component. Use React.memo() for component memoization instead.',
+            useMemoShouldBeComponent: 'useMemo result "{{memoName}}" returns JSX, which hides a component inside a memoized value. JSX needs component identity so React can manage props, state, and dev tooling; wrapping it in useMemo bypasses that boundary and makes reuse/debugging harder. Extract this JSX into its own component and memoize it with React.memo if stability is required.',
         },
     },
     defaultOptions: [],
@@ -454,15 +503,32 @@ exports.reactUseMemoShouldBeComponent = (0, createRule_1.createRule)({
                         node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
                         node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
                         const variableName = node.parent.id.name;
+                        // Only report when the memoized value is used as a JSX child
+                        if (!isUsedAsJsxChild(context, variableName, node)) {
+                            return;
+                        }
                         // Check if the variable is used multiple times in the component
                         if (isUsedMultipleTimes(variableName, node)) {
                             // If the variable is used multiple times, allow it
                             return;
                         }
+                        // Check if the variable is used as a prop value in a JSX element
+                        if (isUsedAsComponentProp(context, variableName, node)) {
+                            // If the variable is used as a prop value, allow it
+                            return;
+                        }
                     }
+                    const memoName = node.parent &&
+                        node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? node.parent.id.name
+                        : 'useMemo return value';
                     context.report({
                         node,
                         messageId: 'useMemoShouldBeComponent',
+                        data: {
+                            memoName,
+                        },
                     });
                 }
             },

package/lib/rules/require-dynamic-firebase-imports.js

@@ -14,7 +14,7 @@ exports.default = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            requireDynamicImport: 'Firebase dependencies must be imported dynamically to reduce bundle size',
+            requireDynamicImport: 'Static Firebase import from "{{importSource}}" keeps the Firebase SDK in the initial bundle and blocks route-level code splitting. Use an `await import(\'{{importSource}}\')` dynamic import so Firebase loads only on the code path that needs it; type-only imports remain allowed.',
         },
     },
     defaultOptions: [],
@@ -72,6 +72,7 @@ exports.default = (0, createRule_1.createRule)({
                     context.report({
                         node,
                         messageId: 'requireDynamicImport',
+                        data: { importSource },
                         fix(fixer) {
                             const dynamicImport = createDynamicImport(node);
                             return fixer.replaceText(node, dynamicImport);

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

@@ -24,7 +24,7 @@ module.exports = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            useImageOptimized: 'Use ImageOptimized component from {{ componentPath }} instead of {{ component }}',
+            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' }],

package/lib/rules/require-memo.js

@@ -66,9 +66,17 @@ function checkFunction(context, node) {
             isUnmemoizedExportedFunctionComponent,
         ].map((fn) => fn(parentNode, node));
         if (results.some((result) => !!result)) {
+            const componentName = (node.type === 'FunctionDeclaration' && node.id?.name) ||
+                (parentNode.type === 'VariableDeclarator' &&
+                    parentNode.id.type === 'Identifier' &&
+                    parentNode.id.name) ||
+                'component';
             context.report({
                 node,
                 messageId: 'requireMemo',
+                data: {
+                    name: componentName,
+                },
                 fix: results[2] || results[1]
                     ? function fix(fixer) {
                         const sourceCode = context.getSourceCode();
@@ -158,7 +166,9 @@ exports.requireMemo = {
             recommended: 'error',
         },
         messages: {
-            requireMemo: 'Component definition not wrapped in memo()',
+            requireMemo: 'Component "{{name}}" renders JSX with props but is not wrapped in memo(). ' +
+                'Without memo the component function is recreated on every parent render, breaking referential equality and causing avoidable child re-renders. ' +
+                'Wrap the component with memo from util/memo so callers receive a stable reference; rename to "{{name}}Unmemoized" if it must stay un-memoized.',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/require-usememo-object-literals.js

@@ -11,7 +11,7 @@ exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         messages: {
-            requireUseMemo: 'Inline object/array literals in JSX props should be wrapped in useMemo to prevent unnecessary re-renders',
+            requireUseMemo: 'Inline {{literalType}} literal passed to {{componentName}} prop "{{propName}}" is recreated on every render, producing a new reference that forces child components to re-render even when values stay the same. Wrap the literal in useMemo (or hoist a memoized constant) so the prop reference remains stable between renders.',
         },
         schema: [],
     },
@@ -46,9 +46,15 @@ exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
                         ? jsxElement.name.name
                         : '';
                     if (elementName && /^[A-Z]/.test(elementName)) {
+                        const literalType = expression.type === 'ObjectExpression' ? 'object' : 'array';
                         context.report({
                             node: expression,
                             messageId: 'requireUseMemo',
+                            data: {
+                                literalType,
+                                propName: typeof propName === 'string' ? propName : 'prop',
+                                componentName: elementName,
+                            },
                         });
                     }
                 }

package/lib/rules/semantic-function-prefixes.js

@@ -24,17 +24,43 @@ const SUGGESTED_ALTERNATIVES = {
     process: ['transform', 'sanitize', 'compute'],
     do: ['execute', 'perform', 'apply'],
 };
+function extractFirstWord(name) {
+    let firstWord = name;
+    for (let i = 1; i < name.length; i++) {
+        const currentChar = name[i];
+        const prevChar = name[i - 1];
+        // lowercase -> Uppercase (camel/Pascal boundary)
+        if (prevChar >= 'a' &&
+            prevChar <= 'z' &&
+            currentChar >= 'A' &&
+            currentChar <= 'Z') {
+            firstWord = name.substring(0, i);
+            break;
+        }
+        // UPPERCASE acronym -> lowercase word start (e.g., XML|Http)
+        if (prevChar >= 'A' &&
+            prevChar <= 'Z' &&
+            currentChar >= 'a' &&
+            currentChar <= 'z') {
+            if (i > 1) {
+                firstWord = name.substring(0, i - 1);
+                break;
+            }
+        }
+    }
+    return firstWord;
+}
 exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
     name: 'semantic-function-prefixes',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce semantic function prefixes over generic ones like "get" and "update"',
+            description: 'Require semantic function prefixes instead of generic verbs so callers know whether a function fetches data, transforms input, or mutates state',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            avoidGenericPrefix: 'Avoid using generic prefix "{{prefix}}". Consider using one of these alternatives: {{alternatives}}',
+            avoidGenericPrefix: 'Function "{{functionName}}" starts with the generic prefix "{{prefix}}", which hides whether it fetches remote data, transforms input, or mutates state. Use a semantic verb such as {{alternatives}} to describe the operation and set caller expectations.',
         },
     },
     defaultOptions: [],
@@ -54,20 +80,17 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             if (NEXTJS_DATA_FUNCTIONS.has(methodName))
                 return;
             // Extract first word from PascalCase/camelCase
-            let firstWord = methodName;
-            for (let i = 1; i < methodName.length; i++) {
-                if (methodName[i] >= 'A' && methodName[i] <= 'Z') {
-                    firstWord = methodName.substring(0, i);
-                    break;
-                }
-            }
+            const firstWord = extractFirstWord(methodName);
             // Check for disallowed prefixes
+            // Only flag if the disallowed word is used as a prefix (not the entire name)
             for (const prefix of DISALLOWED_PREFIXES) {
-                if (firstWord.toLowerCase() === prefix.toLowerCase()) {
+                if (firstWord.toLowerCase() === prefix.toLowerCase() &&
+                    firstWord.length < methodName.length) {
                     context.report({
                         node: node.key,
                         messageId: 'avoidGenericPrefix',
                         data: {
+                            functionName: methodName,
                             prefix,
                             alternatives: SUGGESTED_ALTERNATIVES[prefix].join(', '),
                         },
@@ -99,20 +122,17 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             if (NEXTJS_DATA_FUNCTIONS.has(functionName))
                 return;
             // Extract first word from PascalCase/camelCase
-            let firstWord = functionName;
-            for (let i = 1; i < functionName.length; i++) {
-                if (functionName[i] >= 'A' && functionName[i] <= 'Z') {
-                    firstWord = functionName.substring(0, i);
-                    break;
-                }
-            }
+            const firstWord = extractFirstWord(functionName);
             // Check for disallowed prefixes
+            // Only flag if the disallowed word is used as a prefix (not the entire name)
             for (const prefix of DISALLOWED_PREFIXES) {
-                if (firstWord.toLowerCase() === prefix.toLowerCase()) {
+                if (firstWord.toLowerCase() === prefix.toLowerCase() &&
+                    firstWord.length < functionName.length) {
                     context.report({
                         node: node.id || node,
                         messageId: 'avoidGenericPrefix',
                         data: {
+                            functionName,
                             prefix,
                             alternatives: SUGGESTED_ALTERNATIVES[prefix].join(', '),
                         },

package/lib/rules/sync-onwrite-name-func.js

@@ -14,7 +14,7 @@ exports.syncOnwriteNameFunc = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            mismatchedName: 'The name field should match the func field in onWrite handlers',
+            mismatchedName: 'OnWrite handler name "{{nameValue}}" does not match func reference "{{funcName}}". The name field is what gets registered for deploys, logs, and alerts, so a mismatch hides which function is actually running. Rename the "name" value to "{{funcName}}" or point "func" to a function named "{{nameValue}}" so the trigger label and implementation stay in sync.',
         },
     },
     defaultOptions: [],
@@ -68,6 +68,10 @@ exports.syncOnwriteNameFunc = (0, createRule_1.createRule)({
                         context.report({
                             node: nameProperty,
                             messageId: 'mismatchedName',
+                            data: {
+                                nameValue,
+                                funcName,
+                            },
                             fix(fixer) {
                                 return fixer.replaceText(value, `'${funcName}'`);
                             },

package/lib/rules/test-file-location-enforcement.d.ts

@@ -0,0 +1 @@
+export declare const testFileLocationEnforcement: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"misplacedTestFile", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/test-file-location-enforcement.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testFileLocationEnforcement = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const createRule_1 = require("../utils/createRule");
+const TEST_FILE_PATTERN = /\.test\.tsx?$/i;
+const SUPPORTED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
+    name: 'test-file-location-enforcement',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce colocating *.test.ts(x) files with the code they cover.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            misplacedTestFile: 'Test file "{{testFile}}" is not colocated with its subject. Keep tests in the same directory as {{expectedNames}} so refactors move code and coverage together and engineers can find the implementation without searching separate test folders.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            Program(node) {
+                const filename = context.getFilename();
+                if (filename === '<input>' ||
+                    filename === '<text>' ||
+                    filename.includes('node_modules') ||
+                    !TEST_FILE_PATTERN.test(filename)) {
+                    return;
+                }
+                const directory = path_1.default.dirname(filename);
+                const testFileName = path_1.default.basename(filename);
+                const baseName = testFileName.replace(TEST_FILE_PATTERN, '');
+                const candidates = SUPPORTED_EXTENSIONS.map((extension) => path_1.default.join(directory, `${baseName}${extension}`));
+                const hasSibling = candidates.some((candidate) => fs_1.default.existsSync(candidate));
+                if (hasSibling) {
+                    return;
+                }
+                const relativePath = path_1.default.isAbsolute(filename)
+                    ? path_1.default.relative(process.cwd(), filename) || filename
+                    : filename;
+                const expectedNames = SUPPORTED_EXTENSIONS.map((extension) => `"${baseName}${extension}"`).join(' or ');
+                context.report({
+                    node,
+                    messageId: 'misplacedTestFile',
+                    data: { testFile: relativePath, expectedNames },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=test-file-location-enforcement.js.map

package/lib/rules/use-custom-link.js

@@ -13,7 +13,7 @@ exports.useCustomLink = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            useCustomLink: 'Import Link from src/components/Link instead of next/link',
+            useCustomLink: 'Import "{{localName}}" from src/components/Link instead of next/link. The custom Link wraps Next.js navigation with design system defaults and analytics hooks; importing next/link bypasses those wrappers and leads to inconsistent styling and missing instrumentation. Replace the import source with src/components/Link so routing uses the shared wrapper.',
         },
     },
     defaultOptions: [],
@@ -30,6 +30,11 @@ exports.useCustomLink = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'useCustomLink',
+                            data: {
+                                localName: defaultSpecifier?.local?.name ||
+                                    defaultAsSpecifier?.local?.name ||
+                                    'Link',
+                            },
                             fix(fixer) {
                                 // Get the local name of the imported Link component
                                 const localName = defaultSpecifier?.local?.name ||