@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

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.sourceCode;
+    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.sourceCode;
+    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-hooks-default-params.js

@@ -14,7 +14,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            requireDefaultParams: 'React hooks with all optional parameters should default to an empty object',
+            requireDefaultParams: 'Hook "{{hookName}}" accepts an options object where every property is optional, but the parameter is not defaulted. When callers omit the argument the hook receives undefined, so destructuring or property access throws even though the fields are optional. Default the parameter to an empty object (e.g., "({ option } = {})") so the hook stays safe to call with no arguments.',
         },
     },
     defaultOptions: [],
@@ -81,8 +81,10 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
             'ArrowFunctionExpression, FunctionDeclaration'(node) {
                 // Check if it's a hook function
                 let isHook = false;
+                let hookName;
                 if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
-                    isHook = node.id ? isHookName(node.id.name) : false;
+                    hookName = node.id?.name;
+                    isHook = hookName ? isHookName(hookName) : false;
                 }
                 else {
                     const parent = node.parent;
@@ -90,12 +92,14 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                         parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
                         parent.id &&
                         parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        hookName = parent.id.name;
                         isHook = isHookName(parent.id.name);
                     }
                 }
                 if (!isHook) {
                     return;
                 }
+                const messageData = { hookName: hookName ?? 'this hook' };
                 // Check if it has exactly one parameter
                 if (node.params.length !== 1) {
                     return;
@@ -121,10 +125,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                         context.report({
                                             node: param,
                                             messageId: 'requireDefaultParams',
+                                            data: messageData,
                                             fix(fixer) {
-                                                const paramText = context
-                                                    .getSourceCode()
-                                                    .getText(param);
+                                                const paramText = context.sourceCode.getText(param);
                                                 return fixer.replaceText(param, `${paramText} = {}`);
                                             },
                                         });
@@ -140,10 +143,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                         context.report({
                                             node: param,
                                             messageId: 'requireDefaultParams',
+                                            data: messageData,
                                             fix(fixer) {
-                                                const paramText = context
-                                                    .getSourceCode()
-                                                    .getText(param);
+                                                const paramText = context.sourceCode.getText(param);
                                                 return fixer.replaceText(param, `${paramText} = {}`);
                                             },
                                         });
@@ -152,7 +154,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                             }
                             else {
                                 // If we can't find the type definition, check if it's defined in the same file
-                                const program = context.getSourceCode().ast;
+                                const program = context.sourceCode.ast;
                                 const typeDefinitions = program.body.filter((node) => {
                                     if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
                                         node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
@@ -172,10 +174,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                             context.report({
                                                 node: param,
                                                 messageId: 'requireDefaultParams',
+                                                data: messageData,
                                                 fix(fixer) {
-                                                    const paramText = context
-                                                        .getSourceCode()
-                                                        .getText(param);
+                                                    const paramText = context.sourceCode.getText(param);
                                                     return fixer.replaceText(param, `${paramText} = {}`);
                                                 },
                                             });
@@ -191,10 +192,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                             context.report({
                                                 node: param,
                                                 messageId: 'requireDefaultParams',
+                                                data: messageData,
                                                 fix(fixer) {
-                                                    const paramText = context
-                                                        .getSourceCode()
-                                                        .getText(param);
+                                                    const paramText = context.sourceCode.getText(param);
                                                     return fixer.replaceText(param, `${paramText} = {}`);
                                                 },
                                             });
@@ -214,8 +214,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                             context.report({
                                 node: param,
                                 messageId: 'requireDefaultParams',
+                                data: messageData,
                                 fix(fixer) {
-                                    const paramText = context.getSourceCode().getText(param);
+                                    const paramText = context.sourceCode.getText(param);
                                     return fixer.replaceText(param, `${paramText} = {}`);
                                 },
                             });

package/lib/rules/require-https-error-cause.d.ts

@@ -0,0 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'missingCause' | 'causeNotCatchBinding' | 'missingCatchBinding';
+export declare const requireHttpsErrorCause: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};

package/lib/rules/require-https-error-cause.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireHttpsErrorCause = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const isHttpsErrorCallee = (callee) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name === 'HttpsError';
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return (callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+            callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            callee.property.name === 'HttpsError');
+    }
+    return false;
+};
+const findVariableInScopeChain = (scope, name) => {
+    let currentScope = scope;
+    while (currentScope) {
+        const variable = currentScope.variables.find((item) => item.name === name);
+        if (variable) {
+            return variable;
+        }
+        currentScope = currentScope.upper;
+    }
+    return null;
+};
+exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
+    name: 'require-https-error-cause',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure HttpsError calls inside catch blocks pass the caught error as the fourth "cause" argument to preserve stack traces for monitoring.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            missingCause: 'HttpsError inside a catch block must pass the caught error as the fourth "cause" argument. Without the original error, the stack is lost and monitoring fingerprints degrade. Add {{catchName}} as the cause argument after the optional details parameter.',
+            causeNotCatchBinding: 'The fourth HttpsError argument should be the catch binding {{catchName}} so the original error stack is preserved for monitoring. Pass the catch variable instead of {{actual}}.',
+            missingCatchBinding: 'HttpsError inside a catch block needs a named catch binding so the original error can be forwarded as the fourth "cause" argument. Bind the error value (e.g., `catch (error)`) and pass that variable as the cause to keep the upstream stack trace.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const catchStack = [];
+        // ESLint 9 moves getScope onto sourceCode; ESLint 8 exposes context.getScope().
+        // This shim keeps the rule compatible until the codebase drops ESLint 8 support.
+        const getScopeForNode = (node) => {
+            const sourceCodeWithScope = sourceCode;
+            if (typeof sourceCodeWithScope.getScope === 'function') {
+                return sourceCodeWithScope.getScope(node);
+            }
+            return context.getScope();
+        };
+        const reportMissingCause = (node, catchName) => {
+            context.report({
+                node,
+                messageId: 'missingCause',
+                data: {
+                    catchName,
+                },
+            });
+        };
+        const reportWrongCause = (node, catchName, actual) => {
+            context.report({
+                node,
+                messageId: 'causeNotCatchBinding',
+                data: {
+                    catchName,
+                    actual,
+                },
+            });
+        };
+        const isCatchBindingReference = (identifier, frame) => {
+            if (!frame.paramName || identifier.name !== frame.paramName) {
+                return false;
+            }
+            const variable = findVariableInScopeChain(getScopeForNode(identifier), identifier.name);
+            return (variable?.defs.some((definition) => definition.type === 'CatchClause' && definition.node === frame.node) ?? false);
+        };
+        const validateHttpsError = (node) => {
+            if (!catchStack.length) {
+                return;
+            }
+            if (!isHttpsErrorCallee(node.callee)) {
+                return;
+            }
+            const activeCatch = catchStack[catchStack.length - 1];
+            if (!activeCatch.paramName) {
+                context.report({
+                    node,
+                    messageId: 'missingCatchBinding',
+                });
+                return;
+            }
+            const catchName = activeCatch.paramName;
+            if (node.arguments.length < 4) {
+                reportMissingCause(node, catchName);
+                return;
+            }
+            const causeArg = node.arguments[3];
+            if (!causeArg || causeArg.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                reportWrongCause(causeArg ?? node, catchName, causeArg
+                    ? sourceCode.getText(causeArg)
+                    : 'the missing cause argument');
+                return;
+            }
+            if (!isCatchBindingReference(causeArg, activeCatch)) {
+                reportWrongCause(causeArg, catchName, sourceCode.getText(causeArg));
+            }
+        };
+        return {
+            CatchClause(node) {
+                if (node.param?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    catchStack.push({ paramName: node.param.name, node });
+                    return;
+                }
+                // Destructured catch params (e.g., `catch ({ message })`) do not bind the
+                // full error object, so they cannot be forwarded as the HttpsError cause.
+                // Users should bind the error value (e.g., `catch (error)`) before rethrowing.
+                catchStack.push({ paramName: null, node });
+            },
+            'CatchClause:exit'() {
+                catchStack.pop();
+            },
+            NewExpression(node) {
+                validateHttpsError(node);
+            },
+            CallExpression(node) {
+                validateHttpsError(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-https-error-cause.js.map

package/lib/rules/require-https-error.js

@@ -11,8 +11,8 @@ module.exports = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            useHttpsError: 'Use HttpsError instead of throw new Error in functions/src directory',
-            useProprietaryHttpsError: 'Use our proprietary HttpsError instead of firebase-admin HttpsError',
+            useHttpsError: 'Throwing "{{constructorName}}" in Cloud Functions returns a generic 500 and drops the structured status code clients rely on. Throw the proprietary HttpsError instead so responses include the correct status, sanitized message, and logging context.',
+            useProprietaryHttpsError: '{{reference}} comes from {{source}} and bypasses our proprietary HttpsError wrapper, so responses skip standardized status codes, logging, and client-safe payloads. Import and throw HttpsError from @our-company/errors to keep errors consistent.',
         },
     },
     defaultOptions: [],
@@ -22,12 +22,20 @@ module.exports = (0, createRule_1.createRule)({
         if (!filename.includes('functions/src')) {
             return {};
         }
-        let httpsIdentifier = null;
-        let httpsErrorIdentifier = null;
+        const httpsIdentifiers = new Map();
+        const httpsErrorIdentifiers = new Map();
+        const reportProprietary = (node, data) => context.report({
+            node,
+            messageId: 'useProprietaryHttpsError',
+            data,
+        });
         return {
             ImportDeclaration(node) {
                 if (node.source.value === 'firebase-admin' ||
                     node.source.value === 'firebase-admin/lib/https-error') {
+                    const sourceModule = String(node.source.value);
+                    // Report imports immediately so the forbidden dependency is blocked even
+                    // when unused; throw sites below also report to cover runtime usage.
                     // Check for direct HttpsError import
                     const httpsErrorSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         spec.imported.name === 'HttpsError');
@@ -35,17 +43,19 @@ module.exports = (0, createRule_1.createRule)({
                     const httpsSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         spec.imported.name === 'https');
                     if (httpsErrorSpecifier && 'local' in httpsErrorSpecifier) {
-                        httpsErrorIdentifier = httpsErrorSpecifier.local.name;
-                        context.report({
-                            node,
-                            messageId: 'useProprietaryHttpsError',
+                        const localName = httpsErrorSpecifier.local.name;
+                        httpsErrorIdentifiers.set(localName, sourceModule);
+                        reportProprietary(node, {
+                            reference: localName,
+                            source: sourceModule,
                         });
                     }
                     if (httpsSpecifier && 'local' in httpsSpecifier) {
-                        httpsIdentifier = httpsSpecifier.local.name;
-                        context.report({
-                            node,
-                            messageId: 'useProprietaryHttpsError',
+                        const localName = httpsSpecifier.local.name;
+                        httpsIdentifiers.set(localName, sourceModule);
+                        reportProprietary(node, {
+                            reference: `${localName}.HttpsError`,
+                            source: sourceModule,
                         });
                     }
                 }
@@ -65,22 +75,34 @@ module.exports = (0, createRule_1.createRule)({
                     context.report({
                         node,
                         messageId: 'useHttpsError',
+                        data: {
+                            constructorName: callee.name,
+                        },
                     });
                     return;
                 }
                 // Check for firebase-admin HttpsError usage
-                const isFirebaseHttpsError = callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.object.name === httpsIdentifier &&
                     callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.property.name === 'HttpsError';
-                const isDirectHttpsError = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.name === httpsErrorIdentifier;
-                if (isFirebaseHttpsError || isDirectHttpsError) {
-                    context.report({
-                        node,
-                        messageId: 'useProprietaryHttpsError',
+                    callee.property.name === 'HttpsError') {
+                    const objectName = callee.object.name;
+                    const source = httpsIdentifiers.get(objectName);
+                    if (!source) {
+                        return;
+                    }
+                    reportProprietary(node, {
+                        reference: `${objectName}.HttpsError`,
+                        source,
                     });
+                    return;
+                }
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const source = httpsErrorIdentifiers.get(callee.name);
+                    if (!source) {
+                        return;
+                    }
+                    reportProprietary(node, { reference: callee.name, source });
                 }
             },
         };