@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/rules/no-async-foreach.js

@@ -1,22 +1,225 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noAsyncForEach = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const getNodeStart = (node) => node?.range?.[0] ?? Number.POSITIVE_INFINITY;
+const getFunctionDescription = (node, fallbackName) => {
+    const declaredName = (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+        node.id?.name
+        ? node.id.name
+        : null;
+    const isArrowFunction = node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression;
+    const functionName = declaredName ?? (isArrowFunction ? undefined : fallbackName);
+    if (functionName) {
+        return `function "${functionName}"`;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        return fallbackName ? `arrow function "${fallbackName}"` : 'arrow function';
+    }
+    return 'function expression';
+};
+const findVariableInScope = (scope, name) => {
+    let currentScope = scope;
+    while (currentScope) {
+        const variable = currentScope.set.get(name);
+        if (variable) {
+            return variable;
+        }
+        currentScope = currentScope.upper;
+    }
+    return null;
+};
+/**
+ * Function declarations are hoisted across their scope regardless of source order.
+ * Returning NEGATIVE_INFINITY makes hoisted declarations always "earlier" than any
+ * callback usage when we compare source positions.
+ */
+const getDefinitionStart = (definition) => definition.node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration
+    ? Number.NEGATIVE_INFINITY
+    : getNodeStart(definition.node);
+const getReferenceStart = (reference) => getNodeStart(reference.identifier);
+const isWriteReference = (reference) => typeof reference.isWrite === 'function'
+    ? reference.isWrite()
+    : Boolean(reference.isWrite);
+const isAsyncFunctionExpression = (node) => {
+    if (!node || typeof node !== 'object') {
+        return false;
+    }
+    const typedNode = node;
+    return ((typedNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        typedNode.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+        typedNode.async === true);
+};
+/**
+ * Checks if context has direct sourceCode property
+ */
+const hasSourceCodeProperty = (context) => {
+    return 'sourceCode' in context && !!context.sourceCode;
+};
+/**
+ * Checks if context has getSourceCode method
+ */
+const hasGetSourceCodeMethod = (context) => {
+    return ('getSourceCode' in context && typeof context.getSourceCode === 'function');
+};
+/**
+ * Retrieves source code from an ESLint rule context
+ */
+const getSourceCode = (context) => {
+    if (hasSourceCodeProperty(context)) {
+        return context.sourceCode;
+    }
+    if (hasGetSourceCodeMethod(context)) {
+        return context.getSourceCode();
+    }
+    throw new Error(`Unable to retrieve source code from context in rule "no-async-foreach". ` +
+        `File: ${context.filename ??
+            context.getFilename?.() ??
+            'unknown'}. ` +
+        `Available properties: sourceCode=${typeof context
+            .sourceCode}, ` +
+        `getSourceCode=${typeof context.getSourceCode}.`);
+};
+const getScope = (context, sourceCode, node) => {
+    try {
+        const typedSourceCode = sourceCode;
+        return typedSourceCode.getScope?.(node) ?? context.getScope?.() ?? null;
+    }
+    catch {
+        return context.getScope?.() ?? null;
+    }
+};
+const analyzeInlineCallback = (callback) => {
+    if (!callback.async) {
+        return null;
+    }
+    return {
+        callbackLabel: getFunctionDescription(callback),
+    };
+};
+const getAsyncFunctionDeclarationInfo = (definition, callbackName) => {
+    if (definition.node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+        definition.node.async) {
+        return {
+            callbackLabel: getFunctionDescription(definition.node, definition.node.id?.name ?? callbackName),
+        };
+    }
+    return null;
+};
+const getAsyncVariableDeclaratorInfo = (definition, callbackName) => {
+    if (definition.node.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        return null;
+    }
+    const initializerExpression = definition.node.init;
+    if (!isAsyncFunctionExpression(initializerExpression)) {
+        return null;
+    }
+    const name = (definition.node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+        definition.node.id.name) ||
+        callbackName;
+    return {
+        callbackLabel: getFunctionDescription(initializerExpression, name),
+    };
+};
+const analyzeVariableDefinition = (definition, callbackName) => getAsyncFunctionDeclarationInfo(definition, callbackName) ??
+    getAsyncVariableDeclaratorInfo(definition, callbackName);
+const getReferenceWriteExpression = (reference) => {
+    const parent = reference.identifier.parent;
+    if (reference.writeExpr) {
+        return reference.writeExpr;
+    }
+    if (parent?.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+        return parent.right;
+    }
+    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator && parent.init) {
+        return parent.init;
+    }
+    return null;
+};
+const analyzeVariableReference = (reference) => {
+    if (!isWriteReference(reference)) {
+        return null;
+    }
+    const writeExpr = getReferenceWriteExpression(reference);
+    if (!isAsyncFunctionExpression(writeExpr)) {
+        return null;
+    }
+    const name = (writeExpr.type === utils_1.AST_NODE_TYPES.FunctionExpression &&
+        writeExpr.id?.name) ||
+        reference.identifier.name;
+    return {
+        callbackLabel: getFunctionDescription(writeExpr, name),
+    };
+};
+const analyzeCallbackAsyncStatus = (callback, scope) => {
+    if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return analyzeInlineCallback(callback);
+    }
+    if (callback.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    const variable = findVariableInScope(scope, callback.name);
+    if (!variable) {
+        return null;
+    }
+    /**
+     * Track every write to the callback identifier with its source position. Only
+     * the last write at or before the callback location determines whether the
+     * callback is async when it is passed to forEach. If the callback location is
+     * unknown, bail out to avoid blaming writes that might occur after the call
+     * (e.g., a later reassignment to async that should not retroactively flag an
+     * earlier forEach use).
+     */
+    const callbackStart = callback.range?.[0];
+    const writes = [];
+    for (const definition of variable.defs) {
+        const definitionResult = analyzeVariableDefinition(definition, callback.name);
+        writes.push({
+            start: getDefinitionStart(definition),
+            isAsync: Boolean(definitionResult),
+            info: definitionResult,
+        });
+    }
+    for (const reference of variable.references) {
+        if (!isWriteReference(reference)) {
+            continue;
+        }
+        const referenceResult = analyzeVariableReference(reference);
+        writes.push({
+            start: getReferenceStart(reference),
+            isAsync: Boolean(referenceResult),
+            info: referenceResult,
+        });
+    }
+    const relevantWrites = writes.filter(({ start }) => typeof callbackStart === 'number' && start <= callbackStart);
+    if (!relevantWrites.length) {
+        return null;
+    }
+    const lastWrite = relevantWrites.reduce((latest, current) => !latest || current.start > latest.start ? current : latest, null);
+    return lastWrite && lastWrite.isAsync ? lastWrite.info : null;
+};
 exports.noAsyncForEach = {
     create(context) {
+        const sourceCode = getSourceCode(context);
         return {
             CallExpression(node) {
                 const callee = node.callee;
-                if (callee.type === 'MemberExpression' &&
-                    callee.property.type === 'Identifier' &&
+                const callback = node.arguments[0];
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     callee.property.name === 'forEach' &&
-                    node.arguments[0] &&
-                    (node.arguments[0].type === 'ArrowFunctionExpression' ||
-                        node.arguments[0].type === 'FunctionExpression') &&
-                    node.arguments[0].async) {
-                    context.report({
-                        node,
-                        messageId: 'noAsyncForEach',
-                    });
+                    callback) {
+                    const scope = getScope(context, sourceCode, callback);
+                    const asyncCallbackInfo = analyzeCallbackAsyncStatus(callback, scope);
+                    if (asyncCallbackInfo) {
+                        context.report({
+                            node: callback,
+                            messageId: 'noAsyncForEach',
+                            data: asyncCallbackInfo,
+                        });
+                    }
                 }
             },
         };
@@ -24,11 +227,11 @@ exports.noAsyncForEach = {
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow Array.forEach with an async callback function as it does not wait for promises to resolve. This can lead to race conditions and unexpected behavior. Use a standard for...of loop for sequential execution or Promise.all with map for concurrent execution.',
+            description: 'Disallow async callbacks to Array.forEach',
             recommended: 'error',
         },
         messages: {
-            noAsyncForEach: 'Do not use async function as callback in Array.forEach. Use a standard for loop for sequential execution or Promise.all for concurrent execution.',
+            noAsyncForEach: 'Async {{callbackLabel}} passed to Array.forEach runs without awaiting each item. Array.forEach ignores returned promises, so async work executes in parallel and rejections go unhandled. Use a for...of loop to await sequentially or map with Promise.all when you want controlled concurrency.',
         },
         schema: [],
     },

package/lib/rules/no-circular-references.d.ts

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

package/lib/rules/no-circular-references.js

@@ -16,11 +16,21 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            circularReference: 'Circular reference detected in object. This can cause issues with JSON serialization and memory leaks.',
+            circularReference: 'Reference "{{referenceText}}" makes this object point back to itself (directly or through other objects). Circular object graphs throw in `JSON.stringify()` and keep members reachable longer, which causes memory leaks and unexpected mutations. Store a copy or a serialize-safe identifier instead of the original object when assigning.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        function reportCircularReference(node, reference) {
+            context.report({
+                node,
+                messageId: 'circularReference',
+                data: {
+                    referenceText: sourceCode.getText(reference),
+                },
+            });
+        }
         function isObjectExpression(node) {
             return node.type === utils_1.AST_NODE_TYPES.ObjectExpression;
         }
@@ -97,11 +107,20 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                     node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.property.name === 'method'));
         }
+        function getVariable(name) {
+            let scope = context.getScope();
+            while (scope) {
+                const variable = scope.variables.find((v) => v.name === name);
+                if (variable) {
+                    return variable;
+                }
+                scope = scope.upper;
+            }
+            return null;
+        }
         function getReferencedObject(node) {
             if (isIdentifier(node)) {
-                const scope = context.getScope();
-                const scopeId = getScopeId(scope);
-                const variable = scope.variables.find((v) => v.name === node.name);
+                const variable = getVariable(node.name);
                 if (variable?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
                     const init = variable.defs[0].node.init;
                     if (init) {
@@ -117,24 +136,13 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                         }
                     }
                 }
-                // Check objects in the current scope
-                const scopeObjects = scopeMap.get(scopeId);
-                if (scopeObjects) {
-                    for (const obj of scopeObjects) {
-                        const info = objectMap.get(obj);
-                        if (info && info.scope === scopeId && !info.isCircular) {
-                            return obj;
-                        }
-                    }
-                }
             }
             else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                 const property = node.property;
                 if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     const object = node.object;
                     if (isIdentifier(object)) {
-                        const scope = context.getScope();
-                        const variable = scope.variables.find((v) => v.name === object.name);
+                        const variable = getVariable(object.name);
                         if (variable?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
                             const init = variable.defs[0].node.init;
                             if (init) {
@@ -207,10 +215,7 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
             if (targetInfo) {
                 targetInfo.references.add(reference);
                 if (detectCircularReference(targetObj)) {
-                    context.report({
-                        node: reference,
-                        messageId: 'circularReference',
-                    });
+                    reportCircularReference(reference, reference);
                 }
             }
         }
@@ -502,10 +507,8 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                                                             if (isIdentifier(leftObj)) {
                                                                 const leftObjRef = getReferencedObject(leftObj);
                                                                 if (leftObjRef === referencedObj) {
-                                                                    context.report({
-                                                                        node: assignment,
-                                                                        messageId: 'circularReference',
-                                                                    });
+                                                                    const reference = assignment.right;
+                                                                    reportCircularReference(assignment, reference);
                                                                 }
                                                             }
                                                         }
@@ -523,10 +526,8 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                                                                     if (isIdentifier(leftObj)) {
                                                                         const leftObjRef = getReferencedObject(leftObj);
                                                                         if (leftObjRef === referencedObj) {
-                                                                            context.report({
-                                                                                node: assignment,
-                                                                                messageId: 'circularReference',
-                                                                            });
+                                                                            const reference = assignment.right;
+                                                                            reportCircularReference(assignment, reference);
                                                                         }
                                                                     }
                                                                 }
@@ -568,10 +569,8 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                                     parent.right === node) {
                                     const leftObj = getObjectFromMemberExpression(parent.left);
                                     if (leftObj === referencedObj) {
-                                        context.report({
-                                            node,
-                                            messageId: 'circularReference',
-                                        });
+                                        const reference = node;
+                                        reportCircularReference(node, reference);
                                     }
                                 }
                             }

package/lib/rules/no-class-instance-destructuring.js

@@ -14,11 +14,55 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            noClassInstanceDestructuring: 'Avoid destructuring class instances as it can lead to loss of `this` context. Use direct property access instead.',
+            noClassInstanceDestructuring: [
+                "What's wrong: Destructuring {{members}} from class instance {{instance}} detaches those members from the instance.",
+                'Why it matters: Methods can run with the wrong `this`, and getters become one-time snapshots that go stale when the instance changes.',
+                'How to fix: Access through the instance instead (for example, {{suggestion}}) and bind when you need to pass a method around.',
+            ].join('\n'),
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        function describeMember(prop) {
+            if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                if (prop.computed) {
+                    const keyText = sourceCode.getText(prop.key);
+                    return `[${keyText}]`;
+                }
+                if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return prop.key.name;
+                }
+                return sourceCode.getText(prop.key);
+            }
+            if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
+                prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return `...${prop.argument.name}`;
+            }
+            return 'member';
+        }
+        function buildAccessPath(initText, prop) {
+            const keyText = sourceCode.getText(prop.key);
+            if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier && !prop.computed) {
+                return `${initText}.${keyText}`;
+            }
+            return `${initText}[${keyText}]`;
+        }
+        function formatMembers(properties) {
+            const memberNames = properties.map(describeMember).filter(Boolean);
+            if (memberNames.length === 0)
+                return '`<members>`';
+            return memberNames.map((name) => `\`${name}\``).join(', ');
+        }
+        function formatAccessExamples(properties, initText) {
+            const accessPaths = properties
+                .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
+                .map((prop) => buildAccessPath(initText, prop));
+            if (accessPaths.length === 0) {
+                return `\`${initText}.<member>\``;
+            }
+            return accessPaths.map((path) => `\`${path}\``).join(', ');
+        }
         function isClassInstance(node) {
             // Check for new expressions
             if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
@@ -43,11 +87,16 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
                     node.init &&
                     isClassInstance(node.init)) {
                     const objectPattern = node.id;
+                    const initText = sourceCode.getText(node.init);
                     context.report({
                         node,
                         messageId: 'noClassInstanceDestructuring',
+                        data: {
+                            members: formatMembers(objectPattern.properties),
+                            instance: `\`${initText}\``,
+                            suggestion: formatAccessExamples(objectPattern.properties, initText),
+                        },
                         fix(fixer) {
-                            const sourceCode = context.getSourceCode();
                             const properties = objectPattern.properties;
                             // Skip if there's no init expression
                             if (!node.init)
@@ -56,14 +105,11 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
                             if (properties.length === 1) {
                                 const prop = properties[0];
                                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                                    const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
-                                        ? prop.key.name
-                                        : sourceCode.getText(prop.key);
                                     const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
                                         ? prop.value.name
                                         : sourceCode.getText(prop.value);
-                                    const initText = sourceCode.getText(node.init);
-                                    return fixer.replaceText(node, `${value} = ${initText}.${key}`);
+                                    const accessPath = buildAccessPath(initText, prop);
+                                    return fixer.replaceText(node, `${value} = ${accessPath}`);
                                 }
                                 return null;
                             }
@@ -71,14 +117,11 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
                             const declarations = properties
                                 .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
                                 .map((prop) => {
-                                const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
-                                    ? prop.key.name
-                                    : sourceCode.getText(prop.key);
                                 const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
                                     ? prop.value.name
                                     : sourceCode.getText(prop.value);
-                                const initText = sourceCode.getText(node.init);
-                                return `${value} = ${initText}.${key}`;
+                                const accessPath = buildAccessPath(initText, prop);
+                                return `${value} = ${accessPath}`;
                             })
                                 .join(';\nconst ');
                             // Only apply the fix if we have valid declarations

package/lib/rules/no-complex-cloud-params.js

@@ -14,7 +14,7 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noComplexObjects: 'Do not pass complex objects to cloud functions. Complex objects include class instances, objects with methods, non-serializable values (RegExp, BigInt, TypedArray, etc.), or objects with nested complex properties.',
+            noComplexObjects: 'Cloud function "{{callee}}" receives a value that is not JSON-serializable. Cloud params must stay plain data; class instances, functions, RegExp/BigInt/TypedArray values, or nested complex properties are dropped or cause runtime errors during transport to Firebase. Send only primitives and plain objects/arrays, or serialize the value first (for example, convert a RegExp to a string or JSON.stringify the payload) before calling "{{callee}}".',
         },
     },
     defaultOptions: [],
@@ -324,8 +324,9 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
             return isComplexValue(node);
         }
         function checkCloudFunctionCall(node) {
-            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                cloudFunctions.has(node.callee.name)) {
+            const callee = node.callee;
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                cloudFunctions.has(callee.name)) {
                 // Check each argument for complex objects
                 node.arguments.forEach((arg) => {
                     if (hasComplexProperties(arg) && !reportedNodes.has(node)) {
@@ -333,6 +334,9 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'noComplexObjects',
+                            data: {
+                                callee: callee.name,
+                            },
                         });
                     }
                 });

package/lib/rules/no-compositing-layer-props.js

@@ -37,12 +37,12 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. This rule checks both regular style objects and MUI sx props. Consider alternatives or explicitly document intentional layer promotion.',
+            description: 'Discourage CSS properties that force GPU compositing layers (e.g., transform, filter, will-change). Extra layers consume GPU memory and split rendering work, which slows scrolling and animation when sprinkled across a page. The rule inspects inline style objects and MUI sx props so layer promotion stays intentional rather than incidental.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            compositingLayer: '{{property}} may trigger a new compositing layer which can impact performance. Consider using alternative properties or add an eslint-disable comment if the layer promotion is intentional.',
+            compositingLayer: 'CSS property "{{property}}" promotes this element to its own GPU compositing layer. Extra layers allocate GPU memory and isolate painting, which slows scrolling and animation when used broadly. Remove "{{property}}" or keep it only when the layer promotion is intentional and documented (e.g., eslint-disable with a comment).',
         },
     },
     defaultOptions: [],

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -9,12 +9,14 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow use of conditional literals in JSX code',
+            description: 'Disallow conditional string literals beside other JSX text to avoid fragmented text nodes, translation issues, and hydration mismatches.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            unexpected: 'Conditional text literals must be wrapped in a container element when next to other text. Instead of `<div>text {condition && "more text"}</div>`, use `<div>text <span>{condition && "more text"}</span></div>` to prevent React hydration issues.',
+            unexpected: 'Conditional text literal {{literal}} is rendered next to other JSX text or expressions under condition {{condition}}. ' +
+                'This fragments text nodes, confusing translation/i18n tools and potentially causing React hydration mismatches when server and client group the text differently. ' +
+                'Wrap the conditional expression in its own element (for example, <span>{ {{expression}} }</span>) or move the entire sentence inside the conditional so it renders as a single text node.',
         },
     },
     defaultOptions: [],
@@ -42,17 +44,40 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
                     'expression' in n &&
                     (n.expression.type === 'Identifier' ||
                         n.expression.type === 'MemberExpression'));
-                // Operands of {conditional && 'string'} -- the conditional and the
-                // literal. We want to make sure we have a text literal, otherwise we'd
-                // trigger this rule on the (safe) {conditional && <div>string</div>}.
-                const expressionOperandTypes = [
-                    node.expression.left.type,
-                    node.expression.right.type,
-                ];
-                if (siblingTextNodes.concat(siblingExpressionNodes).length > 0 &&
-                    expressionOperandTypes.includes(utils_1.TSESTree.AST_NODE_TYPES.Literal)) {
-                    context.report({ node, messageId: 'unexpected' });
+                const hasSiblingContent = siblingTextNodes.concat(siblingExpressionNodes).length > 0;
+                if (!hasSiblingContent) {
+                    return;
+                }
+                const logicalExpression = node.expression;
+                const literalNode = logicalExpression.right;
+                const conditionalNode = logicalExpression.left;
+                // Only enforce when the literal is the expression's return value.
+                if (literalNode.type !== utils_1.TSESTree.AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                // Only enforce for string literals to avoid misleading messages for
+                // numeric or boolean literals rendered conditionally.
+                if (typeof literalNode.value !== 'string') {
+                    return;
+                }
+                /**
+                 * Ignore logical expressions that do not actually render the literal
+                 * conditionally (e.g., literal && condition or literal || condition)
+                 * and expressions with two literals.
+                 */
+                if (conditionalNode.type === utils_1.TSESTree.AST_NODE_TYPES.Literal) {
+                    return;
                 }
+                const sourceCode = context.getSourceCode();
+                context.report({
+                    node,
+                    messageId: 'unexpected',
+                    data: {
+                        literal: sourceCode.getText(literalNode),
+                        condition: sourceCode.getText(conditionalNode),
+                        expression: sourceCode.getText(logicalExpression),
+                    },
+                });
             },
         };
     },

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

@@ -0,0 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        ignorePatterns?: string[];
+        allowWithUseAlertDialog?: boolean;
+    }
+];
+export declare const noConsoleError: TSESLint.RuleModule<"noConsoleError", Options, TSESLint.RuleListener>;
+export {};