@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.96

package/lib/rules/enforce-mui-rounded-icons.d.ts

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

package/lib/rules/enforce-mui-rounded-icons.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMuiRoundedIcons = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+const renameFixes_1 = require("../utils/renameFixes");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const MUI_ICONS_BARREL = '@mui/icons-material';
 const MUI_ICONS_DEEP_PREFIX = `${MUI_ICONS_BARREL}/`;
 /**
@@ -66,6 +68,52 @@ const toRoundedIconName = (iconName) => {
     }
     return `${baseIconName}Rounded`;
 };
+/** The icon a deep module path names, e.g. `AddReactionOutlined`. */
+const deepImportIconName = (source) => source.split('/').pop();
+/** The binding a deep import introduces for the icon its path names. */
+const deepImportBinding = (node) => {
+    const defaultSpecifier = node.specifiers.find((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+    return defaultSpecifier ? defaultSpecifier.local : null;
+};
+/**
+ * The Rounded names this declaration would give to *bindings* if its fix ran.
+ *
+ * Only a binding whose name is the icon name being replaced is ever renamed, so
+ * an aliased specifier — whose fix touches the imported name alone — claims no
+ * name here. Collected across the file so two variants of one icon
+ * (`PersonOutlined` and `PersonSharp`, both retargeting to `PersonRounded`) can
+ * be spotted before either fix runs: renaming both bindings would declare the
+ * same name twice.
+ */
+const claimedRoundedNames = (node) => {
+    if (node.source.type !== utils_1.AST_NODE_TYPES.Literal ||
+        typeof node.source.value !== 'string') {
+        return [];
+    }
+    const source = node.source.value;
+    if (source.startsWith(MUI_ICONS_DEEP_PREFIX)) {
+        const iconName = deepImportIconName(source);
+        const roundedVariant = iconName ? toRoundedIconName(iconName) : null;
+        const local = deepImportBinding(node);
+        return roundedVariant && local?.name === iconName ? [roundedVariant] : [];
+    }
+    if (source !== MUI_ICONS_BARREL || node.importKind === 'type') {
+        return [];
+    }
+    const claimed = [];
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+            specifier.importKind === 'type' ||
+            specifier.local.name !== specifier.imported.name) {
+            continue;
+        }
+        const roundedVariant = toRoundedIconName(specifier.imported.name);
+        if (roundedVariant) {
+            claimed.push(roundedVariant);
+        }
+    }
+    return claimed;
+};
 exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     name: 'enforce-mui-rounded-icons',
     meta: {
@@ -82,19 +130,124 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        /**
+         * Rounded names that more than one binding in the file would take. Renaming
+         * every claimant would declare the same name twice, so no claimant of a
+         * contested name is renamed.
+         */
+        const contestedNames = new Set();
+        /**
+         * Rewrites one reference to a renamed binding, or answers null when that
+         * site cannot be rewritten without changing more than the name.
+         */
+        const referenceRenameFixes = (fixer, referenceId, newName) => {
+            const parent = referenceId.parent;
+            // `export { PersonOutlined }` binds the module's public export name to
+            // this token, so renaming it would change an API contract whose importers
+            // a single-file fix cannot reach.
+            if (parent?.type === utils_1.AST_NODE_TYPES.ExportSpecifier) {
+                return null;
+            }
+            // A shorthand property is one token serving as both key and value:
+            // rewriting it renames the key too, and expanding it to `key: value`
+            // reshapes source the rule has no business reshaping.
+            if (parent?.type === utils_1.AST_NODE_TYPES.Property && parent.shorthand) {
+                return null;
+            }
+            // `<Icon.Sub />` and `<svg:icon />` name the binding through a compound
+            // tag whose closing half is not a scope reference, so the two tags cannot
+            // be kept in sync from here.
+            if (parent?.type === utils_1.AST_NODE_TYPES.JSXMemberExpression ||
+                parent?.type === utils_1.AST_NODE_TYPES.JSXNamespacedName) {
+                return null;
+            }
+            const fix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, referenceId, newName);
+            if (!fix) {
+                return null;
+            }
+            if (parent?.type !== utils_1.AST_NODE_TYPES.JSXOpeningElement ||
+                parent.name !== referenceId) {
+                return [fix];
+            }
+            // The scope manager records the opening tag's name as a reference but not
+            // the closing tag's, so renaming the opening half alone would leave
+            // `<PersonRounded></PersonOutlined>` — code that no longer parses.
+            const element = parent.parent;
+            const closingName = element?.type === utils_1.AST_NODE_TYPES.JSXElement
+                ? element.closingElement?.name
+                : undefined;
+            if (!closingName) {
+                return [fix];
+            }
+            // JSX requires the closing name to spell the opening one, so its first
+            // token is the same name this rename replaces.
+            const closingFix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, closingName, newName);
+            return closingFix ? [fix, closingFix] : null;
+        };
+        /**
+         * Builds the rewrites that rename the binding an icon import introduces:
+         * the declaring token(s) plus every in-file reference to it.
+         *
+         * Answers null when the rename cannot be applied everywhere — the caller
+         * then keeps the retarget that leaves the binding alone, or reports without
+         * a fix where no such retarget exists.
+         */
+        const bindingRenameFixes = (fixer, declaration, localIdentifier, declarationTokens, newName) => {
+            if (contestedNames.has(newName)) {
+                return null;
+            }
+            // Resolved by declaration identity rather than by name: a file may bind
+            // the same name in several scopes, and only this declaration's symbol
+            // carries the references the fix has to rewrite.
+            const variable = ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, declaration).find((candidate) => candidate.defs.some((def) => def.name === localIdentifier));
+            if (!variable || (0, renameFixes_1.renameWouldCollide)(variable, newName)) {
+                return null;
+            }
+            const fixes = [];
+            for (const token of declarationTokens) {
+                const fix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, token, newName);
+                if (!fix) {
+                    return null;
+                }
+                fixes.push(fix);
+            }
+            for (const reference of variable.references) {
+                if (reference.identifier === localIdentifier) {
+                    continue;
+                }
+                const referenceFixes = referenceRenameFixes(fixer, reference.identifier, newName);
+                if (!referenceFixes) {
+                    return null;
+                }
+                fixes.push(...referenceFixes);
+            }
+            return fixes;
+        };
         /** `import LogoutIcon from '@mui/icons-material/Logout'` — the icon is named by the module path. */
         const checkDeepImport = (node, iconPath) => {
-            const iconName = iconPath.split('/').pop();
+            const iconName = deepImportIconName(iconPath);
             const roundedVariant = iconName ? toRoundedIconName(iconName) : null;
             if (!roundedVariant) {
                 return;
             }
+            const local = deepImportBinding(node);
+            // A hand-chosen alias (`import BellIcon from '.../NotificationsActive'`)
+            // names the icon's role, not its variant, so only a binding that repeats
+            // the icon name is renamed with the path.
+            const renamedBinding = local?.name === iconName ? local : null;
             context.report({
                 node,
                 messageId: 'enforceRoundedVariant',
-                // The local binding is untouched: only the module the icon comes from
-                // changes.
-                fix: (fixer) => fixer.replaceText(node.source, `'${MUI_ICONS_DEEP_PREFIX}${roundedVariant}'`),
+                fix: (fixer) => {
+                    const pathFix = fixer.replaceText(node.source, `'${MUI_ICONS_DEEP_PREFIX}${roundedVariant}'`);
+                    const renameFixes = renamedBinding
+                        ? bindingRenameFixes(fixer, node, renamedBinding, [renamedBinding], roundedVariant)
+                        : null;
+                    // Path and binding move together: one fixer emits both, so a binding
+                    // rename can never land without the retarget that motivates it.
+                    return renameFixes ? [pathFix, ...renameFixes] : pathFix;
+                },
             });
         };
         /** `import { Logout } from '@mui/icons-material'` — the icon is named by each specifier. */
@@ -116,22 +269,50 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
                     continue;
                 }
                 // An alias keeps the local binding independent of the imported name, so
-                // swapping the imported name is a self-contained edit. Without one, a
-                // fix would rename the binding and would have to rewrite every
-                // reference to it (shorthand properties, export specifiers, JSX) — so
-                // that form is reported without a fix rather than risking a corrupting
-                // edit.
-                const isAliased = specifier.local.name !== importedName;
+                // swapping the imported name is a self-contained edit that leaves the
+                // binding — and every reference to it — alone.
+                if (specifier.local.name !== importedName) {
+                    context.report({
+                        node: specifier,
+                        messageId: 'enforceRoundedVariant',
+                        fix: (fixer) => fixer.replaceText(specifier.imported, roundedVariant),
+                    });
+                    continue;
+                }
+                // Without an alias the imported name IS the local binding, so changing
+                // it renames the binding: the fix must own every reference to it or not
+                // exist at all. `import { Logout }` spells the imported name and the
+                // local one with a single token, which is rewritten once; the redundant
+                // `import { Logout as Logout }` spells them separately, so both move.
+                const declarationTokens = specifier.imported.range[0] === specifier.local.range[0]
+                    ? [specifier.local]
+                    : [specifier.imported, specifier.local];
                 context.report({
                     node: specifier,
                     messageId: 'enforceRoundedVariant',
-                    fix: isAliased
-                        ? (fixer) => fixer.replaceText(specifier.imported, roundedVariant)
-                        : null,
+                    fix: (fixer) => bindingRenameFixes(fixer, node, specifier.local, declarationTokens, roundedVariant),
                 });
             }
         };
         return {
+            // Every import is a top-level statement, so the names the file's fixes
+            // would introduce are all knowable before the first report.
+            Program(node) {
+                const claimCounts = new Map();
+                for (const statement of node.body) {
+                    if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                        continue;
+                    }
+                    for (const claimed of claimedRoundedNames(statement)) {
+                        claimCounts.set(claimed, (claimCounts.get(claimed) ?? 0) + 1);
+                    }
+                }
+                for (const [name, count] of claimCounts) {
+                    if (count > 1) {
+                        contestedNames.add(name);
+                    }
+                }
+            },
             ImportDeclaration(node) {
                 if (node.source.type !== utils_1.AST_NODE_TYPES.Literal ||
                     typeof node.source.value !== 'string') {

package/lib/rules/generic-starts-with-t.js

@@ -2,10 +2,59 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.genericStartsWithT = void 0;
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * A module augmentation targets either an external module
+ * (`declare module 'pkg'`, whose id is a string literal) or the global scope
+ * (`declare global`). TypeScript requires every declaration of a merged entity
+ * to spell its type parameters identically (TS2428, "All declarations of 'X'
+ * must have identical type parameters"), so the name inside an augmentation is
+ * fixed by the upstream declaration rather than chosen by the author. Renaming
+ * it to satisfy the convention breaks the merge.
+ *
+ * A plain `namespace X` — including the ambient `declare namespace X` and
+ * `declare module Foo`, both of which carry an identifier id — augments nothing
+ * upstream, so its type parameters stay author-owned and reportable.
+ */
+function isModuleAugmentation(node) {
+    if (node.id.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.id.value === 'string') {
+        return true;
+    }
+    // `declare global` carries a dedicated flag, which also covers the bare
+    // `global { ... }` form nested inside an ambient module (that form has no
+    // `declare` of its own).
+    if (node.global === true) {
+        return true;
+    }
+    // Parser versions that predate the `global` flag spell the same block as an
+    // ambient module whose id is the `global` keyword. Requiring `declare` keeps
+    // an ordinary `namespace global { ... }` reportable.
+    return (node.declare === true &&
+        node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.id.name === 'global');
+}
+/**
+ * The declaration need not be a direct child of the augmentation block; it can
+ * sit inside a nested namespace, an interface member signature or any other
+ * container within it, so the whole ancestor chain is inspected.
+ */
+function isInsideModuleAugmentation(node) {
+    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+        if (ancestor.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+            isModuleAugmentation(ancestor)) {
+            return true;
+        }
+    }
+    return false;
+}
 exports.genericStartsWithT = (0, createRule_1.createRule)({
     create(context) {
         return {
             TSTypeParameterDeclaration(node) {
+                if (isInsideModuleAugmentation(node)) {
+                    return;
+                }
                 for (const param of node.params) {
                     if (typeof param.name.name === 'string' &&
                         param.name.name[0] !== 'T') {

package/lib/rules/global-const-style.js

@@ -23,6 +23,28 @@ const toUpperSnakeCase = (name) => name
     .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
     .toUpperCase()
     .replace(/^_/, '');
+// `x as T`, `<T>x`, `x satisfies T` and `x!` annotate or assert an expression
+// without contributing a value of their own, so a check that classifies the
+// *shape* of an initializer must look through all four alike. Recognizing only
+// some of them makes the rule's carve-outs depend on which type syntax an
+// author happened to reach for: a React component written
+// `memo(Foo) satisfies ComponentType` or `memo(Foo)!` read as opaque
+// expressions and were renamed to UPPER_SNAKE_CASE while `memo(Foo) as FC` was
+// exempt (Issue #1681).
+const VALUE_WRAPPER_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+const isValueWrapper = (node) => VALUE_WRAPPER_TYPES.has(node.type);
+const unwrapValueWrappers = (node) => {
+    let target = node;
+    while (isValueWrapper(target)) {
+        target = target.expression;
+    }
+    return target;
+};
 // Jest mock handles produced by an `as` cast to a `jest.Mock*` type are
 // stateful test doubles that are reassigned/mutated through
 // `.mockImplementation()`, `.mockReturnValue()`, etc. They are not immutable
@@ -38,11 +60,7 @@ const JEST_MOCK_TYPE_NAMES = new Set([
 // `jest.Mocked<...>` / `jest.MockedClass<...>`. The match is kept deliberately
 // narrow — a qualified `jest.<MockType>` type reference — so unrelated `as`
 // casts keep triggering the rename check.
-const isJestMockCast = (node) => {
-    if (node.type !== utils_1.AST_NODE_TYPES.TSAsExpression) {
-        return false;
-    }
-    const typeAnnotation = node.typeAnnotation;
+const isJestMockTypeReference = (typeAnnotation) => {
     if (typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
         return false;
     }
@@ -53,6 +71,43 @@ const isJestMockCast = (node) => {
         typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
         JEST_MOCK_TYPE_NAMES.has(typeName.right.name));
 };
+// The cast can sit anywhere in a wrapper chain (`(foo as jest.Mock)!`,
+// `foo as jest.Mock satisfies unknown`), so the whole chain is scanned rather
+// than the outermost node alone — a mock handle stays a mock handle whatever is
+// wrapped around the cast.
+const isJestMockCast = (node) => {
+    let current = node;
+    while (isValueWrapper(current)) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+            isJestMockTypeReference(current.typeAnnotation)) {
+            return true;
+        }
+        current = current.expression;
+    }
+    return false;
+};
+// React's component factories, called bare (`memo(Foo)`) or through a namespace
+// import (`React.memo(Foo)`).
+const COMPONENT_FACTORY_NAMES = new Set(['forwardRef', 'memo']);
+const isComponentFactoryCall = (node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    const { callee } = node;
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_FACTORY_NAMES.has(callee.name);
+    }
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        COMPONENT_FACTORY_NAMES.has(callee.property.name));
+};
+// A function value is a component, hook or helper, never the module-level
+// configuration value this rule governs. The two spellings are interchangeable
+// at a declaration site, so `const Row = function (props) {...}` is exempt on
+// the same terms as `const Row = (props) => {...}` (Issue #1681).
+const isFunctionValue = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
 /**
  * Walks the scope chain upward from `scope` (inclusive) and reports whether
  * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
@@ -141,7 +196,16 @@ exports.default = (0, createRule_1.createRule)({
         // Check if the file is a TypeScript file
         const isTypeScript = context.getFilename().endsWith('.ts') ||
             context.getFilename().endsWith('.tsx');
-        const unwrapAssertions = (node) => {
+        /**
+         * Strips `as`/`<T>` casts only, and is deliberately narrower than
+         * `unwrapValueWrappers`. The two carve-outs below — dynamic values and
+         * binding aliases — silence the rule entirely, so widening them to see
+         * through `!`/`satisfies` would newly exempt `const value = getValue()!`
+         * and `const alias = other!` from the rename check. That is a detection
+         * change of its own, distinct from the wrapper-blind component exemption
+         * `unwrapValueWrappers` cures (Issue #1681).
+         */
+        const unwrapCasts = (node) => {
             let target = node;
             while (target.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
                 target.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
@@ -150,7 +214,7 @@ exports.default = (0, createRule_1.createRule)({
             return target;
         };
         const isDynamicValue = (node) => {
-            const target = unwrapAssertions(node);
+            const target = unwrapCasts(node);
             if (target.type === utils_1.AST_NODE_TYPES.CallExpression ||
                 target.type === utils_1.AST_NODE_TYPES.NewExpression ||
                 target.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
@@ -174,18 +238,18 @@ exports.default = (0, createRule_1.createRule)({
          * such a re-export is preserving a name importers depend on and a
          * single-file fixer cannot rewrite them (Issue #1418).
          *
-         * The check unwraps assertions so a type-pinned alias (`x as Foo`,
+         * The check unwraps casts so a type-pinned alias (`x as Foo`,
          * `x as const`) is treated the same as the bare form. A `MemberExpression`
          * (`Foo.bar`) is deliberately not covered — it keeps whatever behavior
          * `isDynamicValue` already gives it.
          */
         const isBindingAlias = (node) => {
-            const target = unwrapAssertions(node);
+            const target = unwrapCasts(node);
             return (target.type === utils_1.AST_NODE_TYPES.Identifier &&
                 !PRIMITIVE_VALUE_GLOBALS.has(target.name));
         };
         const describeValueKind = (node) => {
-            const target = unwrapAssertions(node);
+            const target = unwrapValueWrappers(node);
             if (target.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
                 return 'an array literal';
             }
@@ -208,41 +272,22 @@ exports.default = (0, createRule_1.createRule)({
                     node.parent?.type !== utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
                     return;
                 }
-                // Skip if any declaration is a function component, arrow function, forwardRef, or memo
+                // Skip if any declaration is a function value (component, hook or
+                // helper) or a `memo`/`forwardRef` component factory call. The
+                // initializer is classified through any type wrappers, so the pinned
+                // forms (`… as FC`, `… satisfies ComponentType`, `…!`) are exempt on
+                // the same terms as the bare expression they wrap.
                 const shouldSkip = node.declarations.some((declaration) => {
                     if (declaration.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
                         return false;
                     }
-                    const name = declaration.id.name;
                     const init = declaration.init;
                     // Skip if no initializer
                     if (!init) {
                         return false;
                     }
-                    // Skip function components (uppercase name + arrow function)
-                    if (/^[A-Z]/.test(name) &&
-                        init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        return true;
-                    }
-                    // Skip any arrow function
-                    if (init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        return true;
-                    }
-                    // Skip forwardRef and memo calls
-                    if (init.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        if (init.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            return ['forwardRef', 'memo'].includes(init.callee.name);
-                        }
-                    }
-                    // Skip type assertions on forwardRef and memo calls
-                    if (init.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
-                        const expression = init.expression;
-                        if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                            expression.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            return ['forwardRef', 'memo'].includes(expression.callee.name);
-                        }
-                    }
-                    return false;
+                    const target = unwrapValueWrappers(init);
+                    return isFunctionValue(target) || isComponentFactoryCall(target);
                 });
                 if (shouldSkip) {
                     return;
@@ -267,15 +312,19 @@ exports.default = (0, createRule_1.createRule)({
                         : '';
                     // Only check for as const in TypeScript files
                     if (isTypeScript) {
+                        // An `as const` anywhere in the wrapper chain already freezes the
+                        // value, including when a later wrapper hides it
+                        // (`{...} as const satisfies Config`, `({...} as const)!`).
                         const hasAsConstAssertion = (node) => {
                             let current = node;
-                            while (current &&
-                                (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-                                    current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion)) {
-                                const { typeAnnotation } = current;
-                                if (typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                                    typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    typeAnnotation.typeName.name === 'const') {
+                            while (isValueWrapper(current)) {
+                                if ((current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                                    current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) &&
+                                    current.typeAnnotation.type ===
+                                        utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                    current.typeAnnotation.typeName.type ===
+                                        utils_1.AST_NODE_TYPES.Identifier &&
+                                    current.typeAnnotation.typeName.name === 'const') {
                                     return true;
                                 }
                                 current = current.expression;
@@ -287,14 +336,15 @@ exports.default = (0, createRule_1.createRule)({
                             if (hasAsConstAssertion(node)) {
                                 return false;
                             }
-                            const target = unwrapAssertions(node);
-                            // Skip an initializer already wrapped in a non-`const` assertion
-                            // (`{...} as T`, `<T>{...}`, `{...} as unknown as T`). A `const`
-                            // assertion may only be applied to a literal, so appending one
-                            // after an assertion chain is TS1355 — the same failure mode the
-                            // regex/null/boolean carve-outs below exist for. Such a cast is
-                            // also the author pinning the type deliberately, exactly like the
-                            // `id.typeAnnotation` case skipped next.
+                            const target = unwrapValueWrappers(node);
+                            // Skip an initializer already wrapped in a non-`const` type
+                            // wrapper (`{...} as T`, `<T>{...}`, `{...} as unknown as T`,
+                            // `{...} satisfies T`, `{...}!`). A `const` assertion may only be
+                            // applied to a literal, so appending one after such a chain is
+                            // TS1355 — the same failure mode the regex/null/boolean carve-outs
+                            // below exist for. Such a wrapper is also the author pinning the
+                            // type deliberately, exactly like the `id.typeAnnotation` case
+                            // skipped next.
                             if (target !== node) {
                                 return false;
                             }