@blumintinc/eslint-plugin-blumint 1.20.134 → 1.20.136

package/lib/index.js

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

package/lib/rules/consistent-callback-naming.js

@@ -607,11 +607,27 @@ module.exports = (0, createRule_1.createRule)({
                             globalVar.references.forEach((ref) => references.add(ref));
                         }
                     }
+                    // A binding that leaves the module is one end of a cross-file
+                    // contract. Renaming `export const handleClick` to `click` strands
+                    // every `import { handleClick }` with TS2724, and a single-file fixer
+                    // cannot reach those importers — the same reasoning that already
+                    // withholds the JSX prop rename and the destructured one, which is
+                    // where `isExportedBinding` was first needed. The violation still
+                    // reports; only the rename is withheld.
+                    const declaredVariable = context
+                        .getDeclaredVariables(node)
+                        .find((v) => v.identifiers.includes(node.id));
+                    const leavesModule = declaredVariable
+                        ? isExportedBinding(declaredVariable)
+                        : isExportedDeclaration(node);
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',
                         data: { functionName },
                         fix(fixer) {
+                            if (leavesModule) {
+                                return null;
+                            }
                             // Remove 'handle' prefix and convert first character to lowercase
                             const newName = stripHandlePrefix(functionName);
                             // `const handleDelete = fn` would become `const delete = fn`,

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

@@ -256,6 +256,54 @@ function isNumericCall(node) {
         callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
         callee.object.name === 'Math');
 }
+/**
+ * The property names `assertSafe` exists to reject. A key that provably cannot
+ * spell one of these cannot reach the prototype surface, which is the entire
+ * hazard — so proving it is what earns an exemption, the same standard the
+ * numeric analysis already meets.
+ */
+const PROTOTYPE_REACHING_KEYS = ['__proto__', 'constructor', 'prototype'];
+/**
+ * Whether a template's FIXED text still leaves room to spell `target`.
+ *
+ * The producible set is `q0 + * + q1 + * + … + * + qN`, each `*` an arbitrary
+ * substitution. `target` is producible iff it starts with `q0`, ends with `qN`,
+ * and the interior quasis occur in order in between without overlapping. So
+ * `` `user-${id}` `` can never be `__proto__` (no such prefix) while
+ * `` `__pro${x}` `` can — with `x` = `'to__'`, which resolves to
+ * `Object.prototype` at runtime.
+ *
+ * Interior quasis are matched greedily from the left. That is sufficient
+ * because they are fixed strings: taking the earliest occurrence never consumes
+ * a character a later quasi needed, so no backtracking can succeed where the
+ * greedy pass fails.
+ *
+ * A template with no substitutions produces exactly one string and is a static
+ * key like any other string literal, so it is never treated as reaching.
+ */
+function templateCanSpell(quasis, target) {
+    if (quasis.length < 2) {
+        return false;
+    }
+    const first = quasis[0];
+    const last = quasis[quasis.length - 1];
+    if (!target.startsWith(first) || !target.endsWith(last)) {
+        return false;
+    }
+    const limit = target.length - last.length;
+    let cursor = first.length;
+    if (cursor > limit) {
+        return false;
+    }
+    for (const middle of quasis.slice(1, -1)) {
+        const at = target.indexOf(middle, cursor);
+        if (at < 0 || at + middle.length > limit) {
+            return false;
+        }
+        cursor = at + middle.length;
+    }
+    return true;
+}
 /**
  * A `: number` annotation on a binding name. Parameters and variable
  * declarators are the bindings that carry one, and TypeScript checks every
@@ -346,6 +394,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 +739,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
@@ -808,19 +1181,34 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        // Only flag simple template literals that are just `${id}`
-                        // Complex templates with additional text like `prefix_${id}_suffix` are allowed
+                        // A template whose every substitution is provably numeric can only
+                        // widen into digits, and no dangerous property name is the string
+                        // form of a number — the same proof the identifier path accepts.
+                        const canWidenToText = property.expressions.some((expr) => !isStaticallyNumeric(expr));
+                        const quasis = property.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw);
+                        const reachesPrototype = canWidenToText &&
+                            PROTOTYPE_REACHING_KEYS.some((key) => templateCanSpell(quasis, key));
+                        // Fixed text on either side of the substitution can rule a property
+                        // name out — `user-${id}` is never `__proto__` — and the rule skips
+                        // a key it can prove harmless. What it must NOT do is assume that:
+                        // `__pro${x}` carries fixed text too and still reaches the
+                        // prototype (#1880).
+                        if (!reachesPrototype) {
+                            return;
+                        }
+                        // `${id}` alone is the whole key, so the remedy names the inner
+                        // expression and the fix wraps it directly. A template carrying
+                        // fixed text has no such inner key — the string it builds is the
+                        // key — so that whole template is what gets wrapped, which is the
+                        // shape the docs show for `assertSafe(`${id}_suffix`)`.
                         const isSimpleVarInterpolation = property.expressions.length === 1 &&
                             property.quasis.length === 2 &&
                             property.quasis[0].value.raw === '' &&
                             property.quasis[1].value.raw === '';
-                        if (!isSimpleVarInterpolation) {
-                            // Complex template literals with additional text are fine
-                            return;
-                        }
-                        const expr = property.expressions[0];
-                        const exprText = context.sourceCode.getText(expr);
-                        reportWrittenKey(written, property, exprText);
+                        const unwrapped = isSimpleVarInterpolation
+                            ? property.expressions[0]
+                            : property;
+                        reportWrittenKey(written, property, context.sourceCode.getText(unwrapped));
                         return;
                     }
                     // Check for direct variable usage (identifiers)
@@ -838,6 +1226,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-props-argument-name.js

@@ -340,6 +340,33 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
             });
         }
+        /**
+         * The member name a `this.<x>` access reads, whatever its spelling.
+         *
+         * Keying the check on the dot spelling alone left `this['settings']`
+         * invisible, so the rename shipped and stranded it — the class no longer had
+         * the member the getter reads (#1881). A computed access with a static
+         * string is the SAME member as the dot form, and the fixer cannot rewrite it
+         * either, so it has to count. `null` marks a genuinely dynamic key, which
+         * names no member statically.
+         */
+        function staticMemberName(node) {
+            if (!node.computed) {
+                return node.property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? node.property.name
+                    : null;
+            }
+            if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.property.value === 'string') {
+                return node.property.value;
+            }
+            if (node.property.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                node.property.expressions.length === 0 &&
+                node.property.quasis.length === 1) {
+                return node.property.quasis[0].value.cooked;
+            }
+            return null;
+        }
         // Determine whether renaming a constructor parameter property is unsafe to
         // autofix. A parameter property (`private readonly foo: T`) creates BOTH a
         // constructor-local binding and a `this.foo` class field, so a
@@ -355,8 +382,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
                 if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
-                    node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.property.name === name) {
+                    staticMemberName(node) === name) {
                     unsafe = true;
                     return;
                 }