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

package/src/rules/inject-member-accessibility.js

@@ -2,33 +2,17 @@
 'use strict';
 
 const { getMemberName, isReferencedFromTemplateOrHost } = require('./internals/angular-member-visibility');
+const { isImportedAs } = require('./internals/import-resolution');
+const { buildAccessibilityFix } = require('./internals/member-accessibility-fix');
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isInjectCall = (node) => {
+const isInjectCall = (sourceCode, node) => {
   if (!node || node.type !== 'PropertyDefinition' || !node.value) return false;
   if (node.value.type !== 'CallExpression') return false;
-  return node.value.callee.type === 'Identifier' && node.value.callee.name === 'inject';
-};
-
-/**
- * @param {any} node
- * @param {import('eslint').SourceCode} sourceCode
- * @param {'private' | 'protected'} expectedAccessibility
- */
-const buildFix = (node, sourceCode, expectedAccessibility) => {
-  const keyToken = sourceCode.getFirstToken(node.key);
-  if (!keyToken) return null;
-
-  if (node.accessibility) {
-    const firstToken = sourceCode.getFirstToken(node);
-    if (!firstToken) return null;
-
-    return (fixer) => fixer.replaceText(firstToken, expectedAccessibility);
-  }
-
-  return (fixer) => fixer.insertTextBefore(keyToken, `${expectedAccessibility} `);
+  return isImportedAs(sourceCode, node.value.callee, 'inject');
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -54,7 +38,7 @@ const injectMemberAccessibility = {
 
     return {
       PropertyDefinition(node) {
-        if (!isInjectCall(node)) return;
+        if (!isInjectCall(context.sourceCode, node)) return;
 
         const classNode = node.parent && node.parent.type === 'ClassBody' ? node.parent.parent : null;
         if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
@@ -63,6 +47,7 @@ const injectMemberAccessibility = {
         if (!memberName) return;
 
         const isTemplateOrHostVisible = isReferencedFromTemplateOrHost(classNode, memberName, context);
+        const isAbstractClass = classNode.abstract === true;
 
         if (isTemplateOrHostVisible) {
           if (node.accessibility === 'protected' || node.accessibility === 'public') return;
@@ -71,7 +56,7 @@ const injectMemberAccessibility = {
             node,
             messageId: 'shouldBeProtected',
             data: { name: memberName },
-            fix: buildFix(node, sourceCode, 'protected'),
+            fix: buildAccessibilityFix(node, sourceCode, 'protected'),
           });
 
           return;
@@ -79,11 +64,24 @@ const injectMemberAccessibility = {
 
         if (node.accessibility === 'private' || node.accessibility === 'public') return;
 
+        if (isAbstractClass) {
+          if (node.accessibility === 'protected') return;
+
+          context.report({
+            node,
+            messageId: 'shouldBeProtected',
+            data: { name: memberName },
+            fix: buildAccessibilityFix(node, sourceCode, 'protected'),
+          });
+
+          return;
+        }
+
         context.report({
           node,
           messageId: 'shouldBePrivate',
           data: { name: memberName },
-          fix: buildFix(node, sourceCode, 'private'),
+          fix: buildAccessibilityFix(node, sourceCode, 'private'),
         });
       },
     };

package/src/rules/internals/angular-io.js

@@ -18,6 +18,10 @@
  * (or null when the property is not a reactive I/O declaration).
  */
 
+const { ANGULAR_CORE, getImportedName } = require('./import-resolution');
+
+const ANGULAR_IO_SOURCES = [ANGULAR_CORE, '@angular/core/rxjs-interop'];
+
 /** Factory identifier → I/O kind. */
 const IO_FACTORIES = {
   input: 'input',
@@ -31,48 +35,61 @@ const IO_FACTORIES = {
  * plain form (`input(...)`) and the `.required` member form
  * (`input.required(...)`).
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} callee
  * @returns {string | null}
  */
-const getFactoryName = (callee) => {
+const getFactoryName = (sourceCode, callee) => {
   if (!callee) return null;
 
-  if (callee.type === 'Identifier') return callee.name;
-
-  // input.required(...) / model.required(...)
-  if (
+  const isRequired =
     callee.type === 'MemberExpression' &&
     !callee.computed &&
-    callee.object.type === 'Identifier' &&
     callee.property.type === 'Identifier' &&
-    callee.property.name === 'required'
-  ) {
-    return callee.object.name;
-  }
+    callee.property.name === 'required';
 
-  return null;
+  return getImportedName(sourceCode, isRequired ? callee.object : callee, ANGULAR_IO_SOURCES);
 };
 
 /**
  * Classifies a class property as an Angular signal input/model/output.
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node  PropertyDefinition
  * @returns {{ kind: 'input' | 'model' | 'output', name: string, keyNode: any } | null}
  */
-const getReactiveIo = (node) => {
+const getReactiveIo = (sourceCode, node) => {
   if (!node || node.type !== 'PropertyDefinition') return null;
   if (node.computed || node.key.type !== 'Identifier') return null;
 
   const value = node.value;
   if (!value || value.type !== 'CallExpression') return null;
 
-  const factory = getFactoryName(value.callee);
+  const factory = getFactoryName(sourceCode, value.callee);
   if (!factory) return null;
 
+  if (!Object.hasOwn(IO_FACTORIES, factory)) return null;
   const kind = /** @type {Record<string, 'input' | 'model' | 'output'>} */ (IO_FACTORIES)[factory];
   if (!kind) return null;
 
-  return { kind, name: node.key.name, keyNode: node.key };
+  let name = node.key.name;
+  for (const argument of value.arguments) {
+    if (argument.type !== 'ObjectExpression') continue;
+
+    const aliasProperty = argument.properties.find(
+      (property) =>
+        property.type === 'Property' &&
+        !property.computed &&
+        ((property.key.type === 'Identifier' && property.key.name === 'alias') ||
+          (property.key.type === 'Literal' && property.key.value === 'alias')),
+    );
+    if (aliasProperty?.value.type === 'Literal' && typeof aliasProperty.value.value === 'string') {
+      name = aliasProperty.value.value;
+      break;
+    }
+  }
+
+  return { kind, name, keyNode: node.key };
 };
 
 module.exports = { getReactiveIo };

package/src/rules/internals/angular-member-visibility.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./import-resolution');
+
 const fs = require('fs');
 const path = require('path');
 
@@ -10,21 +12,22 @@ const path = require('path');
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} decorator
  */
-const getDecoratorCall = (decorator) => {
-  if (!decorator || decorator.type !== 'Decorator') return null;
+const getDecoratorCall = (sourceCode, decorator) => {
+  const name = getAngularDecoratorName(sourceCode, decorator);
+  if (!name) return null;
 
   const expression = decorator.expression;
   if (expression.type !== 'CallExpression') return null;
-  if (expression.callee.type !== 'Identifier') return null;
   if (expression.arguments.length === 0) return null;
 
   const metadata = expression.arguments[0];
   if (!metadata || metadata.type !== 'ObjectExpression') return null;
 
   return {
-    name: expression.callee.name,
+    name,
     metadata,
   };
 };
@@ -67,8 +70,8 @@ const getStringValue = (node) => {
   if (!node) return null;
   if (node.type === 'Literal' && typeof node.value === 'string') return node.value;
 
-  if (node.type === 'TemplateLiteral' && node.expressions.length === 0 && node.quasis.length === 1) {
-    return node.quasis[0].value.cooked || '';
+  if (node.type === 'TemplateLiteral') {
+    return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join(' ');
   }
 
   return null;
@@ -111,9 +114,9 @@ const templateReferencesMember = (memberName, template) => {
 
   const escapedName = escapeRegExp(memberName);
   const patterns = [
-    new RegExp(`\\{\\{[\\s\\S]*?\\b${escapedName}\\b[\\s\\S]*?\\}\\}`, 'u'),
-    new RegExp(`@[a-zA-Z]+\\s*\\([\\s\\S]*?\\b${escapedName}\\b[\\s\\S]*?\\)`, 'u'),
-    new RegExp(`@let\\s+[a-zA-Z_$][\\w$]*\\s*=\\s*[\\s\\S]*?\\b${escapedName}\\b`, 'u'),
+    new RegExp(`\\{\\{[^{}]*\\b${escapedName}\\b[^{}]*\\}\\}`, 'u'),
+    new RegExp(`@[a-zA-Z]+(?:\\s+if)?\\s*\\([^)]*\\b${escapedName}\\b[^)]*\\)`, 'u'),
+    new RegExp(`@let\\s+[a-zA-Z_$][\\w$]*\\s*=\\s*[^;]*\\b${escapedName}\\b`, 'u'),
     new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
     new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
     new RegExp(`\\[[^\\]]+\\]\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
@@ -135,11 +138,12 @@ const isDynamicHostBindingKey = (keyName) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  */
-const getAngularMetadata = (classNode) => {
+const getAngularMetadata = (sourceCode, classNode) => {
   for (const decorator of classNode.decorators || []) {
-    const call = getDecoratorCall(decorator);
+    const call = getDecoratorCall(sourceCode, decorator);
     if (!call) continue;
 
     if (call.name === 'Component' || call.name === 'Directive') {
@@ -217,7 +221,7 @@ const getMemberName = (node) => {
  * @param {import('eslint').Rule.RuleContext} context
  */
 const isReferencedFromTemplateOrHost = (classNode, memberName, context) => {
-  const angularMetadata = getAngularMetadata(classNode);
+  const angularMetadata = getAngularMetadata(context.sourceCode, classNode);
 
   if (!angularMetadata) {
     return false;

package/src/rules/internals/angular-metadata-fix.js

@@ -0,0 +1,22 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} metadata
+ * @param {any} property
+ */
+const getMetadataEntryRemovalRange = (sourceCode, metadata, property) => {
+  const entries = metadata.properties;
+  const index = entries.indexOf(property);
+  const openingBrace = sourceCode.getFirstToken(metadata);
+  const closingBrace = sourceCode.getLastToken(metadata);
+
+  if (!openingBrace || !closingBrace || index === -1) return property.range;
+  if (entries.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
+  if (index < entries.length - 1) return [property.range[0], entries[index + 1].range[0]];
+
+  return [entries[index - 1].range[1], property.range[1]];
+};
+
+module.exports = { getMetadataEntryRemovalRange };

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/internals/member-accessibility-fix.js

@@ -0,0 +1,26 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {any} node
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {'private' | 'protected' | 'public'} accessibility
+ */
+const buildAccessibilityFix = (node, sourceCode, accessibility) => {
+  const decoratorEnd = node.decorators?.at(-1)?.range[1] ?? node.range[0];
+  const tokens = sourceCode.getTokens(node);
+  const accessibilityToken = tokens.find(
+    (token) => token.range[0] >= decoratorEnd && token.value === node.accessibility,
+  );
+
+  if (accessibilityToken) {
+    return (fixer) => fixer.replaceText(accessibilityToken, accessibility);
+  }
+
+  const insertionToken = tokens.find((token) => token.range[0] >= decoratorEnd);
+  if (!insertionToken) return null;
+
+  return (fixer) => fixer.insertTextBefore(insertionToken, `${accessibility} `);
+};
+
+module.exports = { buildAccessibilityFix };

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.
@@ -18,9 +25,9 @@
  *   import { Title, Meta } from '@angular/platform-browser';
  *
  * ✅ Use the @ethlete/core SEO utilities:
- *   import { injectTitleBinding, injectMetaBinding } from '@ethlete/core';
- *   const titleBinding = injectTitleBinding();
- *   const metaBinding  = injectMetaBinding();
+ *   import { applyHeadTitleBinding, applyMetaBinding } from '@ethlete/core';
+ *   applyHeadTitleBinding(title);
+ *   applyMetaBinding(meta);
  */
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -32,12 +39,12 @@ const rule = {
     },
     schema: [],
     messages: {
-      noInjectTitle: "Do not inject Angular's Title service. Use injectTitleBinding() from '@ethlete/core' instead.",
-      noInjectMeta: "Do not inject Angular's Meta service. Use injectMetaBinding() from '@ethlete/core' instead.",
+      noInjectTitle: "Do not inject Angular's Title service. Use applyHeadTitleBinding() from '@ethlete/core' instead.",
+      noInjectMeta: "Do not inject Angular's Meta service. Use applyMetaBinding() from '@ethlete/core' instead.",
       noImportTitle:
-        "Do not import Title from '@angular/platform-browser'. Use injectTitleBinding() from '@ethlete/core' instead.",
+        "Do not import Title from '@angular/platform-browser'. Use applyHeadTitleBinding() from '@ethlete/core' instead.",
       noImportMeta:
-        "Do not import Meta from '@angular/platform-browser'. Use injectMetaBinding() from '@ethlete/core' instead.",
+        "Do not import Meta from '@angular/platform-browser'. Use applyMetaBinding() from '@ethlete/core' instead.",
     },
   },
   create(context) {
@@ -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' });
         }