@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/enforce-callable-types.js

@@ -13,10 +13,10 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            missingPropsType: 'Missing Props type export in callable function file',
-            missingResponseType: 'Missing Response type export in callable function file',
-            unusedPropsType: 'Props type is exported but not used in the callable function',
-            unusedResponseType: 'Response type is exported but not used in the callable function',
+            missingPropsType: 'Callable functions must export a Props type to describe the request payload. Without Props the callable accepts any data and loses compile-time validation; export `type Props = { ... }` and use it in `CallableRequest<Props>` so request.data stays typed.',
+            missingResponseType: 'Callable functions must export a Response type to document what the function returns. Without Response the callable can return any shape and break clients; export `type Response = ...` and return that shape from the handler.',
+            unusedPropsType: 'Props is exported but never used in the onCall handler. An unused Props type lets the request payload drift from the code that reads it; annotate the handler parameter as `CallableRequest<Props>` or remove Props if the callable does not accept data.',
+            unusedResponseType: 'Response is exported but never used in the callable return type. Without applying Response, the callable can return any payload and clients lose a stable contract; return Response (or Promise<Response>) from the handler or remove the unused type.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-callback-memo.js

@@ -19,37 +19,144 @@ exports.default = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         function isFunction(node) {
-            return (node.type === utils_1.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression ||
-                node.type === utils_1.TSESTree.AST_NODE_TYPES.FunctionExpression);
+            return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+        }
+        function isInsideUseCallback(node) {
+            let current = node.parent;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const { callee } = current;
+                    const isDirectUseCallback = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.name === 'useCallback';
+                    const isMemberUseCallback = callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !callee.computed &&
+                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.property.name === 'useCallback';
+                    if (isDirectUseCallback || isMemberUseCallback) {
+                        return true;
+                    }
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function collectBoundNames(param, out) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                out.push(param.name);
+                return;
+            }
+            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                collectBoundNames(param.left, out);
+                return;
+            }
+            if (param.type === utils_1.AST_NODE_TYPES.RestElement) {
+                if (param.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    out.push(param.argument.name);
+                }
+                return;
+            }
+            if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                for (const property of param.properties) {
+                    if (property.type === utils_1.AST_NODE_TYPES.RestElement) {
+                        collectBoundNames(property, out);
+                        continue;
+                    }
+                    if (property.type !== utils_1.AST_NODE_TYPES.Property)
+                        continue;
+                    collectBoundNames(property.value, out);
+                }
+                return;
+            }
+            if (param.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                for (const element of param.elements) {
+                    if (element)
+                        collectBoundNames(element, out);
+                }
+            }
+        }
+        function getParentFunctionParams(node) {
+            let current = node.parent;
+            while (current) {
+                if (isFunction(current)) {
+                    const params = [];
+                    for (const param of current.params) {
+                        collectBoundNames(param, params);
+                    }
+                    return params;
+                }
+                current = current.parent;
+            }
+            return [];
+        }
+        function referencesParentScopeVariables(functionNode, parentParams) {
+            const scopeManager = context.getSourceCode().scopeManager;
+            if (!scopeManager)
+                return false;
+            const scope = scopeManager.acquire(functionNode);
+            if (!scope)
+                return false;
+            // "through" holds references that are not resolved within the function scope
+            for (const ref of scope.through) {
+                const { identifier } = ref;
+                const parent = identifier.parent;
+                const isPropertyKey = parent &&
+                    ((parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        !parent.computed &&
+                        parent.property === identifier) ||
+                        (parent.type === utils_1.AST_NODE_TYPES.Property &&
+                            parent.key === identifier &&
+                            parent.kind === 'init'));
+                if (isPropertyKey) {
+                    continue;
+                }
+                if (parentParams.includes(identifier.name)) {
+                    return true;
+                }
+            }
+            return false;
         }
         function containsFunction(node) {
             if (isFunction(node)) {
                 return true;
             }
-            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression) {
+            if (node.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                 return node.properties.some((prop) => {
-                    if (prop.type === utils_1.TSESTree.AST_NODE_TYPES.Property &&
-                        'value' in prop) {
+                    if (prop.type === utils_1.AST_NODE_TYPES.Property && 'value' in prop) {
                         return containsFunction(prop.value);
                     }
+                    if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        return containsFunction(prop.argument);
+                    }
                     return false;
                 });
             }
-            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression) {
+            if (node.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
                 return node.elements.some((element) => element && containsFunction(element));
             }
+            // Check ternary expressions (conditional expressions)
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                return (containsFunction(node.consequent) || containsFunction(node.alternate));
+            }
+            // Check logical expressions (&&, ||)
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                return containsFunction(node.left) || containsFunction(node.right);
+            }
             return false;
         }
         function hasJSXWithFunction(node) {
-            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement) {
+            if (node.type === utils_1.AST_NODE_TYPES.JSXElement) {
                 return node.openingElement.attributes.some((attr) => {
-                    if (attr.type === utils_1.TSESTree.AST_NODE_TYPES.JSXAttribute &&
-                        attr.value) {
-                        if (attr.value.type ===
-                            utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
+                    if (attr.type === utils_1.AST_NODE_TYPES.JSXAttribute && attr.value) {
+                        if (attr.value.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
                             return containsFunction(attr.value.expression);
                         }
                     }
+                    else if (attr.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute &&
+                        attr.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        // Only inspect literal objects to avoid heavy/static-unsafe analysis on identifiers.
+                        return containsFunction(attr.argument);
+                    }
                     return false;
                 });
             }
@@ -57,19 +164,37 @@ exports.default = (0, createRule_1.createRule)({
         }
         function checkJSXAttribute(node) {
             if (!node.value ||
-                node.value.type !== utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
+                node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
                 return;
             }
             const { expression } = node.value;
             // Skip if the prop is already wrapped in useCallback or useMemo
-            if (expression.type === utils_1.TSESTree.AST_NODE_TYPES.CallExpression &&
-                expression.callee.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
+            if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                expression.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                 (expression.callee.name === 'useCallback' ||
                     expression.callee.name === 'useMemo')) {
                 return;
             }
             // Check for direct inline functions
             if (isFunction(expression)) {
+                // Skip reporting if this callback is inside a useCallback and references parent scope variables
+                const isInUseCallback = isInsideUseCallback(expression);
+                const parentParams = getParentFunctionParams(expression);
+                const referencesParentVars = referencesParentScopeVariables(expression, parentParams);
+                if (isInUseCallback && referencesParentVars) {
+                    // Skip reporting - this is a nested callback that needs access to parent scope
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'enforceCallback',
+                });
+                return;
+            }
+            // Check for ternary expressions and logical expressions containing functions
+            if ((expression.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
+                expression.type === utils_1.AST_NODE_TYPES.LogicalExpression) &&
+                containsFunction(expression)) {
                 context.report({
                     node,
                     messageId: 'enforceCallback',
@@ -77,12 +202,12 @@ exports.default = (0, createRule_1.createRule)({
                 return;
             }
             // Check for objects/arrays/JSX elements containing functions
-            if ((expression.type === utils_1.TSESTree.AST_NODE_TYPES.ObjectExpression ||
-                expression.type === utils_1.TSESTree.AST_NODE_TYPES.ArrayExpression ||
-                expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement) &&
+            if ((expression.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                expression.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                expression.type === utils_1.AST_NODE_TYPES.JSXElement) &&
                 (containsFunction(expression) || hasJSXWithFunction(expression))) {
                 // Skip reporting if this is a JSX element and we already reported an inline function
-                if (expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement &&
+                if (expression.type === utils_1.AST_NODE_TYPES.JSXElement &&
                     hasJSXWithFunction(expression)) {
                     return;
                 }

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -15,7 +15,7 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            useCentralizedMockFirestore: 'Use the centralized mockFirestore from the predefined location instead of creating a new mock',
+            useCentralizedMockFirestore: 'This file defines or re-exports a local mockFirestore instead of importing the shared one from "{{requiredPath}}". Local mocks drift from the canonical behavior and hide API changes across suites. To fix this, import mockFirestore from the centralized test util so fixes happen in one place.',
         },
     },
     defaultOptions: [],
@@ -145,6 +145,9 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                     context.report({
                         node: Array.from(mockFirestoreNodes)[0],
                         messageId: 'useCentralizedMockFirestore',
+                        data: {
+                            requiredPath: MOCK_FIRESTORE_PATH,
+                        },
                         fix(fixer) {
                             // Instead of trying to modify the code incrementally, we'll generate the entire fixed code
                             const originalText = sourceCode.getText();

package/lib/rules/enforce-console-error.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'missingConsoleError' | 'missingConsoleWarn' | 'missingConsoleBoth';
+export declare const enforceConsoleError: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-console-error.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceConsoleError = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.enforceConsoleError = (0, createRule_1.createRule)({
+    name: 'enforce-console-error',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce proper logging for useAlertDialog based on severity. When severity is "error", console.error must be included. When severity is "warning", console.warn must be included. This ensures all user-facing errors and warnings are properly logged to monitoring systems.',
+            recommended: 'error',
+        },
+        messages: {
+            missingConsoleError: 'useAlertDialog with severity "error" requires a console.error statement in the same function scope for proper monitoring.',
+            missingConsoleWarn: 'useAlertDialog with severity "warning" requires a console.warn statement in the same function scope for proper monitoring.',
+            missingConsoleBoth: 'useAlertDialog with dynamic severity requires both console.error and console.warn statements in the same function scope for proper monitoring.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track all open calls and console calls in the entire file
+        const openCalls = [];
+        const consoleCalls = [];
+        let hasUseAlertDialog = false;
+        const functionScopeStack = [];
+        let currentFunctionScope = null;
+        // Track renamed open functions from useAlertDialog destructuring
+        const openFunctionNames = new Set();
+        // Track aliased useAlertDialog function names
+        const useAlertDialogNames = new Set(['useAlertDialog']);
+        function isUseAlertDialogCall(node) {
+            return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                useAlertDialogNames.has(node.callee.name));
+        }
+        function isConsoleCall(node, method) {
+            return (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.object.name === 'console' &&
+                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.property.name === method);
+        }
+        function getSeverityFromObjectExpression(node) {
+            for (const prop of node.properties) {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                    // Handle both computed and non-computed properties
+                    let isSeverityProperty = false;
+                    if (!prop.computed &&
+                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        prop.key.name === 'severity') {
+                        isSeverityProperty = true;
+                    }
+                    else if (prop.computed &&
+                        prop.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                        prop.key.value === 'severity') {
+                        isSeverityProperty = true;
+                    }
+                    if (isSeverityProperty) {
+                        if (prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
+                            typeof prop.value.value === 'string') {
+                            return prop.value.value;
+                        }
+                        // If severity is not a literal, treat as dynamic
+                        return 'dynamic';
+                    }
+                }
+            }
+            return null;
+        }
+        const enterFunction = (node) => {
+            functionScopeStack.push(node);
+            currentFunctionScope = functionScopeStack[functionScopeStack.length - 1];
+        };
+        const exitFunction = () => {
+            functionScopeStack.pop();
+            currentFunctionScope =
+                functionScopeStack[functionScopeStack.length - 1] ?? null;
+        };
+        return {
+            ImportDeclaration(node) {
+                // Track aliased imports of useAlertDialog
+                const importPath = String(node.source.value);
+                const isAlertDialogImport = importPath === '../useAlertDialog' ||
+                    importPath === './useAlertDialog' ||
+                    importPath === 'useAlertDialog' ||
+                    importPath.endsWith('/useAlertDialog') ||
+                    importPath.endsWith('/useAlertDialog/index') ||
+                    importPath === '@/hooks/useAlertDialog' ||
+                    importPath === 'src/hooks/useAlertDialog';
+                if (!isAlertDialogImport)
+                    return;
+                for (const specifier of node.specifiers) {
+                    // Named imports
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'useAlertDialog' &&
+                        specifier.local.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        useAlertDialogNames.add(specifier.local.name);
+                    }
+                    // Default or namespace imports still imply useAlertDialog is available via the local name
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                        specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                        if (specifier.local.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            useAlertDialogNames.add(specifier.local.name);
+                        }
+                    }
+                }
+            },
+            'Program:exit'() {
+                // Only check if we have useAlertDialog in the file
+                if (!hasUseAlertDialog)
+                    return;
+                // Group open calls by their containing function
+                const functionGroups = new Map();
+                // Group open calls by function
+                openCalls.forEach(({ node, severity, functionScope }) => {
+                    if (!functionGroups.has(functionScope)) {
+                        functionGroups.set(functionScope, {
+                            openCalls: [],
+                            consoleCalls: [],
+                        });
+                    }
+                    functionGroups.get(functionScope).openCalls.push({ node, severity });
+                });
+                // Group console calls by function
+                consoleCalls.forEach(({ node, method, functionScope }) => {
+                    if (!functionGroups.has(functionScope)) {
+                        functionGroups.set(functionScope, {
+                            openCalls: [],
+                            consoleCalls: [],
+                        });
+                    }
+                    functionGroups
+                        .get(functionScope)
+                        .consoleCalls.push({ node, method });
+                });
+                // Check each function for violations
+                functionGroups.forEach((group) => {
+                    const hasError = group.openCalls.some((call) => call.severity === 'error');
+                    const hasWarning = group.openCalls.some((call) => call.severity === 'warning');
+                    const hasDynamic = group.openCalls.some((call) => call.severity === 'dynamic');
+                    const hasConsoleError = group.consoleCalls.some((call) => call.method === 'error');
+                    const hasConsoleWarn = group.consoleCalls.some((call) => call.method === 'warn');
+                    const needsConsoleError = hasError || hasDynamic;
+                    const needsConsoleWarn = hasWarning || hasDynamic;
+                    if (hasDynamic && (!hasConsoleError || !hasConsoleWarn)) {
+                        const dynamicCall = group.openCalls.find((call) => call.severity === 'dynamic');
+                        if (dynamicCall) {
+                            context.report({
+                                node: dynamicCall.node,
+                                messageId: 'missingConsoleBoth',
+                            });
+                        }
+                    }
+                    else {
+                        if (needsConsoleError && !hasConsoleError) {
+                            const errorCall = group.openCalls.find((call) => call.severity === 'error');
+                            if (errorCall) {
+                                context.report({
+                                    node: errorCall.node,
+                                    messageId: 'missingConsoleError',
+                                });
+                            }
+                        }
+                        if (needsConsoleWarn && !hasConsoleWarn) {
+                            const warningCall = group.openCalls.find((call) => call.severity === 'warning');
+                            if (warningCall) {
+                                context.report({
+                                    node: warningCall.node,
+                                    messageId: 'missingConsoleWarn',
+                                });
+                            }
+                        }
+                    }
+                });
+            },
+            FunctionDeclaration: enterFunction,
+            FunctionExpression: enterFunction,
+            ArrowFunctionExpression: enterFunction,
+            'FunctionDeclaration:exit': exitFunction,
+            'FunctionExpression:exit': exitFunction,
+            'ArrowFunctionExpression:exit': exitFunction,
+            VariableDeclarator(node) {
+                // Track destructuring of open functions from useAlertDialog
+                if (node.init &&
+                    node.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isUseAlertDialogCall(node.init) &&
+                    node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    // Look for destructured open properties
+                    for (const prop of node.id.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'open') {
+                            if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                // Track the renamed function name
+                                openFunctionNames.add(prop.value.name);
+                            }
+                        }
+                    }
+                }
+            },
+            CallExpression(node) {
+                // Track useAlertDialog calls
+                if (isUseAlertDialogCall(node)) {
+                    hasUseAlertDialog = true;
+                }
+                // Track open method calls (both member expressions and direct calls)
+                const isOpenCall = ((node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'open') ||
+                    (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (node.callee.name === 'open' ||
+                            openFunctionNames.has(node.callee.name)))) &&
+                    node.arguments.length > 0;
+                if (isOpenCall) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        const severity = getSeverityFromObjectExpression(firstArg);
+                        if (severity && currentFunctionScope) {
+                            openCalls.push({
+                                node,
+                                severity,
+                                functionScope: currentFunctionScope,
+                            });
+                        }
+                    }
+                }
+                // Track console calls
+                if (currentFunctionScope) {
+                    if (isConsoleCall(node, 'error')) {
+                        consoleCalls.push({
+                            node,
+                            method: 'error',
+                            functionScope: currentFunctionScope,
+                        });
+                    }
+                    if (isConsoleCall(node, 'warn')) {
+                        consoleCalls.push({
+                            node,
+                            method: 'warn',
+                            functionScope: currentFunctionScope,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-console-error.js.map

package/lib/rules/enforce-css-media-queries.js

@@ -16,58 +16,39 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         messages: {
-            enforceCssMediaQueries: 'Use CSS media queries instead of JavaScript breakpoints for responsive design. JavaScript breakpoint handling can cause unnecessary re-renders and impact performance.',
+            enforceCssMediaQueries: 'Responsive breakpoint "{{source}}" uses JavaScript media detection. JavaScript breakpoints attach resize listeners inside the render path, causing avoidable re-renders and drifting from the single CSS breakpoint source of truth. Move this breakpoint into CSS (@media or container queries) and drive layout changes through class names or CSS-driven props instead of runtime hooks.',
         },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
+        const reportUsage = (node, source) => context.report({
+            node,
+            messageId: 'enforceCssMediaQueries',
+            data: { source },
+        });
         return {
-            // Check for Material-UI's useMediaQuery and react-responsive imports
+            // Only react-responsive is handled at the declaration level to avoid duplicates.
             ImportDeclaration(node) {
-                // Check for @mui/material useMediaQuery
-                if (node.source.value === '@mui/material' &&
-                    node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        specifier.imported.name === 'useMediaQuery')) {
-                    context.report({
-                        node,
-                        messageId: 'enforceCssMediaQueries',
-                    });
-                }
-                // Check for react-responsive imports
-                if (node.source.value === 'react-responsive' ||
-                    node.source.value.includes('react-responsive/')) {
-                    context.report({
-                        node,
-                        messageId: 'enforceCssMediaQueries',
-                    });
-                }
-                // Check for useMobile import from hooks/useMobile
-                if (node.source.value.includes('hooks/useMobile') &&
-                    node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        specifier.imported.name === 'useMobile')) {
-                    context.report({
-                        node,
-                        messageId: 'enforceCssMediaQueries',
-                    });
+                if (node.source.value !== 'react-responsive' &&
+                    !node.source.value.includes('react-responsive/')) {
+                    return;
                 }
+                reportUsage(node, `react-responsive import "${String(node.source.value)}"`);
             },
-            // Check for specific import specifiers
+            // Handle specific specifiers to avoid duplicate diagnostics.
             ImportSpecifier(node) {
-                if (node.parent &&
-                    node.parent.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                    node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    // Check for useMediaQuery from @mui/material
-                    ((node.parent.source.value === '@mui/material' &&
-                        node.imported.name === 'useMediaQuery') ||
-                        // Check for useMobile from any source
-                        node.imported.name === 'useMobile')) {
-                    context.report({
-                        node,
-                        messageId: 'enforceCssMediaQueries',
-                    });
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                    node.imported.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (node.parent.source.value === '@mui/material' &&
+                        node.imported.name === 'useMediaQuery') {
+                        reportUsage(node, 'useMediaQuery import from @mui/material');
+                        return;
+                    }
+                    if (node.imported.name === 'useMobile') {
+                        reportUsage(node, `useMobile import from ${String(node.parent.source.value)}`);
+                        return;
+                    }
                 }
             },
             // Check for useMediaQuery and useMobile calls
@@ -75,10 +56,7 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
                 if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                     (node.callee.name === 'useMediaQuery' ||
                         node.callee.name === 'useMobile')) {
-                    context.report({
-                        node,
-                        messageId: 'enforceCssMediaQueries',
-                    });
+                    reportUsage(node, `${node.callee.name} call`);
                 }
             },
         };