@blumintinc/eslint-plugin-blumint 1.15.0 → 1.16.0

package/lib/rules/no-margin-properties.js

@@ -67,7 +67,13 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
             const normalizedName = normalizePropertyName(propertyName);
             return MARGIN_PROPERTIES.has(normalizedName);
         }
-        // Check if a node is within an sx prop context or theme override context
+        /**
+         * True if node is in a flagged MUI styling context (sx attribute, sx
+         * object property, or css() call). Excludes createTheme styleOverrides:
+         * theme margins ARE the container-controlled styling (viewport insets,
+         * resets of MUI's built-in margins, internal layout), not the
+         * sibling-spacing this rule targets.
+         */
         function isMuiStylingContext(node) {
             let current = node;
             while (current?.parent) {
@@ -83,13 +89,6 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                     current.parent.key.name === 'sx') {
                     return true;
                 }
-                // Check for theme overrides (MUI's createTheme)
-                if (current.parent.type === utils_1.AST_NODE_TYPES.Property &&
-                    current.parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (current.parent.key.name === 'styleOverrides' ||
-                        current.parent.key.name === 'components')) {
-                    return true;
-                }
                 // Check for MUI's css function
                 if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
                     current.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -290,36 +289,6 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                         checkObjectExpression(arg);
                     }
                 }
-                // Handle createTheme for MUI theme overrides
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.name === 'createTheme' &&
-                    node.arguments.length > 0 &&
-                    node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    const themeObj = node.arguments[0];
-                    // Find components property in theme object
-                    const componentsProperty = themeObj.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        prop.key.name === 'components' &&
-                        prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression);
-                    if (componentsProperty &&
-                        componentsProperty.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        // Check each component override
-                        componentsProperty.value.properties.forEach((componentProp) => {
-                            if (componentProp.type === utils_1.AST_NODE_TYPES.Property &&
-                                componentProp.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                                // Find styleOverrides property
-                                const styleOverrides = componentProp.value.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    prop.key.name === 'styleOverrides' &&
-                                    prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression);
-                                if (styleOverrides &&
-                                    styleOverrides.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                                    checkObjectExpression(styleOverrides.value);
-                                }
-                            }
-                        });
-                    }
-                }
             },
         };
     },

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -63,6 +63,77 @@ const COMMON_PREPOSITION_SUFFIXES = new Set([
     'Async',
     'Sync',
 ]);
+/**
+ * Phrasal-verb particles that fuse with a preceding past participle to form an
+ * inseparable state adjective (e.g. "signed in", "logged in", "opted in",
+ * "logged out", "zoomed in"). When such a particle is the trailing suffix AND
+ * the token before it is a past participle, the ending is NOT a redundant
+ * verb-preposition action suffix — it is a single adjective describing state.
+ */
+const PHRASAL_PARTICLES = new Set(['In', 'On', 'Out', 'Up', 'Off', 'Down']);
+/**
+ * Verb stems that fuse with a phrasal particle into an established phrasal verb
+ * where the particle is inseparable (e.g. "signIn", "logOut", "optIn",
+ * "checkIn"). Matched in base form ("signIn", "useGuardSignIn") and
+ * past-participle form ("signedIn", "loggedOut", "droppedIn"). A particle
+ * preceded by a NOUN object instead — "searchItemsIn", "processEventOn",
+ * "loadEmbedIn", "isWidgetIn" — is a genuine redundant verb-preposition suffix
+ * and stays flagged. Extend this set when a new phrasal verb appears.
+ */
+const PHRASAL_VERB_STEMS = new Set([
+    'sign',
+    'log',
+    'opt',
+    'check',
+    'zoom',
+    'drop',
+    'shut',
+    'turn',
+    'switch',
+    'scroll',
+]);
+/**
+ * Resolves the lowercased phrasal-verb stem of a final camelCase word, or null
+ * when it is not a known phrasal verb. Handles the base form ("sign"), the
+ * regular past participle ("signed" → "sign"), and the doubled-consonant
+ * participle ("dropped" → "drop"). A noun that merely ends in "ed" (e.g.
+ * "embed" → "emb", "shed" → "sh") resolves to null, so it stays flagged — this
+ * is what keeps a leaky "ends in ed" heuristic from exempting genuine targets.
+ */
+function phrasalVerbStem(lastWord) {
+    const word = lastWord.toLowerCase();
+    if (PHRASAL_VERB_STEMS.has(word)) {
+        return word;
+    }
+    if (word.endsWith('ed')) {
+        let stem = word.slice(0, -2);
+        if (stem.length >= 2 && stem[stem.length - 1] === stem[stem.length - 2]) {
+            stem = stem.slice(0, -1);
+        }
+        if (PHRASAL_VERB_STEMS.has(stem)) {
+            return stem;
+        }
+    }
+    return null;
+}
+/**
+ * Returns true when the trailing `suffix` of `name` is a phrasal-verb particle
+ * fused to its verb — a past-participle adjective ("signedIn", "loggedOut") or a
+ * base-form phrasal verb ("signIn", "logOut"). The word immediately before the
+ * particle must be a KNOWN phrasal verb (via phrasalVerbStem), not merely any
+ * word ending in "ed"; that keeps redundant suffixes where a noun object
+ * precedes the particle ("loadEmbedIn", "isWidgetIn", "searchItemsIn") flagged.
+ * This single check also covers boolean predicates: "isSignedIn" resolves the
+ * pre-particle "signed" → "sign", while "isWidgetIn" resolves "widget" → null.
+ */
+function isPhrasalVerbEnding(name, suffix) {
+    if (!PHRASAL_PARTICLES.has(suffix)) {
+        return false;
+    }
+    const beforeSuffix = name.substring(0, name.length - suffix.length);
+    const lastWord = beforeSuffix.match(/[A-Z]?[a-z]+$/)?.[0] ?? '';
+    return phrasalVerbStem(lastWord) !== null;
+}
 exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
     name: 'no-unnecessary-verb-suffix',
     meta: {
@@ -94,6 +165,14 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                         // Skip if the suggestion would be empty or just a single character
                         if (suggestion.length <= 1)
                             continue;
+                        // Skip phrasal-verb endings (e.g. past-participle adjectives
+                        // "signedIn"/"loggedOut" or compound phrasal verbs "signIn"/
+                        // "logOut"): the trailing particle fuses with its verb, so stripping
+                        // it ("signed", "sign") destroys the meaning. The pre-particle word
+                        // must be a known phrasal verb, so noun-object endings like
+                        // "loadEmbedIn"/"isWidgetIn" remain flagged.
+                        if (isPhrasalVerbEnding(name, suffix))
+                            continue;
                         context.report({
                             node,
                             messageId: 'unnecessaryVerbSuffix',

package/lib/rules/no-unused-props.js

@@ -118,6 +118,45 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             }
             return null;
         };
+        /**
+         * Resolves the `*Props` type name from a parameter's type-annotation node.
+         * Unwraps parenthesized types and descends through generic wrapper type
+         * arguments (e.g. `Readonly<Foo>`, `Partial<...>`, `Readonly<Partial<Foo>>`)
+         * to find the underlying `*Props` reference. Returns the first `*Props`
+         * identifier found, or `null`. Uses the same `endsWith('Props')` heuristic
+         * as the direct path so forward-declared Props types still resolve.
+         */
+        const resolvePropsTypeName = (typeNode, visited = new Set()) => {
+            if (!typeNode || visited.has(typeNode)) {
+                return null;
+            }
+            visited.add(typeNode);
+            if (isTSParenthesizedType(typeNode)) {
+                return resolvePropsTypeName(typeNode.typeAnnotation, visited);
+            }
+            if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return null;
+            }
+            if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeNode.typeName.name.endsWith('Props')) {
+                return typeNode.typeName.name;
+            }
+            // Generic wrapper (Readonly/Partial/etc.): descend into its type arguments
+            // to find the nested *Props reference. typeParameters is the v5 AST shape;
+            // typeArguments is the v6+ shape — handle both for forward compatibility.
+            const typeArgs = typeNode.typeParameters ??
+                typeNode
+                    .typeArguments;
+            if (typeArgs) {
+                for (const arg of typeArgs.params) {
+                    const resolved = resolvePropsTypeName(arg, visited);
+                    if (resolved) {
+                        return resolved;
+                    }
+                }
+            }
+            return null;
+        };
         const isAnyPropFromSpreadTypeUsed = (spreadTypeName, used, knownProps) => {
             const spreadTypeProps = spreadTypeToPropNames.get(spreadTypeName);
             if (!spreadTypeProps || spreadTypeProps.size === 0) {
@@ -170,6 +209,131 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             }
             return false;
         };
+        /**
+         * Records which props an ObjectPattern consumes into `used`. A rest element
+         * (`...rest`) consumes all remaining props, so it flips `restUsed` and also
+         * marks spread-type keys used. Renamed bindings (`{ a: localA }`) still mark
+         * the original prop name `a`. Returns whether a rest element was present.
+         */
+        const collectUsedFromObjectPattern = (pattern, typeName, used) => {
+            let restUsed = false;
+            pattern.properties.forEach((prop) => {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                    const propName = getStaticPropName(prop.key);
+                    if (propName) {
+                        used.add(propName);
+                    }
+                }
+                else if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
+                    prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Rest spread (`{...rest}`): all remaining props are forwarded ⇒ used.
+                    // Spread-type markers are also flagged so the spread-forwarding skip
+                    // applies; remaining plain props are handled at report time via
+                    // `restUsed` (the props map may be incomplete here on forward refs).
+                    restUsed = true;
+                    const propsType = propsTypes.get(typeName);
+                    if (propsType) {
+                        Object.keys(propsType).forEach((key) => {
+                            if (key.startsWith('...')) {
+                                used.add(key);
+                            }
+                        });
+                    }
+                }
+            });
+            return restUsed;
+        };
+        /**
+         * Whether an Identifier node is a value-position *reference* to a variable
+         * (vs. a declaration binding, an object-property key, or the property of a
+         * member expression like `foo.paramName`). Used to detect opaque param use.
+         */
+        const isParamReference = (parent, parentKey) => {
+            if (!parent) {
+                return false;
+            }
+            // `foo.paramName` — the identifier is the member's property, not the param.
+            if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                parentKey === 'property' &&
+                !parent.computed) {
+                return false;
+            }
+            // Non-shorthand object property key: `{ paramName: x }`.
+            if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+                parentKey === 'key' &&
+                !parent.computed) {
+                return false;
+            }
+            // A binding position (declaration id, function param, etc.).
+            if ((parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parentKey === 'id') ||
+                parentKey === 'params') {
+                return false;
+            }
+            return true;
+        };
+        const collectBodyDestructuring = (body, paramName, typeName, used) => {
+            const result = {
+                destructureCount: 0,
+                restUsed: false,
+                hasOpaqueUsage: false,
+            };
+            const declaresParamName = (declarators) => declarators.some((d) => d.id.type === utils_1.AST_NODE_TYPES.Identifier && d.id.name === paramName);
+            /** Identifier nodes that are the `init` of a `const {} = props` declarator. */
+            const destructureInits = new Set();
+            const visit = (node, parent, parentKey) => {
+                if (!node || typeof node.type !== 'string') {
+                    return;
+                }
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                        node.init?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.init.name === paramName) {
+                        destructureInits.add(node.init);
+                        result.destructureCount += 1;
+                        if (collectUsedFromObjectPattern(node.id, typeName, used)) {
+                            result.restUsed = true;
+                        }
+                    }
+                }
+                // A bare reference to the param that is NOT a destructuring init is an
+                // opaque consumption (member access, spread, argument, return, etc.).
+                if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.name === paramName &&
+                    !destructureInits.has(node) &&
+                    isParamReference(parent, parentKey)) {
+                    result.hasOpaqueUsage = true;
+                }
+                // Stop descending into nested functions that re-bind `paramName`, since
+                // that shadowing binding refers to a different variable.
+                if ((node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                    node.params.some((p) => p.type === utils_1.AST_NODE_TYPES.Identifier && p.name === paramName)) {
+                    return;
+                }
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                    declaresParamName(node.declarations)) {
+                    // A `const <paramName> = ...` rebind shadows the param from here on.
+                    return;
+                }
+                for (const key of Object.keys(node)) {
+                    if (key === 'parent') {
+                        continue;
+                    }
+                    const value = node[key];
+                    if (Array.isArray(value)) {
+                        value.forEach((child) => visit(child, node, key));
+                    }
+                    else if (value &&
+                        typeof value.type === 'string') {
+                        visit(value, node, key);
+                    }
+                }
+            };
+            visit(body, null, null);
+            return result;
+        };
         const reportUnusedProps = (typeName, used, restUsed) => {
             const propsType = propsTypes.get(typeName);
             if (!propsType) {
@@ -190,6 +354,11 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                     if (isGenericTypeSpread(prop)) {
                         shouldReport = false;
                     }
+                    else if (restUsed) {
+                        // An explicit rest element (`{ a, ...rest }`) captures every prop not
+                        // named before it, so the remaining props are forwarded ⇒ used.
+                        shouldReport = false;
+                    }
                     else if (prop.startsWith('...')) {
                         shouldReport = !shouldSkipSpreadType(prop, hasRestSpread, used, knownProps);
                     }
@@ -590,45 +759,54 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                 }
             },
             VariableDeclaration(node) {
-                if (node.declarations.length === 1) {
-                    const declaration = node.declarations[0];
-                    if (declaration.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        const param = declaration.init.params[0];
-                        if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
-                            param.typeAnnotation?.typeAnnotation.type ===
-                                utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            param.typeAnnotation.typeAnnotation.typeName.type ===
-                                utils_1.AST_NODE_TYPES.Identifier) {
-                            const typeName = param.typeAnnotation.typeAnnotation.typeName.name;
-                            if (typeName.endsWith('Props')) {
-                                const used = new Set();
-                                let restUsed = false;
-                                param.properties.forEach((prop) => {
-                                    if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                                        const propName = getStaticPropName(prop.key);
-                                        if (propName) {
-                                            used.add(propName);
-                                        }
-                                    }
-                                    else if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
-                                        prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                        // Handle rest spread operator {...rest}
-                                        // When a rest operator is used, all remaining props are considered used
-                                        restUsed = true;
-                                        const propsType = propsTypes.get(typeName);
-                                        if (propsType) {
-                                            Object.keys(propsType).forEach((key) => {
-                                                if (key.startsWith('...')) {
-                                                    used.add(key);
-                                                }
-                                            });
-                                        }
-                                    }
-                                });
-                                currentComponent = { node, typeName, used, restUsed };
-                            }
+                if (node.declarations.length !== 1) {
+                    return;
+                }
+                const declaration = node.declarations[0];
+                if (declaration.init?.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return;
+                }
+                const fn = declaration.init;
+                const param = fn.params[0];
+                if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    // Resolve through generic wrappers (e.g. `Readonly<FooProps>`) as well
+                    // as the plain `FooProps` annotation.
+                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation);
+                    if (typeName) {
+                        const used = new Set();
+                        const restUsed = collectUsedFromObjectPattern(param, typeName, used);
+                        currentComponent = { node, typeName, used, restUsed };
+                    }
+                    return;
+                }
+                if (param?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Identifier param (`props: FooProps`): the destructuring happens in
+                    // the body. Resolve the Props type (unwrapping generic wrappers) and
+                    // scan the body for `const { ... } = props`.
+                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation);
+                    if (!typeName) {
+                        return;
+                    }
+                    const used = new Set();
+                    const { destructureCount, restUsed, hasOpaqueUsage } = collectBodyDestructuring(fn.body, param.name, typeName, used);
+                    // Only check when the body destructures the param at least once.
+                    // Member access (`props.x`), spread (`{...props}`), passing `props`
+                    // whole, or never referencing it (e.g. `_props`) is left to prior
+                    // behavior (no report) — those usages can't be enumerated reliably.
+                    if (destructureCount === 0) {
+                        return;
+                    }
+                    // Mixed usage (some destructure + opaque consumption) forwards the
+                    // remaining props, so treat every prop as used to avoid false reports.
+                    if (hasOpaqueUsage) {
+                        const propsType = propsTypes.get(typeName);
+                        if (propsType) {
+                            Object.keys(propsType).forEach((key) => used.add(key));
                         }
+                        currentComponent = { node, typeName, used, restUsed: true };
+                        return;
                     }
+                    currentComponent = { node, typeName, used, restUsed };
                 }
             },
             'VariableDeclaration:exit'(node) {

package/lib/rules/no-useless-fragment.js

@@ -13,8 +13,6 @@ const describeChild = (child) => {
             return 'JSX element';
         case 'JSXFragment':
             return 'fragment';
-        case 'JSXExpressionContainer':
-            return 'expression result';
         case 'JSXText':
             return 'text node';
         case 'JSXSpreadChild':
@@ -29,6 +27,16 @@ exports.noUselessFragment = {
             JSXFragment(node) {
                 if (node.children.length === 1) {
                     const [child] = node.children;
+                    /**
+                     * A fragment whose only child is an expression container — e.g.
+                     * `<>{portal}</>` — is NOT useless. Unwrapping it to a bare
+                     * `{portal}` is invalid in statement/return position, and wrapping a
+                     * single ReactNode expression in a fragment is the idiomatic way to
+                     * render it. (Mirrors the upstream rule's `allowExpressions`.)
+                     */
+                    if (child.type === 'JSXExpressionContainer') {
+                        return;
+                    }
                     context.report({
                         node,
                         messageId: 'noUselessFragment',

package/lib/rules/parallelize-async-operations.js

@@ -113,9 +113,7 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 }
                 // Skip non-shorthand keys in object literals as they are not value uses
                 if (parent && parent.type === utils_1.AST_NODE_TYPES.Property) {
-                    if (parent.key === node &&
-                        !parent.computed &&
-                        !parent.shorthand) {
+                    if (parent.key === node && !parent.computed && !parent.shorthand) {
                         return false;
                     }
                 }

package/lib/rules/prefer-type-alias-over-typeof-constant.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferTypeAliasOverTypeofConstant = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const PAREN_TYPE = utils_1.AST_NODE_TYPES.TSParenthesizedType ??
     'TSParenthesizedType';
 const isParenthesizedType = (node) => {
@@ -87,6 +88,71 @@ function collectReferencedTypeNames(node, acc = new Set()) {
                 collectReferencedTypeNames(e, acc);
             break;
         }
+        case utils_1.AST_NODE_TYPES.TSIndexedAccessType: {
+            const idx = node;
+            collectReferencedTypeNames(idx.objectType, acc);
+            collectReferencedTypeNames(idx.indexType, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSMappedType: {
+            const mapped = node;
+            if (mapped.typeAnnotation)
+                collectReferencedTypeNames(mapped.typeAnnotation, acc);
+            if (mapped.nameType)
+                collectReferencedTypeNames(mapped.nameType, acc);
+            if (mapped.typeParameter && mapped.typeParameter.constraint) {
+                collectReferencedTypeNames(mapped.typeParameter.constraint, acc);
+            }
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSConditionalType: {
+            const cond = node;
+            collectReferencedTypeNames(cond.checkType, acc);
+            collectReferencedTypeNames(cond.extendsType, acc);
+            collectReferencedTypeNames(cond.trueType, acc);
+            collectReferencedTypeNames(cond.falseType, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral: {
+            const lit = node;
+            for (const m of lit.members) {
+                if (m.type === utils_1.AST_NODE_TYPES.TSPropertySignature && m.typeAnnotation) {
+                    collectReferencedTypeNames(m.typeAnnotation.typeAnnotation, acc);
+                }
+                else if (m.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+                    if (m.returnType) {
+                        collectReferencedTypeNames(m.returnType.typeAnnotation, acc);
+                    }
+                    for (const p of m.params) {
+                        if (p.typeAnnotation) {
+                            collectReferencedTypeNames(p.typeAnnotation.typeAnnotation, acc);
+                        }
+                    }
+                }
+                else if (m.type === utils_1.AST_NODE_TYPES.TSIndexSignature) {
+                    if (m.typeAnnotation) {
+                        collectReferencedTypeNames(m.typeAnnotation.typeAnnotation, acc);
+                    }
+                    for (const p of m.parameters) {
+                        if (p.typeAnnotation) {
+                            collectReferencedTypeNames(p.typeAnnotation.typeAnnotation, acc);
+                        }
+                    }
+                }
+                else if (m.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration ||
+                    m.type === utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration) {
+                    if (m.returnType) {
+                        collectReferencedTypeNames(m.returnType.typeAnnotation, acc);
+                    }
+                    for (const p of m.params) {
+                        if (p.typeAnnotation) {
+                            collectReferencedTypeNames(p.typeAnnotation.typeAnnotation, acc);
+                        }
+                    }
+                }
+            }
+            break;
+        }
         default: {
             if (isParenthesizedType(node)) {
                 collectReferencedTypeNames(node.typeAnnotation, acc);
@@ -225,19 +291,15 @@ exports.preferTypeAliasOverTypeofConstant = (0, createRule_1.createRule)({
             TSTypeQuery(node) {
                 if (!collected)
                     return;
-                // Skip if inside a type alias declaration (Issue #1117)
+                const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
+                // Skip if inside a type alias declaration (Issue #1117, #1175)
                 // This allows 'type T = typeof CONST' as the canonical way to define the alias.
-                let current = node.parent;
-                while (current) {
-                    if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-                        return;
-                    }
-                    current = current.parent;
+                if (ancestors.some((a) => a.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration)) {
+                    return;
                 }
-                // Skip `keyof typeof X`
-                if (node.parent &&
-                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
-                    node.parent.operator === 'keyof') {
+                // Skip `keyof typeof X` as it's a canonical way to derive a union of keys from a constant object.
+                if (ancestors.some((a) => a.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                    a.operator === 'keyof')) {
                     return;
                 }
                 if (node.exprName.type !== utils_1.AST_NODE_TYPES.Identifier) {