@ethlete/eslint-plugin 1.0.0-next.23 → 1.0.0-next.24

package/src/rules/internals/import-resolution.js

@@ -0,0 +1,191 @@
+// @ts-check
+'use strict';
+
+const ANGULAR_CORE = '@angular/core';
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} identifier
+ */
+const findVariable = (sourceCode, identifier) => {
+  /** @type {import('eslint').Scope.Scope | null} */
+  let scope = sourceCode.getScope(identifier);
+
+  while (scope) {
+    const variable = scope.set.get(identifier.name);
+    if (variable) return variable;
+    scope = scope.upper;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} specifier
+ */
+const getSpecifierImportedName = (specifier) => {
+  if (specifier.type === 'ImportDefaultSpecifier') return 'default';
+  if (specifier.type === 'ImportNamespaceSpecifier') return '*';
+
+  return specifier.imported.name ?? specifier.imported.value;
+};
+
+/**
+ * What an identifier is bound to: `{ source, name }` for an import (`name` is the exported
+ * name, `'*'` for a namespace), `{ source: null, name }` for an undeclared global, and `null`
+ * for a local binding.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} identifier
+ * @returns {{ source: string | null; name: string } | null}
+ */
+const resolveIdentifier = (sourceCode, identifier) => {
+  const variable = findVariable(sourceCode, identifier);
+  if (!variable || variable.defs.length === 0) return { source: null, name: identifier.name };
+
+  const definition = /** @type {any} */ (variable.defs[0]);
+  if (definition.type !== 'ImportBinding') return null;
+
+  return { source: definition.parent.source.value, name: getSpecifierImportedName(definition.node) };
+};
+
+/**
+ * The exported name `node` refers to when it is imported from one of `sources`, directly, under
+ * an alias, or as `namespace.name`. An undeclared identifier falls back to its own name, so code
+ * without an import statement still matches; any other binding yields `null`.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} node
+ * @param {string | readonly string[]} sources
+ * @returns {string | null}
+ */
+const getImportedName = (sourceCode, node, sources) => {
+  const sourceList = typeof sources === 'string' ? [sources] : sources;
+
+  if (node?.type === 'Identifier') {
+    const resolved = resolveIdentifier(sourceCode, node);
+    if (!resolved) return null;
+    if (resolved.source === null) return resolved.name;
+
+    return sourceList.includes(resolved.source) && resolved.name !== '*' ? resolved.name : null;
+  }
+
+  if (
+    node?.type === 'MemberExpression' &&
+    !node.computed &&
+    node.object.type === 'Identifier' &&
+    node.property.type === 'Identifier'
+  ) {
+    const resolved = resolveIdentifier(sourceCode, node.object);
+    if (!resolved || resolved.name !== '*' || resolved.source === null) return null;
+
+    return sourceList.includes(resolved.source) ? node.property.name : null;
+  }
+
+  return null;
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} node
+ * @param {string} name
+ * @param {string | readonly string[]} [sources]
+ */
+const isImportedAs = (sourceCode, node, name, sources = ANGULAR_CORE) =>
+  getImportedName(sourceCode, node, sources) === name;
+
+/**
+ * The `@angular/core` name of a decorator such as `@Component(...)`, `@Cmp(...)` or
+ * `@ng.Component(...)`.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} decorator
+ */
+const getAngularDecoratorName = (sourceCode, decorator) => {
+  if (decorator?.type !== 'Decorator') return null;
+
+  const expression = decorator.expression;
+  const target = expression.type === 'CallExpression' ? expression.callee : expression;
+
+  return getImportedName(sourceCode, target, ANGULAR_CORE);
+};
+
+/**
+ * The local name of a value import `{ importedName as local } from source`, or `null` when the
+ * file does not import it as a value.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {string} source
+ * @param {string} importedName
+ */
+const getImportLocalName = (sourceCode, source, importedName) => {
+  for (const node of sourceCode.ast.body) {
+    if (node.type !== 'ImportDeclaration' || node.source.value !== source) continue;
+    if (/** @type {any} */ (node).importKind === 'type') continue;
+
+    for (const specifier of node.specifiers) {
+      if (specifier.type !== 'ImportSpecifier' || /** @type {any} */ (specifier).importKind === 'type') continue;
+      if (getSpecifierImportedName(specifier) === importedName) return specifier.local.name;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Whether `identifier` refers to a global such as `document` or `setTimeout`, rather than a local,
+ * parameter or import of the same name.
+ *
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} identifier
+ */
+const isGlobalReference = (sourceCode, identifier) =>
+  identifier?.type === 'Identifier' && resolveIdentifier(sourceCode, identifier)?.source === null;
+
+const MODULE_REFERENCE_SELECTOR =
+  'ImportDeclaration, ExportNamedDeclaration[source], ExportAllDeclaration, ImportExpression';
+
+/**
+ * The module an import, re-export or dynamic `import('…')` references, with the names it takes by
+ * name. `export *`, a namespace or default import, and a dynamic import have no named entries.
+ *
+ * @param {any} node a node matched by `MODULE_REFERENCE_SELECTOR`
+ * @returns {{ source: string; named: { name: string; node: any }[] } | null}
+ */
+const getModuleReference = (node) => {
+  const sourceNode = node.source;
+  let source = null;
+  if (sourceNode?.type === 'Literal' && typeof sourceNode.value === 'string') source = sourceNode.value;
+  if (sourceNode?.type === 'TemplateLiteral' && sourceNode.expressions.length === 0) {
+    source = sourceNode.quasis[0].value.cooked;
+  }
+  if (source === null) return null;
+
+  /** @type {{ name: string; node: any }[]} */
+  const named = [];
+  if (node.type === 'ImportDeclaration') {
+    for (const specifier of node.specifiers) {
+      if (specifier.type !== 'ImportSpecifier') continue;
+      named.push({ name: getSpecifierImportedName(specifier), node: specifier });
+    }
+  }
+  if (node.type === 'ExportNamedDeclaration') {
+    for (const specifier of node.specifiers) {
+      named.push({ name: specifier.local.name ?? specifier.local.value, node: specifier });
+    }
+  }
+
+  return { source, named };
+};
+
+module.exports = {
+  ANGULAR_CORE,
+  MODULE_REFERENCE_SELECTOR,
+  getAngularDecoratorName,
+  getImportedName,
+  getImportLocalName,
+  getModuleReference,
+  isGlobalReference,
+  isImportedAs,
+  resolveIdentifier,
+};

package/src/rules/no-angular-router-api.js

@@ -35,6 +35,10 @@
  *   injectQueryParamChanges(), injectPathParamChanges()
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isImportedAs } = require('./internals/import-resolution');
+
+const ANGULAR_ROUTER = '@angular/router';
+
 /**
  * Router properties that expose route state and must not be read directly.
  * @type {Map<string, string>}
@@ -66,6 +70,17 @@ const noAngularRouterApi = {
     schema: [],
   },
   create(context) {
+    const sourceCode = context.sourceCode;
+
+    /**
+     * @param {any} call
+     * @param {string} token
+     */
+    const isInjectOf = (call, token) =>
+      call?.type === 'CallExpression' &&
+      isImportedAs(sourceCode, call.callee, 'inject') &&
+      isImportedAs(sourceCode, call.arguments[0], token, ANGULAR_ROUTER);
+
     /**
      * Names of variables/properties assigned from inject(Router).
      * We track identifiers whose initializer is inject(Router) so we can
@@ -78,28 +93,14 @@ const noAngularRouterApi = {
       // ── Track inject(Router) bindings ──────────────────────────────────────
       // const router = inject(Router);
       VariableDeclarator(node) {
-        if (
-          node.init?.type === 'CallExpression' &&
-          node.init.callee.type === 'Identifier' &&
-          node.init.callee.name === 'inject' &&
-          node.init.arguments[0]?.type === 'Identifier' &&
-          node.init.arguments[0].name === 'Router' &&
-          node.id.type === 'Identifier'
-        ) {
+        if (isInjectOf(node.init, 'Router') && node.id.type === 'Identifier') {
           routerBindings.add(node.id.name);
         }
       },
 
       // ── Track class property assignments: router = inject(Router) ──────────
       PropertyDefinition(node) {
-        if (
-          node.value?.type === 'CallExpression' &&
-          node.value.callee.type === 'Identifier' &&
-          node.value.callee.name === 'inject' &&
-          node.value.arguments[0]?.type === 'Identifier' &&
-          node.value.arguments[0].name === 'Router' &&
-          node.key.type === 'Identifier'
-        ) {
+        if (isInjectOf(node.value, 'Router') && node.key.type === 'Identifier') {
           routerBindings.add(node.key.name);
         }
       },
@@ -130,24 +131,17 @@ const noAngularRouterApi = {
       },
 
       // ── ActivatedRoute import ───────────────────────────────────────────────
-      ImportDeclaration(node) {
-        if (node.source.value !== '@angular/router') return;
-        for (const specifier of node.specifiers) {
-          if (specifier.type !== 'ImportSpecifier') continue;
-          if (specifier.imported.name === 'ActivatedRoute') {
-            context.report({ node, messageId: 'noActivatedRoute' });
-            return;
-          }
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== ANGULAR_ROUTER) return;
+        if (reference.named.some((entry) => entry.name === 'ActivatedRoute')) {
+          context.report({ node, messageId: 'noActivatedRoute' });
         }
       },
 
       // ── inject(ActivatedRoute) ──────────────────────────────────────────────
       CallExpression(node) {
-        const { callee } = node;
-        if (callee.type !== 'Identifier' || callee.name !== 'inject') return;
-        const arg = node.arguments[0];
-        if (arg?.type !== 'Identifier') return;
-        if (arg.name === 'ActivatedRoute') {
+        if (isInjectOf(node, 'ActivatedRoute')) {
           context.report({ node, messageId: 'noActivatedRoute' });
         }
       },

package/src/rules/no-angular-seo-services.js

@@ -1,6 +1,13 @@
 // @ts-check
 'use strict';
 
+const {
+  MODULE_REFERENCE_SELECTOR,
+  getImportedName,
+  getModuleReference,
+  isImportedAs,
+} = require('./internals/import-resolution');
+
 /**
  * Disallows injecting Angular's `Title` and `Meta` services from
  * `@angular/platform-browser` and importing them from that module.
@@ -48,11 +55,11 @@ const rule = {
      */
     const injectTokenName = (node) => {
       if (node.type !== 'CallExpression') return null;
-      if (node.callee.type !== 'Identifier' || node.callee.name !== 'inject') return null;
+      if (!isImportedAs(context.sourceCode, node.callee, 'inject')) return null;
       const firstArg = node.arguments[0];
       if (!firstArg) return null;
-      if (firstArg.type === 'Identifier') return firstArg.name;
-      return null;
+
+      return getImportedName(context.sourceCode, firstArg, '@angular/platform-browser');
     };
 
     return {
@@ -64,13 +71,11 @@ const rule = {
       },
 
       // Detect: import { Title, Meta } from '@angular/platform-browser'
-      ImportDeclaration(node) {
-        const decl = /** @type {any} */ (node);
-        if (decl.source.value !== '@angular/platform-browser') return;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== '@angular/platform-browser') return;
 
-        for (const specifier of decl.specifiers) {
-          if (specifier.type !== 'ImportSpecifier') continue;
-          const imported = specifier.imported.name ?? specifier.imported.value;
+        for (const { name: imported, node: specifier } of reference.named) {
           if (imported === 'Title') context.report({ node: specifier, messageId: 'noImportTitle' });
           if (imported === 'Meta') context.report({ node: specifier, messageId: 'noImportMeta' });
         }

package/src/rules/no-cdk-import.js

@@ -4,6 +4,7 @@
 const { createRequire } = require('node:module');
 const path = require('node:path');
 const fs = require('node:fs');
+const { MODULE_REFERENCE_SELECTOR, getModuleReference } = require('./internals/import-resolution');
 
 /**
  * Disallows importing from `@ethlete/cdk`, the maintenance-mode predecessor of `@ethlete/components`,
@@ -52,13 +53,6 @@ const loadMigrationMap = (mapPath, cwd) => {
   return map;
 };
 
-/** @param {any} specifier */
-const importedName = (specifier) => {
-  if (specifier.type !== 'ImportSpecifier') return null;
-
-  return specifier.imported.name ?? specifier.imported.value ?? null;
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const noCdkImport = {
   meta: {
@@ -95,13 +89,13 @@ const noCdkImport = {
     const entryFor = (name) => map?.[name] ?? null;
 
     return {
-      ImportDeclaration(node) {
-        const declaration = /** @type {any} */ (node);
-        const source = declaration.source.value;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        const source = reference?.source;
 
-        if (typeof source !== 'string' || (source !== CDK_PACKAGE && !source.startsWith(`${CDK_PACKAGE}/`))) return;
+        if (!reference || (source !== CDK_PACKAGE && !source?.startsWith(`${CDK_PACKAGE}/`))) return;
 
-        const named = declaration.specifiers.filter(/** @param {any} s */ (s) => importedName(s));
+        const { named } = reference;
 
         if (!named.length) {
           context.report({ node, messageId: 'module', data: { cdk: CDK_PACKAGE, docs: migrationDocs } });
@@ -109,8 +103,7 @@ const noCdkImport = {
           return;
         }
 
-        for (const specifier of named) {
-          const name = /** @type {string} */ (importedName(specifier));
+        for (const { name, node: specifier } of named) {
           const entry = entryFor(name);
 
           if (!entry) {

package/src/rules/no-document-cookie.js

@@ -21,6 +21,8 @@
  *   deleteCookie('name');
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noDocumentCookie = {
   meta: {
@@ -42,6 +44,7 @@ const noDocumentCookie = {
         if (
           node.object.type === 'Identifier' &&
           node.object.name === 'document' &&
+          isGlobalReference(context.sourceCode, node.object) &&
           node.property.type === 'Identifier' &&
           node.property.name === 'cookie'
         ) {

package/src/rules/no-effect-cleanup-return.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Disallows returning a cleanup function from an `effect()` callback.
  *
@@ -115,7 +117,9 @@ const noEffectCleanupReturn = {
       CallExpression(node) {
         const { callee } = node;
 
-        if (callee.type !== 'Identifier' || !EFFECT_CALLEES.has(callee.name)) {
+        const calleeName = getImportedName(context.sourceCode, callee, ANGULAR_CORE);
+
+        if (!calleeName || !EFFECT_CALLEES.has(calleeName)) {
           return;
         }
 
@@ -130,7 +134,7 @@ const noEffectCleanupReturn = {
           context.report({
             node: callback.body,
             messageId: 'returnedCleanup',
-            data: { callee: callee.name },
+            data: { callee: calleeName },
           });
 
           return;
@@ -163,7 +167,7 @@ const noEffectCleanupReturn = {
           context.report({
             node: statement.argument,
             messageId: 'returnedCleanup',
-            data: { callee: callee.name },
+            data: { callee: calleeName },
             fix:
               fixable && openParen
                 ? (fixer) => [

package/src/rules/no-empty-angular-metadata-arrays.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
 
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
@@ -14,22 +16,6 @@ const getPropertyName = (key) => {
   return null;
 };
 
-/**
- * @param {import('eslint').Rule.Node} node
- * @returns {TDecoratorName | null}
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 const MESSAGE_IDS = {
   hostDirectives: 'noEmptyHostDirectives',
   imports: 'noEmptyImports',
@@ -55,7 +41,7 @@ const noEmptyAngularMetadataArrays = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const decorator = /** @type {any} */ (node);

package/src/rules/no-inject-chain.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noInjectChain = {
   meta: {
@@ -19,7 +21,7 @@ const noInjectChain = {
     return {
       MemberExpression(node) {
         const obj = node.object;
-        if (obj.type === 'CallExpression' && obj.callee.type === 'Identifier' && obj.callee.name === 'inject') {
+        if (obj.type === 'CallExpression' && isImportedAs(context.sourceCode, obj.callee, 'inject')) {
           // Allow inject(X).method() — immediately-invoked patterns like
           // inject(DestroyRef).onDestroy(...) are intentional Angular idioms.
           const parent = node.parent;

package/src/rules/no-leading-underscore-class-member.js

@@ -16,6 +16,16 @@ const getDirectMemberName = (node) => {
   return node.key?.type === 'Identifier' ? node.key.name : null;
 };
 
+/**
+ * @param {any} key
+ * @param {boolean} computed
+ */
+const getReferencedName = (key, computed) => {
+  if (!computed && key?.type === 'Identifier') return key.name;
+  if (key?.type === 'Literal' && typeof key.value === 'string') return key.value;
+  return null;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noLeadingUnderscoreClassMember = {
   meta: {
@@ -36,6 +46,7 @@ const noLeadingUnderscoreClassMember = {
      *   declaredNames: Set<string>,
      *   membersByName: Map<string, any[]>,
      *   memberReads: any[],
+     *   untrackedNames: Set<string>,
      * }>}
      */
     const classStack = [];
@@ -66,6 +77,7 @@ const noLeadingUnderscoreClassMember = {
           declaredNames: new Set(),
           membersByName: new Map(),
           memberReads: [],
+          untrackedNames: new Set(),
         });
       },
 
@@ -85,6 +97,7 @@ const noLeadingUnderscoreClassMember = {
             newName.length > 0 &&
             !frame.declaredNames.has(newName) &&
             targetNameCounts.get(newName) === 1 &&
+            !frame.untrackedNames.has(oldName) &&
             memberNodes.every((memberNode) => memberNode.accessibility === 'private');
 
           for (const memberNode of memberNodes) {
@@ -115,10 +128,20 @@ const noLeadingUnderscoreClassMember = {
       MemberExpression(node) {
         const frame = classStack[classStack.length - 1];
         if (!frame) return;
-        if (node.object?.type !== 'ThisExpression' || node.computed) return;
-        if (node.property?.type !== 'Identifier') return;
 
-        frame.memberReads.push(node);
+        if (node.object?.type === 'ThisExpression' && !node.computed && node.property?.type === 'Identifier') {
+          frame.memberReads.push(node);
+          return;
+        }
+
+        const name = getReferencedName(node.property, node.computed);
+        if (name) frame.untrackedNames.add(name);
+      },
+
+      'ObjectPattern > Property'(node) {
+        const frame = classStack[classStack.length - 1];
+        const name = getReferencedName(node.key, node.computed);
+        if (frame && name) frame.untrackedNames.add(name);
       },
     };
   },

package/src/rules/no-legacy-angular-decorators.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
  * Disallows legacy Angular decorators in favour of their modern signal-based
  * equivalents and the `host: {}` shorthand.
@@ -25,20 +27,6 @@
  *   → ✅ host: { '[class.active]': 'isActive', '(click)': 'onClick()' }
  */
 
-/**
- * Returns the identifier name of a decorator.
- * Works for both `@Foo` (Identifier) and `@Foo(...)` (CallExpression).
- *
- * @param {any} decorator
- * @returns {string | null}
- */
-const getDecoratorName = (decorator) => {
-  const expr = decorator.expression;
-  if (expr.type === 'Identifier') return expr.name;
-  if (expr.type === 'CallExpression' && expr.callee.type === 'Identifier') return expr.callee.name;
-  return null;
-};
-
 /**
  * Returns the static string key of a class member, or null for computed keys.
  *
@@ -72,11 +60,12 @@ const getIndent = (sourceCode, node) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  */
-const getAngularMetadata = (classNode) => {
+const getAngularMetadata = (sourceCode, classNode) => {
   for (const decorator of classNode.decorators ?? []) {
-    const decoratorName = getDecoratorName(decorator);
+    const decoratorName = getAngularDecoratorName(sourceCode, decorator);
     if (decoratorName !== 'Component' && decoratorName !== 'Directive') continue;
 
     const expression = decorator.expression;
@@ -106,7 +95,7 @@ const findObjectProperty = (objectExpression, propertyName) =>
  * @param {string} entryText
  */
 const buildObjectTextWithAppendedProperty = (sourceCode, objectExpression, entryText) => {
-  const properties = objectExpression.properties.filter((property) => property.type === 'Property');
+  const properties = objectExpression.properties;
   const isMultiline = Boolean(
     objectExpression.loc && objectExpression.loc.start.line !== objectExpression.loc.end.line,
   );
@@ -138,8 +127,7 @@ ${closingIndent}}`;
  * @param {any} objectExpression
  */
 const hasTrailingComma = (sourceCode, objectExpression) => {
-  const properties = objectExpression.properties.filter((property) => property.type === 'Property');
-  const lastProperty = properties[properties.length - 1];
+  const lastProperty = objectExpression.properties.at(-1);
   if (!lastProperty) return false;
 
   const tokenAfter = sourceCode.getTokenAfter(lastProperty);
@@ -158,7 +146,7 @@ const buildHostBindingFix = (sourceCode, decoratorNode, memberNode, bindingKey,
   const classNode = classBody?.parent;
   if (!classNode) return null;
 
-  const metadata = getAngularMetadata(classNode);
+  const metadata = getAngularMetadata(sourceCode, classNode);
   if (!metadata) return null;
 
   const hostProperty = findObjectProperty(metadata, 'host');
@@ -312,7 +300,7 @@ const rule = {
 
       Decorator(node) {
         const anyNode = /** @type {any} */ (node);
-        const decoratorName = getDecoratorName(anyNode);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, anyNode);
         if (!decoratorName) return;
 
         // Only act on decorators attached to class members, not to the class itself

package/src/rules/no-legacy-query-import.js

@@ -19,6 +19,8 @@
  * the types this rule leaves alone), enable `@typescript-eslint/no-deprecated` alongside it.
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference } = require('./internals/import-resolution');
+
 const QUERY_PACKAGE = '@ethlete/query';
 const DEFAULT_DOCS_BASE_URL = 'https://ethlete-sdk-docs.web.app';
 
@@ -60,13 +62,6 @@ const V2_SUCCESSORS = {
   V2BearerAuthProvider: { to: '`createBearerAuthProvider` plus the secure creator templates', docs: '/query/auth' },
 };
 
-/** @param {any} specifier */
-const importedName = (specifier) => {
-  if (specifier.type !== 'ImportSpecifier') return null;
-
-  return specifier.imported.name ?? specifier.imported.value ?? null;
-};
-
 /** @param {string} name */
 const isV2Symbol = (name) => /^(V2|AnyV2)[A-Z]/.test(name);
 
@@ -98,16 +93,12 @@ const noLegacyQueryImport = {
     const docsBaseUrl = (options.docsBaseUrl ?? DEFAULT_DOCS_BASE_URL).replace(/\/$/, '');
 
     return {
-      ImportDeclaration(node) {
-        const declaration = /** @type {any} */ (node);
-
-        if (declaration.source.value !== QUERY_PACKAGE) return;
-
-        for (const specifier of declaration.specifiers) {
-          const name = importedName(specifier);
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
 
-          if (!name) continue;
+        if (reference?.source !== QUERY_PACKAGE) return;
 
+        for (const { name, node: specifier } of reference.named) {
           const successor = V2_SUCCESSORS[name] ?? LEGACY_SYMBOLS[name];
 
           if (successor) {