@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.0

package/lib/rules/enforce-querykey-ts.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceQueryKeyTs = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Rule to enforce the use of centralized router state key constants imported from
+ * `src/util/routing/queryKeys.ts` instead of arbitrary string literals when calling
+ * router methods that accept key parameters.
+ */
+exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
+    name: 'enforce-querykey-ts',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using centralized router state key constants from queryKeys.ts for useRouterState key parameter',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceQueryKeyImport: 'Router state key must come from queryKeys.ts (e.g., "@/util/routing/queryKeys", "src/util/routing/queryKeys", or a relative path ending in "/util/routing/queryKeys"). Use a QUERY_KEY_* constant instead of string literals.',
+            enforceQueryKeyConstant: 'Router state key must use a QUERY_KEY_* constant from queryKeys.ts. Variable "{{variableName}}" is not imported from the correct source.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track imports from queryKeys.ts
+        const queryKeyImports = new Map();
+        const localUseRouterStateNames = new Set(['useRouterState']);
+        const validQueryKeySources = new Set([
+            '@/util/routing/queryKeys',
+            'src/util/routing/queryKeys',
+        ]);
+        const allowedQueryKeyFactories = new Set(['makeQueryKey', 'getQueryKey']);
+        /**
+         * Ensure a suggested constant is imported from queryKeys.ts and return combined fixes
+         */
+        function buildImportFixes(fixer, keyNode, suggestedConstant) {
+            return [fixer.replaceText(keyNode, suggestedConstant)];
+        }
+        /**
+         * Check if a source path refers to queryKeys.ts
+         */
+        function isQueryKeysSource(source) {
+            return (validQueryKeySources.has(source) ||
+                source.endsWith('/util/routing/queryKeys'));
+        }
+        /**
+         * Check if an identifier is a valid QUERY_KEY constant
+         */
+        function isValidQueryKeyConstant(name) {
+            return name.startsWith('QUERY_KEY_');
+        }
+        /**
+         * Track variable assignments to detect variables derived from query key constants
+         */
+        const variableAssignments = new Map();
+        /**
+         * Check if a node represents a valid query key usage
+         */
+        function isValidQueryKeyUsage(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const importInfo = queryKeyImports.get(node.name);
+                if (importInfo && isQueryKeysSource(importInfo.source)) {
+                    return isValidQueryKeyConstant(importInfo.imported);
+                }
+                // Check if it's a variable derived from a query key constant
+                const assignment = variableAssignments.get(node.name);
+                if (assignment) {
+                    return isValidQueryKeyUsage(assignment);
+                }
+            }
+            // Allow member expressions accessing query key constants
+            if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const member = node;
+                if (member.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    !member.computed &&
+                    member.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const importInfo = queryKeyImports.get(member.object.name);
+                    if (importInfo && isQueryKeysSource(importInfo.source)) {
+                        if (importInfo.imported === '*') {
+                            return isValidQueryKeyConstant(member.property.name);
+                        }
+                        return isValidQueryKeyConstant(member.property.name);
+                    }
+                }
+            }
+            // Allow template literals only when they contain no static content and all expressions are valid
+            if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                const hasSignificantStaticPart = node.quasis.some((quasi) => {
+                    const content = quasi.value.raw.trim();
+                    return content.length > 0 && !/^[-_:/.]+$/.test(content);
+                });
+                if (node.expressions.length === 0) {
+                    // Pure static template acts like a string literal
+                    return false;
+                }
+                if (hasSignificantStaticPart) {
+                    return false;
+                }
+                return node.expressions.some((expr) => isValidQueryKeyUsage(expr));
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                node.operator === '+') {
+                return (isValidQueryKeyUsage(node.left) || isValidQueryKeyUsage(node.right));
+            }
+            // Allow conditional expressions if both branches use valid query keys
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                return (isValidQueryKeyUsage(node.consequent) &&
+                    isValidQueryKeyUsage(node.alternate));
+            }
+            // Allow function calls that might return query keys
+            if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                const callee = node.callee;
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return allowedQueryKeyFactories.has(callee.name);
+                }
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    !callee.computed &&
+                    callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return allowedQueryKeyFactories.has(callee.property.name);
+                }
+                return false;
+            }
+            return false;
+        }
+        /**
+         * Check if a node contains string literals that should be reported
+         */
+        function containsInvalidStringLiteral(node) {
+            // Direct string literal
+            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') {
+                return true;
+            }
+            // String concatenation with + operator containing literals
+            if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                node.operator === '+') {
+                return (containsInvalidStringLiteral(node.left) ||
+                    containsInvalidStringLiteral(node.right));
+            }
+            // Conditional (ternary) expression with string literals
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                return (containsInvalidStringLiteral(node.consequent) ||
+                    containsInvalidStringLiteral(node.alternate));
+            }
+            // Template literal handling
+            if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                const hasSignificantStaticPart = node.quasis.some((quasi) => {
+                    const content = quasi.value.raw.trim();
+                    return content.length > 0 && !/^[-_:/.]+$/.test(content);
+                });
+                if (node.expressions.length === 0) {
+                    // Pure static template behaves like a string literal
+                    return hasSignificantStaticPart;
+                }
+                // Any meaningful static content makes this invalid regardless of expressions
+                if (hasSignificantStaticPart) {
+                    return true;
+                }
+                // Only dynamic parts remain; all expressions must be valid query key usages
+                return !node.expressions.every((expr) => isValidQueryKeyUsage(expr));
+            }
+            return false;
+        }
+        /**
+         * Generate auto-fix suggestion for string literals
+         */
+        function generateAutoFix(keyValue) {
+            // Simple heuristic to suggest query key constant names
+            const normalizedKey = keyValue
+                .toUpperCase()
+                .replace(/[^A-Z0-9]/g, '_')
+                .replace(/_+/g, '_')
+                .replace(/^_|_$/g, '');
+            return `QUERY_KEY_${normalizedKey}`;
+        }
+        return {
+            // Track imports from queryKeys.ts
+            ImportDeclaration(node) {
+                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.source.value === 'string') {
+                    const source = node.source.value;
+                    if (isQueryKeysSource(source)) {
+                        node.specifiers.forEach((spec) => {
+                            if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                                const imported = spec.imported.name;
+                                const local = spec.local.name;
+                                queryKeyImports.set(local, { source, imported });
+                            }
+                            else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                                const local = spec.local.name;
+                                queryKeyImports.set(local, { source, imported: '*' });
+                            }
+                        });
+                    }
+                    node.specifiers.forEach((spec) => {
+                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            spec.imported.name === 'useRouterState') {
+                            localUseRouterStateNames.add(spec.local.name);
+                        }
+                    });
+                }
+            },
+            // Track variable declarations that might derive from query key constants
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier && node.init) {
+                    variableAssignments.set(node.id.name, node.init);
+                }
+            },
+            AssignmentExpression(node) {
+                if (node.left.type === utils_1.AST_NODE_TYPES.Identifier && node.right) {
+                    variableAssignments.set(node.left.name, node.right);
+                }
+            },
+            // Check useRouterState calls
+            CallExpression(node) {
+                // Check if this is a call to useRouterState
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    localUseRouterStateNames.has(node.callee.name)) {
+                    // Check if there are arguments
+                    if (node.arguments.length > 0) {
+                        const firstArg = node.arguments[0];
+                        // Check if the first argument is an object expression
+                        if (firstArg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                            // Find the key property in the object
+                            const keyProperty = firstArg.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                prop.key.name === 'key');
+                            // If key property exists, check its value
+                            if (keyProperty && keyProperty.value) {
+                                const keyValue = keyProperty.value;
+                                // Check if it's a valid query key usage
+                                if (!isValidQueryKeyUsage(keyValue)) {
+                                    // Check if it contains invalid string literals
+                                    if (containsInvalidStringLiteral(keyValue)) {
+                                        context.report({
+                                            node: keyValue,
+                                            messageId: 'enforceQueryKeyImport',
+                                            fix(fixer) {
+                                                // Only provide auto-fix for simple string literals
+                                                if (keyValue.type === utils_1.AST_NODE_TYPES.Literal &&
+                                                    typeof keyValue.value === 'string') {
+                                                    const suggestedConstant = generateAutoFix(keyValue.value);
+                                                    if (suggestedConstant) {
+                                                        return buildImportFixes(fixer, keyValue, suggestedConstant);
+                                                    }
+                                                }
+                                                return null;
+                                            },
+                                        });
+                                    }
+                                    else if (keyValue.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        // Report variables that aren't from the correct source
+                                        context.report({
+                                            node: keyValue,
+                                            messageId: 'enforceQueryKeyConstant',
+                                            data: {
+                                                variableName: keyValue.name,
+                                            },
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-querykey-ts.js.map

package/lib/rules/enforce-singular-type-names.js

@@ -26,6 +26,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceSingularTypeNames = void 0;
 const createRule_1 = require("../utils/createRule");
 const pluralize = __importStar(require("pluralize"));
+const NON_PLURALIZABLE_SUFFIXES = [
+    'Props',
+    'Params',
+    'Options',
+    'Settings',
+    'Data',
+];
 exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
     create(context) {
         /**
@@ -37,11 +44,8 @@ exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
             // Skip checking if name is too short (less than 3 characters)
             if (name.length < 3)
                 return false;
-            // Skip checking if name ends with 'Props' or 'Params'
-            if (name.endsWith('Props') ||
-                name.endsWith('Params') ||
-                name.endsWith('Options') ||
-                name.endsWith('Settings'))
+            // Skip checking if name ends with 'Props', 'Params', 'Data', etc.
+            if (NON_PLURALIZABLE_SUFFIXES.some((suffix) => name.toLowerCase().endsWith(suffix.toLowerCase())))
                 return false;
             // Skip checking if name is already singular according to pluralize
             if (pluralize.isSingular(name))

package/lib/rules/enforce-typescript-markdown-code-blocks.d.ts

@@ -0,0 +1 @@
+export declare const enforceTypescriptMarkdownCodeBlocks: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missingLanguageSpecifier", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-typescript-markdown-code-blocks.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceTypescriptMarkdownCodeBlocks = void 0;
+const createRule_1 = require("../utils/createRule");
+const FENCE = '```';
+function isFenceLine(text, fenceIndex, indent) {
+    const lineEnd = text.indexOf('\n', fenceIndex);
+    const afterFence = lineEnd === -1 ? text.slice(fenceIndex + FENCE.length) : text.slice(fenceIndex + FENCE.length, lineEnd);
+    return afterFence.trim().length === 0 && text.slice(text.lastIndexOf('\n', fenceIndex - 1) + 1, fenceIndex) === indent;
+}
+function findClosingFence(text, startIndex, indent) {
+    let searchIndex = startIndex;
+    while (searchIndex < text.length) {
+        const candidate = text.indexOf(FENCE, searchIndex);
+        if (candidate === -1) {
+            return null;
+        }
+        if (isFenceLine(text, candidate, indent)) {
+            return candidate;
+        }
+        searchIndex = candidate + FENCE.length;
+    }
+    return null;
+}
+function isIndentOnly(value) {
+    return /^[\t ]*$/.test(value);
+}
+exports.enforceTypescriptMarkdownCodeBlocks = (0, createRule_1.createRule)({
+    name: 'enforce-typescript-markdown-code-blocks',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure Markdown fenced code blocks without a language specifier default to typescript for consistent highlighting.',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            missingLanguageSpecifier: 'Code block starting on line {{line}} has no language label. Unlabeled fences render as plain text, hiding TypeScript syntax and type cues. Add "typescript" after the opening backticks (```typescript) to keep documentation readable and consistent.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        if (!filename.toLowerCase().endsWith('.md')) {
+            return {};
+        }
+        return {
+            Program() {
+                const sourceCode = context.getSourceCode();
+                const text = sourceCode.getText();
+                let index = 0;
+                while (index < text.length) {
+                    const openingFence = text.indexOf(FENCE, index);
+                    if (openingFence === -1) {
+                        break;
+                    }
+                    const lineStart = text.lastIndexOf('\n', openingFence - 1) + 1;
+                    const indent = text.slice(lineStart, openingFence);
+                    if (!isIndentOnly(indent)) {
+                        index = openingFence + FENCE.length;
+                        continue;
+                    }
+                    const lineEnd = text.indexOf('\n', openingFence + FENCE.length);
+                    if (lineEnd === -1) {
+                        break;
+                    }
+                    const infoString = text.slice(openingFence + FENCE.length, lineEnd);
+                    const closingFence = findClosingFence(text, lineEnd + 1, indent);
+                    if (closingFence === null) {
+                        index = lineEnd + 1;
+                        continue;
+                    }
+                    const content = text.slice(lineEnd + 1, closingFence);
+                    const hasContent = content.trim().length > 0;
+                    const hasLanguage = infoString.trim().length > 0;
+                    if (!hasLanguage && hasContent) {
+                        const locStart = sourceCode.getLocFromIndex(openingFence);
+                        const hasCarriageReturn = lineEnd > 0 && text[lineEnd - 1] === '\r';
+                        context.report({
+                            loc: {
+                                start: locStart,
+                                end: sourceCode.getLocFromIndex(lineEnd),
+                            },
+                            messageId: 'missingLanguageSpecifier',
+                            data: { line: locStart.line },
+                            fix: (fixer) => fixer.replaceTextRange([openingFence + FENCE.length, lineEnd], hasCarriageReturn ? 'typescript\r' : 'typescript'),
+                        });
+                    }
+                    index = closingFence + FENCE.length;
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-typescript-markdown-code-blocks.js.map

package/lib/rules/enforce-verb-noun-naming.js

@@ -4600,18 +4600,86 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             }
             return false;
         }
+        function bodyContainsJsx(node) {
+            const stack = [node];
+            while (stack.length) {
+                const current = stack.pop();
+                if (current.type === utils_1.AST_NODE_TYPES.JSXElement ||
+                    current.type === utils_1.AST_NODE_TYPES.JSXFragment) {
+                    return true;
+                }
+                for (const key of Object.keys(current)) {
+                    if (key === 'parent')
+                        continue;
+                    const value = current[key];
+                    if (Array.isArray(value)) {
+                        for (const child of value) {
+                            if (child && typeof child.type === 'string') {
+                                stack.push(child);
+                            }
+                        }
+                    }
+                    else if (value && typeof value.type === 'string') {
+                        stack.push(value);
+                    }
+                }
+            }
+            return false;
+        }
         function hasJsxReturn(node) {
-            const sourceCode = context.getSourceCode();
-            const text = sourceCode.getText(node);
-            // Check for direct JSX returns
-            if (text.includes('return <') || text.includes('=> <')) {
-                return true;
+            /**
+             * Recursively checks if an expression looks like JSX
+             */
+            function isJsxExpression(expr) {
+                if (!expr)
+                    return false;
+                // Handle parenthesized expressions
+                if (expr.type === 'ParenthesizedExpression') {
+                    return isJsxExpression(expr.expression);
+                }
+                switch (expr.type) {
+                    case utils_1.AST_NODE_TYPES.JSXElement:
+                    case utils_1.AST_NODE_TYPES.JSXFragment:
+                        return true;
+                    case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                        return (isJsxExpression(expr.consequent) ||
+                            isJsxExpression(expr.alternate));
+                    case utils_1.AST_NODE_TYPES.LogicalExpression:
+                        // e.g. condition && <div />
+                        return isJsxExpression(expr.right);
+                    default:
+                        return false;
+                }
             }
-            // Check for JSX assigned to variables then returned
-            if (text.includes('const ') &&
-                text.includes('<') &&
-                text.includes('return')) {
-                return true;
+            /**
+             * Recursively checks if a statement/body returns JSX
+             */
+            function checkBodyForJsx(body) {
+                if (body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    for (const stmt of body.body) {
+                        if (stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                            if (isJsxExpression(stmt.argument))
+                                return true;
+                        }
+                        else if (stmt.type === utils_1.AST_NODE_TYPES.IfStatement) {
+                            if (checkBodyForJsx(stmt.consequent))
+                                return true;
+                            if (stmt.alternate && checkBodyForJsx(stmt.alternate))
+                                return true;
+                        }
+                        // We could traverse more (try/catch, switch), but this covers most idiomatic React
+                    }
+                }
+                else {
+                    // Implicit return (arrow function expression body)
+                    return isJsxExpression(body);
+                }
+                return false;
+            }
+            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) {
+                return checkBodyForJsx(node.body);
             }
             return false;
         }
@@ -4664,6 +4732,13 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                 // 5. Component name ends with "Unmemoized" (common React pattern)
                 functionName && functionName.endsWith('Unmemoized'),
             ];
+            // If the function has a PascalCase name AND returns JSX, it's definitely a React component
+            if (functionName && isPascalCase(functionName) && hasJsxReturn(node)) {
+                return true;
+            }
+            if (functionName && isPascalCase(functionName) && bodyContainsJsx(node)) {
+                return true;
+            }
             // Consider it a React component if it matches at least 2 indicators
             // OR if it has the Unmemoized suffix (strong indicator of a React component)
             return (indicators.filter(Boolean).length >= 2 ||

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractGlobalConstants = void 0;
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
 function isInsideFunction(node) {
     let current = node;
     while (current) {
@@ -19,53 +20,61 @@ function isFunctionDefinition(node) {
     return (node?.type === 'FunctionExpression' ||
         node?.type === 'ArrowFunctionExpression');
 }
-function isImmutableValue(node) {
+const unwrapOnce = (node) => {
     if (!node)
-        return false;
+        return null;
+    const maybeParen = node;
+    if (maybeParen.type === 'ParenthesizedExpression') {
+        return maybeParen.expression ?? null;
+    }
     switch (node.type) {
-        case 'Literal':
-            return true;
-        case 'TemplateLiteral':
-            return node.expressions.length === 0;
-        case 'UnaryExpression':
-            return isImmutableValue(node.argument);
-        case 'BinaryExpression':
-            if (node.left.type === 'PrivateIdentifier')
-                return false;
-            return isImmutableValue(node.left) && isImmutableValue(node.right);
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+            return node.expression;
         default:
-            return false;
+            return null;
     }
+};
+function unwrapExpression(node) {
+    let current = node;
+    while (current) {
+        const inner = unwrapOnce(current);
+        if (!inner)
+            break;
+        current = inner;
+    }
+    return current;
 }
 function isMutableValue(node) {
-    if (!node)
+    const unwrapped = unwrapExpression(node);
+    if (!unwrapped)
+        return false;
+    // If explicitly marked readonly with `as const`, treat as immutable
+    if (node && isAsConstExpression(node)) {
         return false;
+    }
     // Check for JSX elements (always mutable due to props/context)
-    if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+    if (unwrapped.type === 'JSXElement' || unwrapped.type === 'JSXFragment') {
         return true;
     }
     // Check for object expressions (always mutable)
-    if (node.type === 'ObjectExpression') {
+    if (unwrapped.type === 'ObjectExpression') {
         return true;
     }
-    // Check array literals - mutable if empty or if they contain mutable values
-    if (node.type === 'ArrayExpression') {
-        // Empty arrays are mutable since they can be modified later
-        if (node.elements.length === 0)
-            return true;
-        // Arrays with spread elements are mutable
-        if (node.elements.some((element) => !element || element.type === 'SpreadElement'))
-            return true;
-        // Arrays with non-immutable values are mutable
-        return node.elements.some((element) => !isImmutableValue(element));
+    // Arrays are mutable objects unless explicitly narrowed with `as const`.
+    if (unwrapped.type === 'ArrayExpression') {
+        return true;
     }
     // Check for new expressions (e.g., new Map(), new Set())
-    if (node.type === 'NewExpression') {
+    if (unwrapped.type === 'NewExpression') {
         return true;
     }
     // Check for array/object methods that return mutable values
-    if (node.type === 'CallExpression') {
-        const callee = node.callee;
+    if (unwrapped.type === 'CallExpression') {
+        const callee = unwrapped.callee;
         if (callee.type === 'MemberExpression') {
             // Handle both Identifier and non-Identifier property nodes
             if (callee.property.type !== 'Identifier') {
@@ -103,14 +112,15 @@ function isZeroOrOne(node) {
     return value === 0 || value === 1;
 }
 function isAsConstExpression(node) {
-    if (!node)
-        return false;
-    if (node.type === 'TSAsExpression') {
-        if (node.typeAnnotation.type === 'TSTypeReference' &&
-            node.typeAnnotation.typeName.type === 'Identifier' &&
-            node.typeAnnotation.typeName.name === 'const') {
+    let current = node;
+    while (current) {
+        if (current.type === 'TSAsExpression' &&
+            current.typeAnnotation.type === 'TSTypeReference' &&
+            current.typeAnnotation.typeName.type === 'Identifier' &&
+            current.typeAnnotation.typeName.name === 'const') {
             return true;
         }
+        current = unwrapOnce(current);
     }
     return false;
 }
@@ -134,16 +144,18 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 if (!hasDependencies &&
                     !hasAsConstAssertion &&
                     (scope.type === 'function' || scope.type === 'block') &&
-                    isInsideFunction(node)) {
-                    const constName = node.declarations[0].id
-                        .name;
-                    context.report({
-                        node,
-                        messageId: 'extractGlobalConstants',
-                        data: {
-                            declarationName: constName,
-                        },
-                    });
+                    isInsideFunction(node) &&
+                    node.declarations.some((d) => d.id.type === 'Identifier')) {
+                    for (const d of node.declarations) {
+                        if (d.id.type !== 'Identifier')
+                            continue;
+                        const constName = d.id.name;
+                        context.report({
+                            node: d,
+                            messageId: 'extractGlobalConstants',
+                            data: { declarationName: constName },
+                        });
+                    }
                 }
             },
             FunctionDeclaration(node) {