@blumintinc/eslint-plugin-blumint 1.20.115 → 1.20.117

package/lib/index.js

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

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -11,6 +11,93 @@ exports.enforceFirestoreDocRefGeneric = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+/** The Firestore reference types that carry a document-shape generic. */
+const REFERENCE_TYPE_NAMES = new Set([
+    'DocumentReference',
+    'CollectionReference',
+    'CollectionGroup',
+]);
+/**
+ * The final segment of a type reference's name, so `FirebaseFirestore.
+ * DocumentReference` is recognized as the same type as `DocumentReference`.
+ *
+ * The rightmost segment is the right granularity because the namespace is
+ * arbitrary — `FirebaseFirestore.`, `admin.firestore.` and any
+ * `import * as fs from 'firebase-admin/firestore'` alias all name these types —
+ * while the names themselves are specific enough that an unrelated module's
+ * `DocumentReference` is not a realistic collision.
+ */
+const referenceTypeNameOf = (typeName) => {
+    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return REFERENCE_TYPE_NAMES.has(typeName.name) ? typeName.name : undefined;
+    }
+    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
+        typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+        REFERENCE_TYPE_NAMES.has(typeName.right.name)) {
+        return typeName.right.name;
+    }
+    return undefined;
+};
+/** Statement containers a type declaration can be a direct child of. */
+function statementsOf(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.Program:
+        case utils_1.AST_NODE_TYPES.BlockStatement:
+        case utils_1.AST_NODE_TYPES.TSModuleBlock:
+        case utils_1.AST_NODE_TYPES.StaticBlock:
+            return node.body;
+        case utils_1.AST_NODE_TYPES.SwitchCase:
+            return node.consequent;
+        default:
+            return undefined;
+    }
+}
+/**
+ * The type declaration a statement makes, looking through `export`.
+ *
+ * `export type User = ...` is the same declaration one AST node deeper, inside
+ * an `ExportNamedDeclaration`. Reading the statement without unwrapping makes
+ * the `export` keyword alone decide whether a schema is checked, which is not a
+ * distinction the document shape knows anything about.
+ */
+function typeDeclarationNamed(statement, name) {
+    const declared = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+        statement.declaration
+        ? statement.declaration
+        : statement;
+    if ((declared.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+        declared.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) &&
+        declared.id.name === name) {
+        return declared;
+    }
+    return undefined;
+}
+/**
+ * Resolves a type name against every enclosing statement container, innermost
+ * outward, so the nearest declaration shadows a same-named outer one.
+ *
+ * Searching `Program.body` alone left the two commonest spellings unresolvable:
+ * an exported declaration sits inside its `export` statement, and a declaration
+ * written in a function body, block, or namespace sits inside that. Since an
+ * unresolved name is treated as carrying no readable members, the hole silently
+ * dropped the nested-`any` check rather than reporting anything.
+ */
+function declarationOfType(from, name) {
+    let current = from;
+    while (current) {
+        const statements = statementsOf(current);
+        if (statements) {
+            for (const statement of statements) {
+                const declaration = typeDeclarationNamed(statement, name);
+                if (declaration) {
+                    return declaration;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
 /**
  * @type {import('eslint').Rule.RuleModule}
  */
@@ -48,7 +135,13 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const typeCache = new Map();
+        /**
+         * Keyed on the resolved declaration rather than on the name, because
+         * resolution is lexical: two scopes in one file may declare the same name
+         * with different fields, and a name-keyed answer would carry one scope's
+         * verdict into the other.
+         */
+        const declarationCache = new WeakMap();
         const nodeCache = new WeakMap();
         function hasInvalidType(node) {
             if (!node)
@@ -66,19 +159,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         return node.typeParameters.params.some(hasInvalidType);
                     }
                     if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const typeName = node.typeName.name;
-                        if (typeCache.has(typeName)) {
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            return typeCache.get(typeName);
-                        }
-                        // Prevent infinite recursion
-                        typeCache.set(typeName, false);
-                        const members = declaredMembersOf(typeName);
-                        if (members) {
-                            const result = membersHaveInvalidType(members);
-                            typeCache.set(typeName, result);
-                            return result;
-                        }
+                        return declaredTypeHasInvalidType(node.typeName);
                     }
                     return false;
                 case utils_1.AST_NODE_TYPES.TSIntersectionType:
@@ -155,8 +236,8 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                 : undefined;
         }
         /**
-         * Resolves a named generic to the members its declaration lists, reading an
-         * interface and a type alias alike.
+         * The members a declaration lists, reading an interface and a type alias
+         * alike.
          *
          * The alias spelling is not an extra convenience: `prefer-type-over-interface`
          * ships in the same recommended config and is fixable, so a single
@@ -165,18 +246,36 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
          * has run the config, and a nested `any` in a document schema goes
          * unreported.
          */
-        function declaredMembersOf(typeName) {
-            for (const statement of context.sourceCode.ast.body) {
-                if (statement.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
-                    statement.id.name === typeName) {
-                    return statement.body.body;
-                }
-                if (statement.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
-                    statement.id.name === typeName) {
-                    return aliasedTypeLiteral(statement.typeAnnotation)?.members;
-                }
+        function declaredMembersOf(declaration) {
+            return declaration.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration
+                ? declaration.body.body
+                : aliasedTypeLiteral(declaration.typeAnnotation)?.members;
+        }
+        /**
+         * Reports whether the type a name stands for declares a field this rule
+         * rejects, resolving the name from the reference site outward.
+         *
+         * The declaration doubles as the recursion guard: a self-referential schema
+         * such as `type Node = { child: Node }` reaches its own entry, which is
+         * seeded `false` before its members are read.
+         */
+        function declaredTypeHasInvalidType(typeName) {
+            const declaration = declarationOfType(typeName, typeName.name);
+            if (!declaration) {
+                return false;
             }
-            return undefined;
+            const cached = declarationCache.get(declaration);
+            if (cached !== undefined) {
+                return cached;
+            }
+            declarationCache.set(declaration, false);
+            const members = declaredMembersOf(declaration);
+            if (!members) {
+                return false;
+            }
+            const result = membersHaveInvalidType(members);
+            declarationCache.set(declaration, result);
+            return result;
         }
         function hasTypeAnnotation(node) {
             if (nodeCache.has(node)) {
@@ -655,11 +754,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
         }
         function hasCollectionReferenceType(typeNode) {
             if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                ((typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    typeNode.typeName.name === 'CollectionReference') ||
-                    (typeNode.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
-                        typeNode.typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        typeNode.typeName.right.name === 'CollectionReference')) &&
+                referenceTypeNameOf(typeNode.typeName) === 'CollectionReference' &&
                 typeNode.typeParameters &&
                 typeNode.typeParameters.params.length > 0) {
                 return true;
@@ -860,11 +955,8 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
         }
         return {
             TSTypeReference(node) {
-                if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (node.typeName.name === 'DocumentReference' ||
-                        node.typeName.name === 'CollectionReference' ||
-                        node.typeName.name === 'CollectionGroup')) {
-                    const typeName = node.typeName.name;
+                const typeName = referenceTypeNameOf(node.typeName);
+                if (typeName) {
                     // Check if generic type argument is missing
                     if (!node.typeParameters || node.typeParameters.params.length === 0) {
                         context.report({

package/lib/rules/enforce-firestore-set-merge.js

@@ -192,6 +192,68 @@ function isPrimitiveLiteral(node) {
         typeof value === 'boolean' ||
         typeof value === 'bigint');
 }
+/** Statement containers a declaration can be a direct child of. */
+function statementsOf(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.Program:
+        case utils_1.AST_NODE_TYPES.BlockStatement:
+        case utils_1.AST_NODE_TYPES.TSModuleBlock:
+        case utils_1.AST_NODE_TYPES.StaticBlock:
+            return node.body;
+        case utils_1.AST_NODE_TYPES.SwitchCase:
+            return node.consequent;
+        default:
+            return undefined;
+    }
+}
+/** Whether a declarator is initialized from a `<x>.firestore()` call. */
+function initializesFirestore(declarator) {
+    const { init } = declarator;
+    return (init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        init.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        init.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        init.callee.property.name === 'firestore');
+}
+/**
+ * Whether a statement declares a Firestore instance, looking through `export`.
+ *
+ * `export const db = admin.firestore()` is the same declaration one AST node
+ * deeper, inside an `ExportNamedDeclaration`. Reading the statement without
+ * unwrapping makes the `export` keyword alone decide whether the file's
+ * Firestore evidence is visible, which is not a distinction a `db` handle knows
+ * anything about — `classBodiesByName()` already unwraps it for the same
+ * "find the in-file declaration that carries the evidence" purpose.
+ */
+function declaresFirestoreInstance(statement) {
+    const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+        statement.declaration
+        ? statement.declaration
+        : statement;
+    return (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+        declaration.declarations.some(initializesFirestore));
+}
+/**
+ * Whether the file itself proves Firestore is in play at the call site, by
+ * searching every enclosing statement container innermost outward.
+ *
+ * Scanning `Program.body` alone left both commonplace spellings invisible: a
+ * `const db = admin.firestore()` written inside the handler that uses it, and an
+ * exported one, which sits inside its `export` statement. Since this scan is the
+ * only detector left for a bare-identifier receiver, the hole silently dropped
+ * the report rather than producing a wrong one. A container without the evidence
+ * falls through to the next one out instead of answering for the whole chain.
+ */
+function hasFirestoreInstanceInScope(node) {
+    let current = node;
+    while (current) {
+        const statements = statementsOf(current);
+        if (statements?.some(declaresFirestoreInstance)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     name: 'enforce-firestore-set-merge',
     meta: {
@@ -397,25 +459,9 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                             object.name === 'transaction') {
                             return true;
                         }
-                        // Check if it's a Firestore document reference by looking at imports
-                        const program = ASTHelpers_1.ASTHelpers.getAncestors(context, node).find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
-                        if (program) {
-                            for (const node of program.body) {
-                                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
-                                    for (const decl of node.declarations) {
-                                        if (decl.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                                            decl.init.callee.type ===
-                                                utils_1.AST_NODE_TYPES.MemberExpression &&
-                                            decl.init.callee.property.type ===
-                                                utils_1.AST_NODE_TYPES.Identifier &&
-                                            decl.init.callee.property.name === 'firestore') {
-                                            return true;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        return false;
+                        // Check if it's a Firestore document reference by looking for the
+                        // file's own `<x>.firestore()` handle, wherever it is declared.
+                        return hasFirestoreInstanceInScope(node);
                     }
                     return false;
                 }

package/lib/rules/enforce-render-hits-memoization.js

@@ -5,6 +5,34 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const LATEST_CALLBACK_MODULE = 'use-latest-callback';
 const LATEST_CALLBACK_HOOK = 'useLatestCallback';
+function isFunctionNode(node) {
+    if (!node)
+        return false;
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
+}
+/**
+ * Nearest enclosing function of a node, or `null` when the node sits at module
+ * scope. Class and object methods are reached through their `FunctionExpression`
+ * value, so no separate `MethodDefinition` case is needed.
+ *
+ * The walk starts at the parent, so a `FunctionDeclaration` passed in as the
+ * declaration site reports the function that CONTAINS it rather than itself.
+ */
+function getEnclosingFunction(node) {
+    let current = node.parent;
+    while (current) {
+        if (isFunctionNode(current)) {
+            return current;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.Program) {
+            return null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
 /**
  * Declaration forms whose binding is created once for the program's lifetime.
  *
@@ -28,6 +56,32 @@ function isStableDeclaration(def) {
             return false;
     }
 }
+/**
+ * The hazard is identity churn measured against the CONSUMER, not absolute
+ * scope depth: `useRenderHits` only ever sees a new identity when the function
+ * that CALLS it re-runs and rebuilds the binding on the way. That holds exactly
+ * when the declaration and the call share a nearest enclosing function.
+ *
+ * When the declaration sits in a strictly outer function — a component factory,
+ * an HOC, a `describe` callback consumed from a nested `it` — the binding is
+ * created once per outer call and the calling function is created in that same
+ * call, so every run of the consumer sees the identical reference. The message's
+ * remedy is also unavailable there: `useCallback` cannot legally be called in a
+ * function that is neither a component nor a hook, and a helper closing over an
+ * outer parameter cannot be hoisted to module scope. Module scope is the
+ * degenerate case: the declaration has no enclosing function at all.
+ *
+ * Scope resolution guarantees the declaration's scope is on the consumer's scope
+ * chain, so "not the same function" and "strictly encloses" coincide here.
+ *
+ * A custom hook is deliberately NOT special-cased. A hook body does re-run per
+ * render, and when it also holds the `useRenderHits` call the two functions
+ * coincide, so the same predicate reports it.
+ */
+function isStableForConsumer(defNode, consumerFunction) {
+    const definitionFunction = getEnclosingFunction(defNode);
+    return definitionFunction === null || definitionFunction !== consumerFunction;
+}
 exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
     name: 'enforce-render-hits-memoization',
     meta: {
@@ -116,21 +170,25 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             return false;
         };
         /**
-         * A prop pointing at a declaration that lives outside every component body.
+         * A prop pointing at a declaration that lives outside the body of the
+         * function calling `useRenderHits`.
          *
-         * Module scope creates the binding once for the program's lifetime, so its
-         * identity is strictly more stable than anything a hook can hand back:
-         * demanding a `useCallback` wrapper around it asks for work that can only
-         * make the reference less stable, never more.
+         * Such a binding is created once per run of the enclosing scope, and the
+         * calling function is created in that same run, so its identity is fixed for
+         * the whole life of that closure — strictly more stable than anything a hook
+         * can hand back. Demanding a `useCallback` wrapper around it asks for work
+         * that can only make the reference less stable, never more, and in a factory
+         * the wrapper is not even legal (rules-of-hooks) while a helper closing over
+         * an outer parameter cannot be hoisted to module scope either.
          *
-         * Both `module` and `global` count. Under `sourceType: 'script'` — the
-         * parser default, and what a consumer's config may well leave in place — a
-         * top-level declaration binds to the *global* scope and no module scope
-         * exists at all (issue #1578), so keying on `module` alone would silently
-         * drop the carve-out for exactly the consumers who never opted into module
-         * parsing.
+         * Module and global scope are the degenerate case of "outside", and both
+         * count. Under `sourceType: 'script'` — the parser default, and what a
+         * consumer's config may well leave in place — a top-level declaration binds
+         * to the *global* scope and no module scope exists at all (issue #1578);
+         * measuring against the enclosing function rather than the scope type keeps
+         * the carve-out for consumers who never opted into module parsing.
          *
-         * The shape is not hypothetical:
+         * The module-scope shape is not hypothetical:
          * `no-empty-dependency-use-callbacks` — 'error' in the same recommended
          * config, and fixable — hoists a dependency-free callback to module scope
          * and drops the hook, so one `eslint --fix` run rewrites memoized code into
@@ -141,18 +199,17 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
             // The scope chain has to be walked rather than a single scope's variable
-            // list read: the useRenderHits call sits inside the component, so a
-            // module-scope declaration is never among the current scope's own
+            // list read: the useRenderHits call sits inside the component, so an
+            // outer-scope declaration is never among the current scope's own
             // variables.
             const variable = utils_1.ASTUtils.findVariable(context.getScope(), node);
             if (!variable)
                 return false;
-            const scopeType = variable.scope.type;
-            if (scopeType !== utils_1.TSESLint.Scope.ScopeType.module &&
-                scopeType !== utils_1.TSESLint.Scope.ScopeType.global) {
-                return false;
-            }
-            return variable.defs.some(isStableDeclaration);
+            // The prop value sits lexically inside the useRenderHits call, so its
+            // nearest enclosing function is the consuming one.
+            const consumerFunction = getEnclosingFunction(node);
+            return variable.defs.some((def) => isStableDeclaration(def) &&
+                isStableForConsumer(def.node, consumerFunction));
         };
         const isInsideMemoizedCall = (node) => {
             // Handle the case when node is already a memoized call

package/lib/rules/enforce-transform-memoization.js

@@ -6,6 +6,62 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const LATEST_CALLBACK_MODULE = 'use-latest-callback';
 const LATEST_CALLBACK_HOOK = 'useLatestCallback';
+function isFunctionNode(node) {
+    if (!node)
+        return false;
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
+}
+/**
+ * Nearest enclosing function of a node, or `null` when the node sits at module
+ * scope. Class and object methods are reached through their `FunctionExpression`
+ * value, so no separate `MethodDefinition` case is needed.
+ *
+ * The walk starts at the parent, so a `FunctionDeclaration` passed in as the
+ * declaration site reports the function that CONTAINS it rather than itself.
+ */
+function getEnclosingFunction(node) {
+    let current = node.parent;
+    while (current) {
+        if (isFunctionNode(current)) {
+            return current;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.Program) {
+            return null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * The hazard is identity churn measured against the CONSUMER, not absolute scope
+ * depth: `adaptValue` only ever sees a new transform identity when the function
+ * that references it re-runs and rebuilds the binding on the way. That holds
+ * exactly when the declaration and the reference share a nearest enclosing
+ * function.
+ *
+ * When the declaration sits in a strictly outer function — a component factory,
+ * an HOC, a `describe` callback consumed from a nested `it`, a class-method
+ * factory, an IIFE — the binding is created once per outer call and the
+ * referencing function is created in that same call, so every render sees the
+ * identical reference. The message's remedy is also unavailable there: `useMemo`
+ * cannot legally be called in a factory that is neither a component nor a hook,
+ * and a helper closing over an outer parameter cannot be hoisted to module
+ * scope. Module scope is the degenerate case: the declaration has no enclosing
+ * function at all.
+ *
+ * Scope resolution guarantees the declaration's scope is on the reference's
+ * scope chain, so "not the same function" and "strictly encloses" coincide here.
+ *
+ * A custom hook is deliberately NOT special-cased, and neither is a plain helper
+ * called during render: both re-run per render, and when either also holds the
+ * reference the two functions coincide, so the same predicate reports it.
+ */
+function isStableForConsumer(defNode, consumerFunction) {
+    const definitionFunction = getEnclosingFunction(defNode);
+    return definitionFunction === null || definitionFunction !== consumerFunction;
+}
 exports.enforceTransformMemoization = (0, createRule_1.createRule)({
     name: 'enforce-transform-memoization',
     meta: {
@@ -69,6 +125,15 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
             }
             return '';
         };
+        // Used ONLY by the dependency audit, where the question is "can this value
+        // differ between two renders", not "is this binding stable for its
+        // consumer". The consumer-relative predicate is deliberately not applied
+        // here: a hook call nested in a render callback (`keys.map((key) =>
+        // adaptValue({ transformValue: useMemo(...) }, Switch))`) has that callback
+        // as its nearest enclosing function, so measuring against it would drop the
+        // component's own props and state from the audit — a false negative. Naming
+        // one extra outer-scope value in the array, by contrast, is a legal and
+        // harmless remedy, so over-collection costs nothing here.
         const isTopLevelScope = (scope) => scope.type === 'global' || scope.type === 'module';
         const findVariableInScopeChain = (identifier) => {
             if (!scopeManager)
@@ -352,8 +417,14 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
                 if (!variable) {
                     return { ok: true };
                 }
+                // `every` rather than `some` on the stability test: a name bound more
+                // than once is only as stable as its least stable binding. It also keeps
+                // a variable with NO definition — an ambient global such as `console`,
+                // resolved in the global scope with an empty `defs` — exempt, since such
+                // a binding is created once for the program's lifetime.
+                const consumerFunction = getEnclosingFunction(unwrapped);
                 if (variable.defs.some((def) => def.type === 'Parameter') ||
-                    isTopLevelScope(variable.scope)) {
+                    variable.defs.every((def) => isStableForConsumer(def.node, consumerFunction))) {
                     return { ok: true };
                 }
                 const init = getVariableInitializer(variable);

package/lib/rules/extract-global-constants.js

@@ -186,10 +186,15 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 }
             },
             FunctionDeclaration(node) {
-                if (node.parent &&
-                    (node.parent.type === 'FunctionDeclaration' ||
-                        node.parent.type === 'FunctionExpression' ||
-                        node.parent.type === 'ArrowFunctionExpression')) {
+                /**
+                 * The enclosing function, not the immediate parent. A
+                 * FunctionDeclaration is a Statement, so its parent is always a
+                 * statement container — Program, BlockStatement, StaticBlock,
+                 * SwitchCase, an export, an IfStatement. It is never a direct child of
+                 * a function node, which made the previous `node.parent.type` check
+                 * unsatisfiable and this whole branch dead.
+                 */
+                if (node.parent && isInsideFunction(node.parent)) {
                     const scope = context.getScope();
                     const hasDependencies = ASTHelpers_1.ASTHelpers.blockIncludesIdentifier(node.body);
                     if (!hasDependencies && scope.type === 'function') {