@blumintinc/eslint-plugin-blumint 1.20.133 → 1.20.135

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.133',
+        version: '1.20.135',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-assert-safe-object-key.js

@@ -346,6 +346,77 @@ function definesNumericBinding(def) {
     return (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
         isNumberAnnotated(def.name));
 }
+/**
+ * Utility wrappers whose single type argument keeps a Record annotation's key
+ * domain intact: `Readonly<Record<K, V>>` and `Partial<Record<K, V>>` admit
+ * exactly the keys `Record<K, V>` admits.
+ */
+const RECORD_KEY_PRESERVING_WRAPPERS = new Set(['Readonly', 'Partial']);
+/**
+ * The property names assertSafe exists to keep out of a lookup. A literal key
+ * union that names one of them proves nothing about safety, so the
+ * compiler-bounded carve-out refuses it and the key keeps being reported.
+ */
+const PROTOTYPE_SURFACE_NAMES = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+]);
+/**
+ * Union semantics over domains: one open member opens the whole domain, an
+ * unclassifiable member leaves it unclassifiable (it could be hiding an open
+ * one), and a closed-but-unenumerable member keeps the union closed without a
+ * literal listing.
+ */
+function foldKeyDomains(domains) {
+    const values = new Set();
+    let closed = false;
+    let unknown = false;
+    for (const domain of domains) {
+        if (domain === 'open') {
+            return 'open';
+        }
+        if (domain === 'unknown') {
+            unknown = true;
+        }
+        else if (domain === 'closed') {
+            closed = true;
+        }
+        else {
+            for (const value of domain) {
+                values.add(value);
+            }
+        }
+    }
+    if (unknown) {
+        return 'unknown';
+    }
+    if (closed) {
+        return 'closed';
+    }
+    return values;
+}
+/**
+ * An enum is a compiler-checked finite set. Members with literal initializers
+ * enumerate their runtime key strings (which is what lets the forbidden-name
+ * screen and subset comparison see them); a computed or auto-numbered member
+ * leaves the set finite but unenumerable.
+ */
+function enumKeyDomain(node) {
+    const values = new Set();
+    for (const member of node.members) {
+        const { initializer } = member;
+        if (initializer?.type === utils_1.AST_NODE_TYPES.Literal &&
+            (typeof initializer.value === 'string' ||
+                typeof initializer.value === 'number')) {
+            values.add(String(initializer.value));
+        }
+        else {
+            return 'closed';
+        }
+    }
+    return values;
+}
 exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
     name: 'enforce-assert-safe-object-key',
     meta: {
@@ -620,6 +691,260 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     init.callee.name === 'assertSafe');
             });
         };
+        /**
+         * The declared key domain of a type annotation. Alias references resolve
+         * through the scope chain to the declaration in this file — a type alias
+         * recurses into what it aliases, an enum enumerates its members, a generic
+         * type parameter is judged by its constraint (an unconstrained one could be
+         * instantiated with anything, so it reads as open). `seen` terminates a
+         * recursive alias without conflating it with a sibling reference to the
+         * same name.
+         */
+        const keyDomainOf = (typeNode, anchor, seen) => {
+            switch (typeNode.type) {
+                case utils_1.AST_NODE_TYPES.TSLiteralType: {
+                    const { literal } = typeNode;
+                    if (literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                        (typeof literal.value === 'string' ||
+                            typeof literal.value === 'number')) {
+                        return new Set([String(literal.value)]);
+                    }
+                    return 'unknown';
+                }
+                case utils_1.AST_NODE_TYPES.TSUnionType:
+                    return foldKeyDomains(typeNode.types.map((member) => keyDomainOf(member, anchor, seen)));
+                case utils_1.AST_NODE_TYPES.TSTypeReference: {
+                    if (typeNode.typeParameters ||
+                        typeNode.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                        return 'unknown';
+                    }
+                    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, anchor), typeNode.typeName.name);
+                    if (!variable || variable.defs.length === 0 || seen.has(variable)) {
+                        return 'unknown';
+                    }
+                    const nextSeen = new Set(seen).add(variable);
+                    return foldKeyDomains(variable.defs.map((def) => {
+                        switch (def.node.type) {
+                            case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+                                return keyDomainOf(def.node.typeAnnotation, anchor, nextSeen);
+                            case utils_1.AST_NODE_TYPES.TSEnumDeclaration:
+                                return enumKeyDomain(def.node);
+                            case utils_1.AST_NODE_TYPES.TSTypeParameter:
+                                return def.node.constraint
+                                    ? keyDomainOf(def.node.constraint, anchor, nextSeen)
+                                    : 'open';
+                            default:
+                                return 'unknown';
+                        }
+                    }));
+                }
+                // `(typeof KINDS)[number]` — the union derived from a values array,
+                // which prefer-union-from-const-array rewrites literal-union aliases
+                // into. The members live in a value rather than the type syntax, so
+                // they are read off the array's own literal elements — but only under
+                // `as const`: without it the array's type widens to `string[]` and the
+                // indexed access IS `string`, the open domain this rule exists to keep
+                // reported.
+                case utils_1.AST_NODE_TYPES.TSIndexedAccessType: {
+                    if (typeNode.objectType.type !== utils_1.AST_NODE_TYPES.TSTypeQuery) {
+                        return 'unknown';
+                    }
+                    const { exprName } = typeNode.objectType;
+                    if (exprName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                        return 'unknown';
+                    }
+                    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, anchor), exprName.name);
+                    if (!variable || variable.defs.length !== 1) {
+                        return 'unknown';
+                    }
+                    const def = variable.defs[0];
+                    if (def.node.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                        return 'unknown';
+                    }
+                    const init = def.node.init;
+                    const isAsConstArray = init?.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+                        init.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                        init.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        init.typeAnnotation.typeName.name === 'const' &&
+                        init.expression.type === utils_1.AST_NODE_TYPES.ArrayExpression;
+                    if (!isAsConstArray) {
+                        return 'unknown';
+                    }
+                    if (typeNode.indexType.type !== utils_1.AST_NODE_TYPES.TSNumberKeyword) {
+                        return 'closed';
+                    }
+                    const values = new Set();
+                    for (const element of init.expression
+                        .elements) {
+                        if (element?.type === utils_1.AST_NODE_TYPES.Literal &&
+                            (typeof element.value === 'string' ||
+                                typeof element.value === 'number')) {
+                            values.add(String(element.value));
+                        }
+                        else {
+                            return 'closed';
+                        }
+                    }
+                    return values;
+                }
+                case utils_1.AST_NODE_TYPES.TSStringKeyword:
+                case utils_1.AST_NODE_TYPES.TSNumberKeyword:
+                case utils_1.AST_NODE_TYPES.TSSymbolKeyword:
+                case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+                case utils_1.AST_NODE_TYPES.TSTemplateLiteralType:
+                    return 'open';
+                default:
+                    return 'unknown';
+            }
+        };
+        /**
+         * The key type parameter of a Record-shaped annotation, read through the
+         * wrappers that keep its key domain (`Readonly`, `Partial`) and through a
+         * bare in-file alias (`type Lookup = Record<K, V>`). Anything else — a type
+         * literal with an index signature, a Map, an imported alias — yields null:
+         * the annotation then makes no syntactically checkable claim about which
+         * keys exist.
+         */
+        const recordKeyTypeOf = (typeNode, anchor, seen = new Set()) => {
+            // `Record<K, V> | undefined` — the natural annotation for a receiver
+            // reached through `?.` — keys exactly what `Record<K, V>` keys: a nullish
+            // receiver short-circuits (or throws), it never indexes anything else.
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                const substantive = typeNode.types.filter((member) => member.type !== utils_1.AST_NODE_TYPES.TSUndefinedKeyword &&
+                    member.type !== utils_1.AST_NODE_TYPES.TSNullKeyword);
+                return substantive.length === 1
+                    ? recordKeyTypeOf(substantive[0], anchor, seen)
+                    : null;
+            }
+            if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+                typeNode.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            const { name } = typeNode.typeName;
+            const args = typeNode.typeParameters?.params;
+            if (name === 'Record') {
+                return args?.length === 2 ? args[0] : null;
+            }
+            if (RECORD_KEY_PRESERVING_WRAPPERS.has(name) && args?.length === 1) {
+                return recordKeyTypeOf(args[0], anchor, seen);
+            }
+            if (args) {
+                return null;
+            }
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, anchor), name);
+            if (!variable || seen.has(variable) || variable.defs.length !== 1) {
+                return null;
+            }
+            const def = variable.defs[0];
+            if (def.node.type !== utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                return null;
+            }
+            return recordKeyTypeOf(def.node.typeAnnotation, anchor, new Set(seen).add(variable));
+        };
+        /**
+         * Whether the Record's declared key domain covers the key's declared type,
+         * so that TypeScript itself rejects any key value outside the record's
+         * declared keys.
+         *
+         * Two spellings prove it:
+         *
+         * - **The same type reference on both sides** (`kind: Kind` into
+         *   `Record<Kind, V>`). Name identity makes the domains equal whatever the
+         *   alias holds — an imported alias included — so resolution is consulted
+         *   only to refuse a domain that resolves to something open (`type K =
+         *   string` re-opens the very surface this rule guards) or to a literal
+         *   union naming a prototype field.
+         * - **Literal unions the syntax can compare** (`kind: 'live' | 'simulated'`
+         *   into `Record<'live' | 'simulated', V>`, or a narrowing of it): every
+         *   literal the key admits must be a declared record key, and none of them
+         *   may name the prototype surface.
+         */
+        const recordKeyCovers = (keyAnnotation, recordKeyType, anchor) => {
+            const namesNoPrototypeField = (domain) => ![...domain].some((value) => PROTOTYPE_SURFACE_NAMES.has(value));
+            if (keyAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                recordKeyType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                !keyAnnotation.typeParameters &&
+                !recordKeyType.typeParameters &&
+                context.sourceCode.getText(keyAnnotation.typeName) ===
+                    context.sourceCode.getText(recordKeyType.typeName)) {
+                const domain = keyDomainOf(keyAnnotation, anchor, new Set());
+                if (domain === 'open') {
+                    return false;
+                }
+                return typeof domain === 'string' || namesNoPrototypeField(domain);
+            }
+            const keyDomain = keyDomainOf(keyAnnotation, anchor, new Set());
+            if (typeof keyDomain === 'string' ||
+                keyDomain.size === 0 ||
+                !namesNoPrototypeField(keyDomain)) {
+                return false;
+            }
+            const recordDomain = keyDomainOf(recordKeyType, anchor, new Set());
+            if (typeof recordDomain === 'string') {
+                return false;
+            }
+            return [...keyDomain].every((value) => recordDomain.has(value));
+        };
+        /**
+         * The type annotations declared on the binding an identifier resolves to.
+         * Every definition must carry one on the binding name itself — an
+         * annotation on a binding is what TypeScript checks every write against, so
+         * it holds for the lookup no matter which statement assigned last. A
+         * destructured binding, an unannotated declarator, an import: null, because
+         * nothing constrains what the identifier holds.
+         */
+        const declaredAnnotationsOf = (identifier) => {
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, identifier), identifier.name);
+            if (!variable || variable.defs.length === 0) {
+                return null;
+            }
+            const annotations = [];
+            for (const def of variable.defs) {
+                const bindingName = def.name;
+                if (bindingName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !bindingName.typeAnnotation) {
+                    return null;
+                }
+                annotations.push(bindingName.typeAnnotation.typeAnnotation);
+            }
+            return annotations;
+        };
+        /**
+         * Whether `object[key]` is a lookup the compiler already bounds: the object
+         * is a binding annotated `Record<K, V>` and the key a binding whose
+         * declared type `K` covers (#1875). Such a lookup cannot reach the
+         * prototype surface without the code failing to compile, so `assertSafe`
+         * would validate nothing — and it is not identity on the values that DO
+         * slip past a declared type at runtime (data crossing a persistence or
+         * version boundary): the plain lookup degrades to `undefined` where the
+         * wrapped one throws, which is precisely the semantic change that turned a
+         * graceful render fallback into a render-time crash. Both sides must be
+         * annotated: an `any`-typed or unannotated key indexes into any Record
+         * without a compile error, so the record annotation alone proves nothing.
+         */
+        const isCompilerBoundedLookup = (node, key) => {
+            if (node.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            const objectAnnotations = declaredAnnotationsOf(node.object);
+            if (!objectAnnotations) {
+                return false;
+            }
+            const recordKeyTypes = [];
+            for (const annotation of objectAnnotations) {
+                const recordKeyType = recordKeyTypeOf(annotation, node);
+                if (!recordKeyType) {
+                    return false;
+                }
+                recordKeyTypes.push(recordKeyType);
+            }
+            const keyAnnotations = declaredAnnotationsOf(key);
+            if (!keyAnnotations) {
+                return false;
+            }
+            return keyAnnotations.every((keyAnnotation) => recordKeyTypes.every((recordKeyType) => recordKeyCovers(keyAnnotation, recordKeyType, node)));
+        };
         /**
          * Whether the syntax alone proves the key is a number. `__proto__`,
          * `constructor` and `prototype` are never the string form of a number, so a
@@ -838,6 +1163,12 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isAssertSafeValidatedIdentifier(property)) {
                             return;
                         }
+                        // A typed discriminant indexing a Record whose declared keys cover
+                        // its type is compile-time bounded; wrapping it would turn a total
+                        // lookup into a throwing one (#1875).
+                        if (isCompilerBoundedLookup(node, property)) {
+                            return;
+                        }
                         const propText = context.sourceCode.getText(property);
                         reportWrittenKey(written, property, propText);
                         return;

package/lib/rules/enforce-fieldpath-syntax-in-docsetter.js

@@ -119,17 +119,49 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
         function needsQuoting(key) {
             return key.includes('.') || !/^(?:[$_A-Za-z][$\w]*)$/u.test(key);
         }
+        // A method shorthand elides the `function` keyword, and its
+        // FunctionExpression range starts at the parameter list, so copying the
+        // value's text verbatim emits `() { … }`, which is not an expression. The
+        // member is re-emitted with the keyword the shorthand leaves out, matching
+        // what the `key: function () {}` spelling already produces.
+        //
+        // `super` is the one binding the two spellings do not share: it resolves
+        // through the enclosing object literal's home object, which a function
+        // expression has none of, so such a method is declined rather than
+        // rewritten into code that cannot resolve it. Any nested `super` counts,
+        // because narrowing the scan to the method's own body would have to model
+        // which inner forms rebind it.
+        function getMethodValueText(value, sourceCode) {
+            const referencesSuper = sourceCode
+                .getTokens(value)
+                .some((token) => token.type === utils_1.AST_TOKEN_TYPES.Keyword && token.value === 'super');
+            if (referencesSuper) {
+                return undefined;
+            }
+            return `${value.async ? 'async ' : ''}function${value.generator ? '*' : ''} ${sourceCode.getText(value)}`;
+        }
+        // Text a nested leaf contributes to its FieldPath entry, or undefined when
+        // the value has no expression-position equivalent.
+        function getFlattenedValueText(property, sourceCode) {
+            if (property.method &&
+                property.value.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                return getMethodValueText(property.value, sourceCode);
+            }
+            return sourceCode.getText(property.value);
+        }
         // Collect the FieldPath entries a nested property flattens into, or bail out
         // when flattening would silently drop payload data (spreads, computed keys,
-        // accessors/methods, unsupported key literals) or would produce nothing at
-        // all. Bailing leaves the report in place so the developer flattens by hand
+        // accessors, unsupported key literals) or would produce nothing at all.
+        // Bailing leaves the report in place so the developer flattens by hand
         // instead of receiving a fix that deletes fields or emits invalid syntax.
         function collectFieldPathEntries(obj, prefix, sourceCode) {
             const entries = [];
             for (const property of obj.properties) {
+                // A getter or setter is declined even though it is spelled like a
+                // method: its body runs on access rather than holding a value, so no
+                // FieldPath entry can carry it
                 if (property.type !== utils_1.AST_NODE_TYPES.Property ||
                     property.computed ||
-                    property.method ||
                     property.kind !== 'init') {
                     return null;
                 }
@@ -146,7 +178,11 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
                     entries.push(...nestedEntries);
                     continue;
                 }
-                entries.push([fullKey, sourceCode.getText(property.value)]);
+                const valueText = getFlattenedValueText(property, sourceCode);
+                if (valueText === undefined) {
+                    return null;
+                }
+                entries.push([fullKey, valueText]);
             }
             return entries.length > 0 ? entries : null;
         }

package/lib/rules/enforce-id-capitalization.js

@@ -43,6 +43,9 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
             'removeAttributeNS',
             'toHaveAttribute',
         ]);
+        // A single identifier token — no whitespace, no punctuation. Prose is a
+        // phrase, so anything matching this is a name rather than displayed text.
+        const IDENTIFIER_TOKEN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
         /**
          * Check if a node is in a context that should be excluded from the rule
          * (e.g., parameter names, property names, type definitions)
@@ -116,6 +119,21 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
                     return true;
                 }
             }
+            // Check if the node is a lone identifier token listed in an array
+            // literal, e.g. ['id', 'broadcastTest'] as const. An array of bare
+            // identifiers is a key/field-name list — the array spelling of the object
+            // keys this rule already leaves alone — so 'ID' would name a key that
+            // does not exist. The carve-out requires the *whole* element to be one
+            // identifier, which keeps a phrase such as ['Enter your id', 'Name']
+            // reported: prose carries whitespace or punctuation, a key name does not.
+            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string' &&
+                node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ArrayExpression &&
+                node.parent.elements.includes(node) &&
+                IDENTIFIER_TOKEN.test(node.value)) {
+                return true;
+            }
             // Check if the node is a string literal used for property access
             // This handles cases like obj['id'] or OverwolfGame['id']
             if (node.parent &&

package/lib/rules/enforce-unique-cursor-headers.js

@@ -41,6 +41,23 @@ const DEFAULT_OPTIONS = {
         '@vitest-environment',
     ],
 };
+/**
+ * What the consumer's options are deep-merged over, with every null-valued
+ * default removed.
+ *
+ * `applyDefault` merges before `create` runs, and its `deepMerge` classifies
+ * `null` as an object (`typeof null === 'object'`), so a key that is null on
+ * both sides is recursed into and reaches `Object.keys(null)`. That throws
+ * while LOADING the rule, which aborts the lint for the whole file and takes
+ * every other rule with it. `headerTemplate` is exactly that shape: `null` is
+ * both its schema-legal value and its documented default, so a consumer who
+ * writes the documented default out explicitly crashes their own run.
+ *
+ * Omitting the key leaves the merge nothing to recurse into. Nothing is lost —
+ * `normalizeOptions` reads the default straight from `DEFAULT_OPTIONS`, so an
+ * absent key and a null one already resolve identically.
+ */
+const MERGEABLE_DEFAULT_OPTIONS = Object.fromEntries(Object.entries(DEFAULT_OPTIONS).filter(([, value]) => value !== null));
 /**
  * Maximum number of characters to scan at the beginning of a file to detect generated markers.
  */
@@ -381,7 +398,7 @@ exports.enforceUniqueCursorHeaders = (0, createRule_1.createRule)({
             splitHeaderFragment: 'Cursor header metadata is split across adjacent comment blocks → Fragmented headers are easy to miss and let required tags drift out of sync → Merge the fragments into a single top-of-file header containing: {{tags}}.',
         },
     },
-    defaultOptions: [DEFAULT_OPTIONS],
+    defaultOptions: [MERGEABLE_DEFAULT_OPTIONS],
     create(context, [userOptions]) {
         const options = normalizeOptions(userOptions);
         const fileName = context.getFilename();

package/lib/rules/no-inline-component-prop.js

@@ -414,17 +414,20 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             if (!definition)
                 return;
             const defNode = definition.node;
-            if (!defNode ||
-                defNode.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
-                !defNode.init ||
-                defNode.init.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+            if (!defNode || defNode.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return;
+            }
+            // `global-const-style` autofixes a module-scope object literal to
+            // `as const`, so reading `init` raw lets one fixer silence this rule.
+            const holder = unwrapExpression(defNode.init);
+            if (!holder || holder.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
                 return;
             }
             if (resolvedOptions.allowModuleScopeFactories &&
                 isStableForConsumer(defNode, consumerFunction)) {
                 return;
             }
-            const fnNode = findObjectPropertyFunction(defNode.init, member.property.name);
+            const fnNode = findObjectPropertyFunction(holder, member.property.name);
             if (fnNode &&
                 isComponentLikeFunction(fnNode, context, member.property.name)) {
                 report(member, propName, member.property.name);

package/lib/rules/no-object-values-on-strings.js

@@ -68,18 +68,33 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                 node.callee.property.name === 'values' &&
                 node.arguments.length > 0);
         }
+        /**
+         * `a?.b()` parses as a ChainExpression wrapping the call. The wrapper is
+         * ESTree-only, so it has no TypeScript node: leaving it in place defeats
+         * both the syntactic tests below and `getTypeAtLocation`, and a nullable
+         * receiver is exactly where `?.` gets written.
+         */
+        function unwrapChain(node) {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                current = current.expression;
+            }
+            return current;
+        }
         /**
          * Checks if a node is a string literal or template literal
          */
         function isStringLiteral(node) {
-            return ((node.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value === 'string') ||
-                node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
+            const inner = unwrapChain(node);
+            return ((inner.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof inner.value === 'string') ||
+                inner.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
         /**
          * Checks if a node is likely to produce a string value based on AST patterns
          */
-        function isLikelyStringExpression(node) {
+        function isLikelyStringExpression(maybeChained) {
+            const node = unwrapChain(maybeChained);
             // Check for string concatenation
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
                 node.operator === '+' &&
@@ -190,8 +205,10 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
             CallExpression(node) {
                 // Check if the call is Object.values()
                 if (isObjectValuesCall(node)) {
-                    const argument = node.arguments[0];
-                    const argumentText = sourceCode.getText(argument);
+                    // The message quotes what the author wrote, so text comes from the
+                    // original node while every test below reads through the chain.
+                    const argumentText = sourceCode.getText(node.arguments[0]);
+                    const argument = unwrapChain(node.arguments[0]);
                     // Quick check for string literals and template literals
                     if (isStringLiteral(argument)) {
                         context.report({

package/lib/rules/no-passthrough-getters.js

@@ -421,8 +421,16 @@ exports.noPassthroughGetters = (0, createRule_1.createRule)({
             if (node.type === 'ConditionalExpression') {
                 return true;
             }
-            // Check for optional chaining like this.settings?.property
-            if (node.type === 'MemberExpression' && node.optional) {
+            // Check for optional chaining like this.settings?.property. `a?.b` parses
+            // as a ChainExpression wrapping the member access, so the wrapper has to
+            // be stripped here or this arm never fires — the shape stays silent only
+            // because the member walker cannot follow it, which would reverse the
+            // moment that walker learns to.
+            let unchained = node;
+            while (unchained.type === 'ChainExpression') {
+                unchained = unchained.expression;
+            }
+            if (unchained.type === 'MemberExpression' && unchained.optional) {
                 return true;
             }
             // The nullish coalescing check is already covered by the LogicalExpression check above

package/lib/rules/no-useless-usememo-primitives.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUselessUsememoPrimitives = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const tsTypeClassifier_1 = require("../utils/tsTypeClassifier");
 const DEFAULT_OPTIONS = {
     ignoreCallExpressions: true,
@@ -381,24 +382,44 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
                         valueKind,
                     },
                     fix(fixer) {
+                        const expressionText = sourceCode.getText(returnedExpression);
                         // Inlining replaces the entire useMemo(...) call with the returned
                         // expression's text, so any comment inside the call but outside
                         // that expression — an eslint-disable-next-line directive on the
                         // return statement among them — has no representation in the
-                        // replacement and would be silently destroyed, changing which
-                        // rules report on the file (#1591). The inlined expression lands
-                        // mid-line (e.g. `const label = <expr>;`), where a -next-line
-                        // directive cannot be hosted, so the autofix declines and leaves
-                        // the report for a manual fix.
+                        // replacement. Dropping one changes which rules report on the file
+                        // (#1591), and declining the fix whenever one is present makes a
+                        // comment decide whether the rule rewrites at all (#1877). Both are
+                        // avoided by carrying every such comment into the replacement,
+                        // where the directives among them keep the line relationship they
+                        // were written with.
                         const strandedComments = sourceCode
                             .getCommentsInside(node)
                             .filter((comment) => comment.range[0] < returnedExpression.range[0] ||
                             comment.range[1] > returnedExpression.range[1]);
-                        if (strandedComments.length > 0) {
-                            return null;
+                        if (strandedComments.length === 0) {
+                            return fixer.replaceText(node, `(${expressionText})`);
                         }
-                        const replacement = `(${sourceCode.getText(returnedExpression)})`;
-                        return fixer.replaceText(node, replacement);
+                        // A comment inside the call lies wholly on one side of the
+                        // expression, since a comment is a token and cannot straddle a
+                        // node; keeping each on its own side preserves what it annotates.
+                        const toSegment = (comment) => ({
+                            text: sourceCode.text.slice(comment.range[0], comment.range[1]),
+                            breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+                        });
+                        const isBefore = (comment) => comment.range[0] < returnedExpression.range[0];
+                        const segments = [
+                            ...strandedComments.filter(isBefore).map(toSegment),
+                            { text: expressionText, breakAfter: false },
+                            ...strandedComments
+                                .filter((comment) => !isBefore(comment))
+                                .map(toSegment),
+                        ];
+                        // The call can start mid-line, so the indentation of the line it
+                        // opens on is the only anchor the carried comments have.
+                        const startLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
+                        const indent = /^[\t ]*/.exec(startLine)?.[0] ?? '';
+                        return fixer.replaceText(node, (0, replacementSegments_1.joinSegments)(segments, indent));
                     },
                 });
             },