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

package/src/rules/no-typed-injected-element-ref.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noTypedInjectedElementRef = {
   meta: {
@@ -20,30 +22,25 @@ const noTypedInjectedElementRef = {
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== 'Identifier' || node.callee.name !== 'inject') {
-          return;
-        }
+        const src = context.sourceCode;
+        if (!isImportedAs(src, node.callee, 'inject')) return;
 
         const firstArg = node.arguments[0];
         if (!firstArg) return;
 
-        const isPlainElementRef = firstArg.type === 'Identifier' && firstArg.name === 'ElementRef';
+        const isPlainElementRef = isImportedAs(src, firstArg, 'ElementRef');
         const isInstantiatedElementRef =
-          firstArg.type === 'TSInstantiationExpression' &&
-          firstArg.expression &&
-          firstArg.expression.type === 'Identifier' &&
-          firstArg.expression.name === 'ElementRef';
+          firstArg.type === 'TSInstantiationExpression' && isImportedAs(src, firstArg.expression, 'ElementRef');
 
         if (!isPlainElementRef && !isInstantiatedElementRef) return;
 
-        const src = context.sourceCode;
+        const elementRef = src.getText(isPlainElementRef ? firstArg : firstArg.expression);
         const existingTypeParams = node.typeParameters || node.typeArguments;
         const injectType = existingTypeParams?.params?.[0];
         const hasTypedElementRef =
           existingTypeParams?.params?.length === 1 &&
           injectType?.type === 'TSTypeReference' &&
-          injectType.typeName?.type === 'Identifier' &&
-          injectType.typeName.name === 'ElementRef' &&
+          src.getText(injectType.typeName) === elementRef &&
           (injectType.typeArguments || injectType.typeParameters)?.params?.length > 0;
 
         if (isPlainElementRef && !hasTypedElementRef) {
@@ -53,8 +50,8 @@ const noTypedInjectedElementRef = {
             messageId: 'missingGeneric',
             fix(fixer) {
               return existingTypeParams
-                ? fixer.replaceText(existingTypeParams, '<ElementRef<HTMLElement>>')
-                : fixer.insertTextAfter(node.callee, '<ElementRef<HTMLElement>>');
+                ? fixer.replaceText(existingTypeParams, `<${elementRef}<HTMLElement>>`)
+                : fixer.insertTextAfter(node.callee, `<${elementRef}<HTMLElement>>`);
             },
           });
           return;
@@ -71,9 +68,9 @@ const noTypedInjectedElementRef = {
               messageId: 'missingGeneric',
               fix(fixer) {
                 const typeFix = existingTypeParams
-                  ? fixer.replaceText(existingTypeParams, `<ElementRef${tokenTypeParamText}>`)
-                  : fixer.insertTextAfter(node.callee, `<ElementRef${tokenTypeParamText}>`);
-                return [typeFix, fixer.replaceText(firstArg, 'ElementRef')];
+                  ? fixer.replaceText(existingTypeParams, `<${elementRef}${tokenTypeParamText}>`)
+                  : fixer.insertTextAfter(node.callee, `<${elementRef}${tokenTypeParamText}>`);
+                return [typeFix, fixer.replaceText(firstArg, elementRef)];
               },
             });
           } else {
@@ -82,7 +79,7 @@ const noTypedInjectedElementRef = {
               node,
               messageId: 'missingGeneric',
               fix(fixer) {
-                return fixer.replaceText(firstArg, 'ElementRef');
+                return fixer.replaceText(firstArg, elementRef);
               },
             });
           }

package/src/rules/no-unused-class-member.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
  * Disallows class members that are declared but never read within the class body.
  *
@@ -42,22 +44,17 @@ const extractIdentifiers = (str) => str.match(/\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g) ?
 
 /**
  * Returns info about the Angular decorators applied to a class node.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  * @returns {{ isComponent: boolean, isAngularClass: boolean }}
  */
-const getDecoratorInfo = (classNode) => {
+const getDecoratorInfo = (sourceCode, classNode) => {
   const decorators = classNode.decorators ?? [];
   let isComponent = false;
   let isAngularClass = false;
 
   for (const dec of decorators) {
-    const expr = dec.expression;
-    const name =
-      expr?.type === 'CallExpression' && expr.callee?.type === 'Identifier'
-        ? expr.callee.name
-        : expr?.type === 'Identifier'
-          ? expr.name
-          : null;
+    const name = getAngularDecoratorName(sourceCode, dec);
 
     if (name && ANGULAR_DECORATORS.has(name)) {
       isAngularClass = true;
@@ -167,7 +164,7 @@ const noUnusedClassMember = {
     return {
       ClassBody(node) {
         const classNode = node.parent;
-        const { isComponent, isAngularClass } = getDecoratorInfo(classNode);
+        const { isComponent, isAngularClass } = getDecoratorInfo(context.sourceCode, classNode);
         const hostBound = getHostBoundMembers(classNode);
         classStack.push({
           classBody: node,

package/src/rules/prefer-clone-equal.js

@@ -25,6 +25,8 @@
  *   import { clone, equal } from '@ethlete/core';
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferCloneEqual = {
   meta: {
@@ -70,21 +72,21 @@ const preferCloneEqual = {
         }
 
         // ── structuredClone(expr) ─────────────────────────────────────────────
-        if (callee.type === 'Identifier' && callee.name === 'structuredClone') {
+        if (isGlobalReference(context.sourceCode, callee) && callee.name === 'structuredClone') {
           context.report({ node, messageId: 'preferClone', data: { method: 'structuredClone()' } });
         }
       },
 
-      ImportDeclaration(node) {
-        const src = node.source.value;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (!reference) return;
+        const src = reference.source;
 
         // ── lodash cloneDeep / isEqual ────────────────────────────────────────
         // import { cloneDeep } from 'lodash' / 'lodash-es'
         // import { isEqual } from 'lodash' / 'lodash-es'
         if (src === 'lodash' || src === 'lodash-es') {
-          for (const specifier of node.specifiers) {
-            if (specifier.type !== 'ImportSpecifier') continue;
-            const name = specifier.imported.name;
+          for (const { name } of reference.named) {
             if (name === 'cloneDeep') {
               context.report({ node, messageId: 'preferClone', data: { method: 'lodash cloneDeep' } });
             } else if (name === 'isEqual') {

package/src/rules/prefer-concise-angular-host-directives.js

@@ -1,29 +1,16 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 /** @typedef {import('estree').Property & { range: [number, number] }} TPropertyNode */
 /** @typedef {import('estree').ArrayExpression & { elements: Array<import('estree').Expression | import('estree').SpreadElement | null> }} TArrayExpressionNode */
 /** @typedef {import('estree').ObjectExpression & { properties: Array<TPropertyNode | import('estree').SpreadElement> }} TObjectExpressionNode */
-/** @typedef {{ hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; segmentText: string }} TPropertyEntry */
+/** @typedef {{ bodyText: string; hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; trailingText: string }} TPropertyEntry */
 
 const HOST_DIRECTIVE_PROPERTY_ORDER = ['directive', 'inputs', 'outputs'];
 
-/**
- * @param {import('eslint').Rule.Node} node
- */
-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;
-};
-
 /**
  * @param {import('estree').Property['key']} key
  */
@@ -98,22 +85,24 @@ const buildSortedObjectText = (node, sourceCode) => {
     /** @param {TPropertyNode} property @param {number} originalIndex @returns {TPropertyEntry} */
     (property, originalIndex) => {
       const tokenAfter = sourceCode.getTokenAfter(property);
-      const hasComma = Boolean(tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',');
-      const segmentEnd = hasComma && tokenAfter ? tokenAfter.range[0] : property.range[1];
-      const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
+      const comma = tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',' ? tokenAfter : null;
+      const bodyText = sourceCode.text.slice(segmentStart, property.range[1]);
+      const afterProperty = comma ?? property;
+      const trailingComment = sourceCode
+        .getCommentsAfter(afterProperty)
+        .filter((comment) => comment.loc?.start.line === property.loc?.end.line)
+        .at(-1);
+      const trailingEnd = trailingComment?.range ? trailingComment.range[1] : afterProperty.range[1];
 
-      if (hasComma && tokenAfter) {
-        segmentStart = tokenAfter.range[1];
-      } else {
-        segmentStart = property.range[1];
-      }
+      segmentStart = trailingEnd;
 
       return {
-        hasComma,
+        bodyText,
+        hasComma: Boolean(comma),
         originalIndex,
         orderIndex: orderIndexMap.get(getPropertyName(property.key)) ?? HOST_DIRECTIVE_PROPERTY_ORDER.length,
         property,
-        segmentText,
+        trailingText: trailingComment ? sourceCode.text.slice(afterProperty.range[1], trailingEnd) : '',
       };
     },
   );
@@ -131,7 +120,10 @@ const buildSortedObjectText = (node, sourceCode) => {
   return (
     '{' +
     sortedEntries
-      .map((entry, index) => `${entry.segmentText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}`)
+      .map(
+        (entry, index) =>
+          `${entry.bodyText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}${entry.trailingText}`,
+      )
       .join('') +
     suffix +
     '}'
@@ -182,7 +174,7 @@ const preferConciseAngularHostDirectives = {
 
     return {
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const hostDirectives = getHostDirectivesArray(decoratorName, node);
@@ -199,10 +191,12 @@ const preferConciseAngularHostDirectives = {
             const directiveValue = getDirectiveValueNode(config);
             if (!directiveValue) continue;
 
+            const hasComments = sourceCode.getCommentsInside(config).length > 0;
+
             context.report({
               node: config,
               messageId: 'preferShorthand',
-              fix: (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
+              fix: hasComments ? null : (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
             });
 
             continue;

package/src/rules/prefer-concise-angular-style-metadata.js

@@ -1,24 +1,11 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {import('estree').Property} TPropertyNode */
 /** @typedef {import('estree').Expression | import('estree').SpreadElement | null} TArrayElement */
 
-/**
- * @param {import('eslint').Rule.Node} node
- */
-const isComponentDecorator = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return false;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' && expression.callee.name === 'Component';
-  }
-
-  return expression.type === 'Identifier' && expression.name === 'Component';
-};
-
 /**
  * @param {import('estree').Property['key']} key
  */
@@ -62,7 +49,7 @@ const preferConciseAngularStyleMetadata = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        if (!isComponentDecorator(node)) return;
+        if (getAngularDecoratorName(context.sourceCode, node) !== 'Component') return;
 
         const decorator = /** @type {any} */ (node);
         const expression = decorator.expression;
@@ -71,11 +58,16 @@ const preferConciseAngularStyleMetadata = {
         const metadata = expression.arguments[0];
         if (!metadata || metadata.type !== 'ObjectExpression') return;
 
+        const hasStyleUrl = metadata.properties.some(
+          (/** @type {any} */ property) => property.type === 'Property' && getPropertyName(property.key) === 'styleUrl',
+        );
+
         for (const property of metadata.properties) {
           if (property.type !== 'Property') continue;
 
           const propertyName = getPropertyName(property.key);
           if (propertyName !== 'styleUrls' && propertyName !== 'styles') continue;
+          if (propertyName === 'styleUrls' && hasStyleUrl) continue;
 
           const singleElement = getSingleArrayElement(property);
           if (!singleElement) continue;

package/src/rules/prefer-element-dimensions.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Prefers signalElementDimensions / signalHostElementDimensions from @ethlete/core
  * over imperatively reading element size properties inside reactive contexts
@@ -46,10 +48,11 @@ const ELEMENT_SIZE_METHODS = new Set(['getBoundingClientRect', 'getClientRects']
 /**
  * Returns the name of the wrapping reactive context ('effect' | 'computed') if
  * the node is inside one, crossing exactly one function boundary.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.Node} node
  * @returns {string | null}
  */
-const getReactiveContext = (node) => {
+const getReactiveContext = (sourceCode, node) => {
   let crossedFunctionBoundary = false;
   let current = node.parent;
 
@@ -58,13 +61,9 @@ const getReactiveContext = (node) => {
       crossedFunctionBoundary = true;
     }
 
-    if (
-      crossedFunctionBoundary &&
-      current.type === 'CallExpression' &&
-      current.callee.type === 'Identifier' &&
-      (current.callee.name === 'effect' || current.callee.name === 'computed')
-    ) {
-      return current.callee.name;
+    if (crossedFunctionBoundary && current.type === 'CallExpression') {
+      const calleeName = getImportedName(sourceCode, current.callee, ANGULAR_CORE);
+      if (calleeName === 'effect' || calleeName === 'computed') return calleeName;
     }
 
     current = current.parent;
@@ -95,7 +94,7 @@ const preferElementDimensions = {
         if (node.property.type !== 'Identifier') return;
         if (!ELEMENT_SIZE_PROPS.has(node.property.name)) return;
 
-        const reactiveCtx = getReactiveContext(node);
+        const reactiveCtx = getReactiveContext(context.sourceCode, node);
         if (!reactiveCtx) return;
 
         context.report({
@@ -112,7 +111,7 @@ const preferElementDimensions = {
         if (callee.property.type !== 'Identifier') return;
         if (!ELEMENT_SIZE_METHODS.has(callee.property.name)) return;
 
-        const reactiveCtx = getReactiveContext(node);
+        const reactiveCtx = getReactiveContext(context.sourceCode, node);
         if (!reactiveCtx) return;
 
         context.report({

package/src/rules/prefer-linked-signal.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /**
  * Prefer linkedSignal over setting a signal inside an effect().
  *
@@ -22,31 +24,48 @@
  * GOOD:
  *   selectedItem = linkedSignal(() => this.items()[0] ?? null);
  *
- * NOTE: Only flag when .set() is called directly inside an effect() callback.
- * Setting signals outside effects (in methods, event handlers, etc.) is fine.
+ * Also flagged when the write sits behind an `if`, as long as every branch only
+ * writes signals: `linkedSignal` keeps the previous value for the untaken branch.
  */
 
 /**
- * Returns true only when the `.set()` call node is a *pure derivation* inside
- * an effect() callback — meaning:
- *
- * 1. The IMMEDIATE enclosing function (the first function boundary walking up
- *    from the node) IS the first argument passed to `effect()`. This ensures
- *    that `.set()` calls nested inside `untracked(() => ...)` or other inner
- *    functions within the effect are NOT flagged — those are intentional
- *    write-back patterns, not derivations.
- *
- * 2. The `.set()` call is the SOLE expression in that callback:
- *    - Arrow with expression body: `effect(() => sig.set(x))`
- *    - Block body with a single ExpressionStatement: `effect(() => { sig.set(x); })`
+ * @param {any} node
+ * @returns {boolean}
+ */
+const isSetCall = (node) =>
+  node.type === 'CallExpression' &&
+  node.callee.type === 'MemberExpression' &&
+  node.callee.property.type === 'Identifier' &&
+  node.callee.property.name === 'set' &&
+  node.arguments.length === 1;
+
+/**
+ * A statement that does nothing but write signals: a lone `.set()`, a block holding one, or an
+ * `if`/`else` whose every branch is one.
  *
- *    Multi-statement blocks (even if they end with a `.set()`) indicate that the
- *    effect is performing side effects alongside the signal write, so they are
- *    not flagged either.
+ * @param {any} statement
+ * @returns {boolean}
+ */
+const isSetOnlyStatement = (statement) => {
+  if (!statement) return false;
+  if (statement.type === 'ExpressionStatement') return isSetCall(statement.expression);
+  if (statement.type === 'BlockStatement') return statement.body.length === 1 && isSetOnlyStatement(statement.body[0]);
+  if (statement.type === 'IfStatement') {
+    return (
+      isSetOnlyStatement(statement.consequent) && (!statement.alternate || isSetOnlyStatement(statement.alternate))
+    );
+  }
+  return false;
+};
+
+/**
+ * True when the `.set()` call sits directly in an `effect()` callback (not in a nested function such as
+ * `untracked(() => …)`) and that callback does nothing but write signals, optionally behind an `if`.
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.Node} node The `.set()` CallExpression node
  */
-const isPureSetInDirectEffectCallback = (node) => {
+const isPureSetInDirectEffectCallback = (sourceCode, node) => {
   // Find the immediate enclosing function (cross exactly one boundary).
   let current = node.parent;
   let immediateFunction = null;
@@ -66,27 +85,16 @@ const isPureSetInDirectEffectCallback = (node) => {
   if (
     !funcParent ||
     funcParent.type !== 'CallExpression' ||
-    funcParent.callee.type !== 'Identifier' ||
-    funcParent.callee.name !== 'effect' ||
+    !isImportedAs(sourceCode, funcParent.callee, 'effect') ||
     funcParent.arguments[0] !== immediateFunction
   ) {
     return false;
   }
 
-  // The .set() must be the sole expression — no surrounding statements.
-  // Case A: arrow with expression body — the body IS the .set() call.
-  if (immediateFunction.type === 'ArrowFunctionExpression' && immediateFunction.body === node) {
-    return true;
-  }
-
-  // Case B: block body with exactly one ExpressionStatement wrapping the .set() call.
   const body = immediateFunction.body;
-  return (
-    body.type === 'BlockStatement' &&
-    body.body.length === 1 &&
-    body.body[0].type === 'ExpressionStatement' &&
-    body.body[0].expression === node
-  );
+  if (body.type !== 'BlockStatement') return body === node;
+
+  return node.parent.type === 'ExpressionStatement' && body.body.length === 1 && isSetOnlyStatement(body.body[0]);
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -106,14 +114,7 @@ const preferLinkedSignal = {
   create(context) {
     return {
       CallExpression(node) {
-        const { callee } = node;
-
-        if (
-          callee.type === 'MemberExpression' &&
-          callee.property.type === 'Identifier' &&
-          callee.property.name === 'set' &&
-          isPureSetInDirectEffectCallback(node)
-        ) {
+        if (isSetCall(node) && isPureSetInDirectEffectCallback(context.sourceCode, node)) {
           context.report({ node, messageId: 'preferLinkedSignal' });
         }
       },

package/src/rules/prefer-match-media.js

@@ -37,6 +37,10 @@
  *   // … etc. All from @ethlete/core.
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isImportedAs } = require('./internals/import-resolution');
+
+const CDK_LAYOUT = '@angular/cdk/layout';
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferMatchMedia = {
   meta: {
@@ -72,25 +76,17 @@ const preferMatchMedia = {
 
         // ── inject(BreakpointObserver) ────────────────────────────────────────
         if (
-          callee.type === 'Identifier' &&
-          callee.name === 'inject' &&
-          node.arguments[0]?.type === 'Identifier' &&
-          node.arguments[0].name === 'BreakpointObserver'
+          isImportedAs(context.sourceCode, callee, 'inject') &&
+          isImportedAs(context.sourceCode, node.arguments[0], 'BreakpointObserver', CDK_LAYOUT)
         ) {
           context.report({ node, messageId: 'noBreakpointObserver' });
         }
       },
 
-      ImportDeclaration(node) {
-        // ── import { BreakpointObserver } from '@angular/cdk/layout' ─────────
-        if (node.source.value !== '@angular/cdk/layout') return;
-        const hasBreakpointObserver = node.specifiers.some(
-          (s) =>
-            s.type === 'ImportSpecifier' &&
-            s.imported.type === 'Identifier' &&
-            s.imported.name === 'BreakpointObserver',
-        );
-        if (hasBreakpointObserver) {
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== CDK_LAYOUT) return;
+        if (reference.named.some((entry) => entry.name === 'BreakpointObserver')) {
           context.report({ node, messageId: 'noBreakpointObserver' });
         }
       },

package/src/rules/prefer-present-tense-output.js

@@ -72,7 +72,7 @@ const rule = {
   create(context) {
     return {
       PropertyDefinition(node) {
-        const io = getReactiveIo(node);
+        const io = getReactiveIo(context.sourceCode, node);
         if (!io || io.kind !== 'output') return;
 
         const word = lastWord(io.name);

package/src/rules/prefer-rxjs-timer.js

@@ -19,6 +19,8 @@
  *   fromEvent(element, 'click').pipe(takeUntilDestroyed()).subscribe(handler);
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferRxjsTimer = {
   meta: {
@@ -47,7 +49,7 @@ const preferRxjsTimer = {
         const { callee } = node;
 
         // ── Global timer calls ────────────────────────────────────────────────
-        if (callee.type === 'Identifier') {
+        if (isGlobalReference(context.sourceCode, callee)) {
           const { name } = callee;
           if (name === 'setTimeout') {
             context.report({ node, messageId: 'preferTimer' });

package/src/rules/require-dollar-suffix.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getImportedName } = require('./internals/import-resolution');
+
 /**
  * Requires observable variables and class properties to be suffixed with `$`.
  *
@@ -45,9 +47,10 @@ const RXJS_SUBJECT_CTORS = new Set(['Subject', 'BehaviorSubject', 'ReplaySubject
 
 /**
  * Returns true if the expression looks like an Observable.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isObservableInit = (node) => {
+const isObservableInit = (sourceCode, node) => {
   if (!node) return false;
 
   // someObs.pipe(...)
@@ -61,12 +64,12 @@ const isObservableInit = (node) => {
   }
 
   // from(...), of(...), interval(...), etc.
-  if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && RXJS_CREATORS.has(node.callee.name)) {
+  if (node.type === 'CallExpression' && RXJS_CREATORS.has(getImportedName(sourceCode, node.callee, 'rxjs') ?? '')) {
     return true;
   }
 
   // new Subject(), new BehaviorSubject(...), etc.
-  if (node.type === 'NewExpression' && node.callee.type === 'Identifier' && RXJS_SUBJECT_CTORS.has(node.callee.name)) {
+  if (node.type === 'NewExpression' && RXJS_SUBJECT_CTORS.has(getImportedName(sourceCode, node.callee, 'rxjs') ?? '')) {
     return true;
   }
 
@@ -92,7 +95,7 @@ const rule = {
      * @param {any} initNode
      */
     const checkBinding = (name, reportNode, initNode) => {
-      if (!isObservableInit(initNode)) return;
+      if (!isObservableInit(context.sourceCode, initNode)) return;
       if (name.endsWith('$')) return;
 
       context.report({