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

package/src/rules/class-member-order.js

@@ -1,13 +1,15 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /** @typedef {'inject' | 'input' | 'output' | 'query' | 'property' | 'constructor' | 'method' | 'private-method'} TMemberGroup */
 /** @typedef {{ dependencies: Set<string>; group: TMemberGroup; groupIndex: number; name: string; node: any; originalIndex: number }} TMemberEntry */
-/** @typedef {TMemberEntry & { segmentText: string }} TSegmentEntry */
 
 const INPUT_APIS = new Set(['input', 'model']);
 const OUTPUT_APIS = new Set(['output', 'outputFromObservable']);
 const QUERY_APIS = new Set(['viewChild', 'viewChildren', 'contentChild', 'contentChildren']);
+const ANGULAR_API_SOURCES = [ANGULAR_CORE, '@angular/core/rxjs-interop'];
 
 /** @type {TMemberGroup[]} */
 const MEMBER_GROUP_ORDER = [
@@ -71,49 +73,70 @@ const getCallRootName = (value) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} value
+ */
+const getAngularCallName = (sourceCode, value) => {
+  if (!value || value.type !== 'CallExpression') return null;
+
+  const { callee } = value;
+  const isRequired =
+    callee.type === 'MemberExpression' &&
+    !callee.computed &&
+    callee.property.type === 'Identifier' &&
+    callee.property.name === 'required';
+
+  return getImportedName(sourceCode, isRequired ? callee.object : callee, ANGULAR_API_SOURCES);
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  * @param {Set<string>} apiNames
  */
-const isPropertyInitializedWith = (node, apiNames) => {
+const isPropertyInitializedWith = (sourceCode, node, apiNames) => {
   if (node.type !== 'PropertyDefinition') return false;
 
-  const apiName = getCallRootName(node.value);
+  const apiName = getAngularCallName(sourceCode, node.value);
   return apiName !== null && apiNames.has(apiName);
 };
 
 const INJECT_HELPER_NAME_PATTERN = /^inject[A-Z]/;
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  */
-const isPropertyInitializedWithInject = (node) => {
+const isPropertyInitializedWithInject = (sourceCode, node) => {
   if (node.type !== 'PropertyDefinition') return false;
+  if (getAngularCallName(sourceCode, node.value) === 'inject') return true;
 
-  const apiName = getCallRootName(node.value);
-  return apiName !== null && (apiName === 'inject' || INJECT_HELPER_NAME_PATTERN.test(apiName));
+  const rootName = getCallRootName(node.value);
+  return rootName !== null && INJECT_HELPER_NAME_PATTERN.test(rootName);
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  * @returns {TMemberGroup | null}
  */
-const getMemberGroup = (node) => {
+const getMemberGroup = (sourceCode, node) => {
   if (node.static) return null;
 
   if (node.type === 'PropertyDefinition') {
-    if (isPropertyInitializedWithInject(node)) {
+    if (isPropertyInitializedWithInject(sourceCode, node)) {
       return 'inject';
     }
 
-    if (isPropertyInitializedWith(node, INPUT_APIS)) {
+    if (isPropertyInitializedWith(sourceCode, node, INPUT_APIS)) {
       return 'input';
     }
 
-    if (isPropertyInitializedWith(node, OUTPUT_APIS)) {
+    if (isPropertyInitializedWith(sourceCode, node, OUTPUT_APIS)) {
       return 'output';
     }
 
-    if (isPropertyInitializedWith(node, QUERY_APIS)) {
+    if (isPropertyInitializedWith(sourceCode, node, QUERY_APIS)) {
       return 'query';
     }
 
@@ -188,12 +211,13 @@ const getInitializerDependencies = (node) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} node
  * @param {number} originalIndex
  * @returns {TMemberEntry | null}
  */
-const toMemberEntry = (node, originalIndex) => {
-  const group = getMemberGroup(node);
+const toMemberEntry = (sourceCode, node, originalIndex) => {
+  const group = getMemberGroup(sourceCode, node);
   const name = getMemberName(node);
 
   if (group === null || name === null) {
@@ -273,12 +297,24 @@ const sortMembers = (members) => {
   return sortedMembers;
 };
 
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} node
+ */
+const getMemberEnd = (sourceCode, node) => {
+  const trailingComments = sourceCode
+    .getCommentsAfter(node)
+    .filter((comment) => comment.loc?.start.line === node.loc.end.line);
+  const lastComment = trailingComments.at(-1);
+
+  return lastComment?.range ? lastComment.range[1] : node.range[1];
+};
+
 /**
  * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classBodyNode
- * @param {TMemberEntry[]} members
  */
-const getSegmentEntries = (sourceCode, classBodyNode, members) => {
+const getSegments = (sourceCode, classBodyNode) => {
   const openingBrace = sourceCode.getFirstToken(classBodyNode);
   const closingBrace = sourceCode.getLastToken(classBodyNode);
 
@@ -288,22 +324,23 @@ const getSegmentEntries = (sourceCode, classBodyNode, members) => {
 
   let segmentStart = openingBrace.range[1];
 
-  const segmentEntries = members.map((member) => {
-    const segmentText = sourceCode.text.slice(segmentStart, member.node.range[1]);
-    segmentStart = member.node.range[1];
+  /** @type {string[]} */
+  const segmentTexts = classBodyNode.body.map(
+    /** @param {any} node */ (node) => {
+      const segmentEnd = getMemberEnd(sourceCode, node);
+      const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
+      segmentStart = segmentEnd;
 
-    return {
-      ...member,
-      segmentText,
-    };
-  });
+      return segmentText;
+    },
+  );
 
   const suffix = sourceCode.text.slice(segmentStart, closingBrace.range[0]);
 
   return {
     closingBrace,
     openingBrace,
-    segmentEntries,
+    segmentTexts,
     suffix,
   };
 };
@@ -314,43 +351,37 @@ const getSegmentEntries = (sourceCode, classBodyNode, members) => {
  * @param {TMemberEntry[]} members
  */
 const buildClassOrderFix = (sourceCode, classBodyNode, members) => {
-  if (classBodyNode.body.length !== members.length) {
-    return null;
-  }
-
   const sortedMembers = sortMembers(members);
 
   if (!sortedMembers) {
     return null;
   }
 
-  const segments = getSegmentEntries(sourceCode, classBodyNode, members);
+  const isAlreadySorted = sortedMembers.every((member, index) => member === members[index]);
 
-  if (!segments) {
+  if (isAlreadySorted) {
     return null;
   }
 
-  const { closingBrace, openingBrace, segmentEntries, suffix } = segments;
-  const segmentEntriesByOriginalIndex = new Map(
-    segmentEntries.map(
-      /** @param {TSegmentEntry} segmentEntry */ (segmentEntry) => [segmentEntry.originalIndex, segmentEntry],
-    ),
-  );
-  const sortedSegmentEntries = sortedMembers.map((member) => segmentEntriesByOriginalIndex.get(member.originalIndex));
+  const segments = getSegments(sourceCode, classBodyNode);
 
-  if (sortedSegmentEntries.some((entry) => entry === undefined)) {
+  if (!segments) {
     return null;
   }
 
-  const isAlreadySorted = sortedSegmentEntries.every((entry, index) => entry === segmentEntries[index]);
-
-  if (isAlreadySorted) {
-    return null;
-  }
+  const { closingBrace, openingBrace, segmentTexts, suffix } = segments;
+  const rankedIndexes = new Set(members.map((member) => member.originalIndex));
+  let nextSortedMember = 0;
 
-  const reorderedBody = sortedSegmentEntries.map((entry) => entry.segmentText).join('') + suffix;
+  const reorderedBody =
+    segmentTexts
+      .map((segmentText, index) =>
+        rankedIndexes.has(index) ? segmentTexts[sortedMembers[nextSortedMember++].originalIndex] : segmentText,
+      )
+      .join('') + suffix;
 
-  return (fixer) => fixer.replaceTextRange([openingBrace.range[1], closingBrace.range[0]], reorderedBody);
+  return (/** @type {import('eslint').Rule.RuleFixer} */ fixer) =>
+    fixer.replaceTextRange([openingBrace.range[1], closingBrace.range[0]], reorderedBody);
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -379,7 +410,7 @@ const classMemberOrder = {
         const members = node.body
           .map(
             /** @param {any} member @param {number} originalIndex */ (member, originalIndex) =>
-              toMemberEntry(member, originalIndex),
+              toMemberEntry(sourceCode, member, originalIndex),
           )
           .filter(Boolean);
 

package/src/rules/consistent-type-definitions.js

@@ -0,0 +1,60 @@
+// @ts-check
+'use strict';
+
+const { rules } = require('@typescript-eslint/eslint-plugin');
+
+const upstream = rules['consistent-type-definitions'];
+
+/**
+ * `@typescript-eslint/consistent-type-definitions` with `'type'`, except that an interface inside a
+ * `declare module`, `declare global` or `namespace` block is left alone.
+ *
+ * Only an interface merges into an existing declaration. The upstream fix turns
+ * `declare module '@ethlete/core' { interface EthleteColorThemeNameRegistry { … } }` into a type
+ * alias, which merges into nothing, and under `skipLibCheck` the registration disappears without an
+ * error.
+ *
+ * BAD:
+ *   interface User { name: string }
+ *
+ * GOOD:
+ *   type User = { name: string };
+ *
+ *   declare module '@ethlete/core' {
+ *     interface EthleteColorThemeNameRegistry { name: 'brand' }
+ *   }
+ */
+
+const isInsideModuleDeclaration = (sourceCode, node) =>
+  sourceCode.getAncestors(node).some((ancestor) => ancestor.type === 'TSModuleDeclaration');
+
+/** @type {import('eslint').Rule.RuleModule} */
+const consistentTypeDefinitions = {
+  meta: {
+    ...upstream.meta,
+    docs: {
+      description:
+        'Use `type` instead of `interface`, except for an interface that augments a module or the global scope.',
+      recommended: true,
+    },
+    schema: [],
+  },
+  create(context) {
+    const { sourceCode } = context;
+
+    const filteredContext = Object.create(context, {
+      options: { value: ['type'] },
+      report: {
+        value: (descriptor) => {
+          if ('node' in descriptor && isInsideModuleDeclaration(sourceCode, descriptor.node)) return;
+
+          context.report(descriptor);
+        },
+      },
+    });
+
+    return upstream.create(filteredContext);
+  },
+};
+
+module.exports = consistentTypeDefinitions;

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

@@ -2,15 +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';
+  return isImportedAs(sourceCode, node.value.callee, 'inject');
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -36,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;

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,42 +35,37 @@ 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;

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,
   };
 };
@@ -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/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,
+};