@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.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.sourceCode.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: [],
@@ -140,11 +140,14 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
             },
             'Program:exit'() {
                 if (mockFirestoreNodes.size > 0) {
-                    const sourceCode = context.getSourceCode();
+                    const sourceCode = context.sourceCode;
                     // Report only once for the entire file
                     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,278 @@
+"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 observability systems.',
+            recommended: 'error',
+        },
+        messages: {
+            missingConsoleError: 'useAlertDialog call with severity "{{severity}}" shows an error dialog but this function never logs with {{consoleMethod}}. Without the log the alert is invisible to observability and post-incident breadcrumbs. Add a {{consoleMethod}} call in this function scope before or after the open() call so the dialog is paired with an observable error trail.',
+            missingConsoleWarn: 'useAlertDialog call with severity "{{severity}}" shows a warning dialog but this function never logs with {{consoleMethod}}. Without the log the warning is invisible to observability, making degraded states hard to diagnose. Add a {{consoleMethod}} call in this function scope before or after the open() call so the dialog is paired with an observable warning trail.',
+            missingConsoleBoth: 'useAlertDialog call uses dynamic severity, so runtime may render an error or a warning dialog. It is missing {{missingMethods}} in this function scope, leaving one or more runtime severity branches (error or warning) without observability breadcrumbs: {{missingPaths}}. Branch on the severity value and add the matching console method before or after the open() call (console.error for error branches, console.warn for warning branches), as in the conditional pattern shown in the rule docs, so each branch leaves a single appropriate log trail instead of double-logging both methods.',
+        },
+        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 missingMethods = [];
+                        const missingSeverities = [];
+                        if (!hasConsoleError) {
+                            missingMethods.push('console.error');
+                            missingSeverities.push('error');
+                        }
+                        if (!hasConsoleWarn) {
+                            missingMethods.push('console.warn');
+                            missingSeverities.push('warning');
+                        }
+                        const missingMethodsLabel = missingMethods.length === 2
+                            ? 'console.error and console.warn'
+                            : missingMethods[0];
+                        const missingPathsLabel = missingSeverities.length === 2
+                            ? 'the error and warning severity paths'
+                            : `the ${missingSeverities[0]} severity path`;
+                        const dynamicCalls = group.openCalls.filter((call) => call.severity === 'dynamic');
+                        dynamicCalls.forEach((dynamicCall) => {
+                            context.report({
+                                node: dynamicCall.node,
+                                messageId: 'missingConsoleBoth',
+                                data: {
+                                    missingMethods: missingMethodsLabel,
+                                    missingPaths: missingPathsLabel,
+                                },
+                            });
+                        });
+                    }
+                    else {
+                        if (needsConsoleError && !hasConsoleError) {
+                            const errorCall = group.openCalls.find((call) => call.severity === 'error');
+                            if (errorCall) {
+                                context.report({
+                                    node: errorCall.node,
+                                    messageId: 'missingConsoleError',
+                                    data: {
+                                        severity: 'error',
+                                        consoleMethod: 'console.error',
+                                    },
+                                });
+                            }
+                        }
+                        if (needsConsoleWarn && !hasConsoleWarn) {
+                            const warningCall = group.openCalls.find((call) => call.severity === 'warning');
+                            if (warningCall) {
+                                context.report({
+                                    node: warningCall.node,
+                                    messageId: 'missingConsoleWarn',
+                                    data: {
+                                        severity: 'warning',
+                                        consoleMethod: 'console.warn',
+                                    },
+                                });
+                            }
+                        }
+                    }
+                });
+            },
+            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`);
                 }
             },
         };

package/lib/rules/enforce-dynamic-file-naming.d.ts

@@ -1,3 +1,5 @@
 export declare const RULE_NAME = "enforce-dynamic-file-naming";
+export declare const REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = "@blumintinc/blumint/require-dynamic-firebase-imports";
+export declare const DYNAMIC_RULES_LABEL: string;
 declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDynamicExtension" | "requireDisableDirective", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;