@ethlete/eslint-plugin 0.1.0-beta.5

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

@@ -0,0 +1,233 @@
+// @ts-check
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @param {string} value
+ */
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * @param {any} decorator
+ */
+const getDecoratorCall = (decorator) => {
+  if (!decorator || decorator.type !== 'Decorator') 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,
+    metadata,
+  };
+};
+
+/**
+ * @param {any} property
+ */
+const getPropertyKeyName = (property) => {
+  if (!property || property.computed) return null;
+
+  const key = property.key;
+  if (key.type === 'Identifier') return key.name;
+  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+
+  return null;
+};
+
+/**
+ * @param {any} metadata
+ * @param {string} propertyName
+ */
+const getMetadataProperty = (metadata, propertyName) => {
+  for (const property of metadata.properties) {
+    if (!property || property.type !== 'Property' || property.computed) continue;
+
+    const keyName = getPropertyKeyName(property);
+
+    if (keyName === propertyName) {
+      return property;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} node
+ */
+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 || '';
+  }
+
+  return null;
+};
+
+/**
+ * @param {string} filePath
+ */
+const readFileIfExists = (filePath) => {
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf8');
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+};
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const getContextFilename = (context) => {
+  const filename = context.physicalFilename || context.filename;
+
+  if (!filename || filename === '<input>' || filename === '<text>') {
+    return null;
+  }
+
+  return filename;
+};
+
+/**
+ * @param {string} memberName
+ * @param {string | null} template
+ */
+const templateReferencesMember = (memberName, template) => {
+  if (!template) return false;
+
+  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(`\\*[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'),
+    new RegExp(`\\[[^\\]]+\\]\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
+    new RegExp(`\\([^\\)]+\\)\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
+    new RegExp(`\\([^\\)]+\\)\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
+  ];
+
+  return patterns.some((pattern) => pattern.test(template));
+};
+
+/**
+ * @param {string | null} keyName
+ */
+const isDynamicHostBindingKey = (keyName) => {
+  if (!keyName) return false;
+
+  return keyName.startsWith('[') || keyName.startsWith('(') || keyName.startsWith('@');
+};
+
+/**
+ * @param {any} classNode
+ */
+const getAngularMetadata = (classNode) => {
+  for (const decorator of classNode.decorators || []) {
+    const call = getDecoratorCall(decorator);
+    if (!call) continue;
+
+    if (call.name === 'Component' || call.name === 'Directive') {
+      return call;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * @param {string} memberName
+ * @param {string | null} text
+ */
+const textReferencesMember = (memberName, text) => {
+  if (!text) return false;
+
+  const pattern = new RegExp(`\\b${escapeRegExp(memberName)}\\b`, 'u');
+  return pattern.test(text);
+};
+
+/**
+ * @param {string} memberName
+ * @param {any} metadata
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const isReferencedFromTemplateOrHostMetadata = (memberName, metadata, context) => {
+  const templateProperty = getMetadataProperty(metadata, 'template');
+  if (templateProperty && templateReferencesMember(memberName, getStringValue(templateProperty.value))) {
+    return true;
+  }
+
+  const templateUrlProperty = getMetadataProperty(metadata, 'templateUrl');
+  if (templateUrlProperty) {
+    const templateUrl = getStringValue(templateUrlProperty.value);
+    const filename = getContextFilename(context);
+
+    if (templateUrl && filename) {
+      const templatePath = path.resolve(path.dirname(filename), templateUrl);
+      const templateText = readFileIfExists(templatePath);
+      if (templateReferencesMember(memberName, templateText)) {
+        return true;
+      }
+    }
+  }
+
+  const hostProperty = getMetadataProperty(metadata, 'host');
+  if (hostProperty && hostProperty.value.type === 'ObjectExpression') {
+    for (const property of hostProperty.value.properties) {
+      if (!property || property.type !== 'Property') continue;
+      if (!isDynamicHostBindingKey(getPropertyKeyName(property))) continue;
+
+      if (textReferencesMember(memberName, getStringValue(property.value))) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+/**
+ * @param {any} node
+ */
+const getMemberName = (node) => {
+  if (node.key?.type === 'Identifier') return node.key.name;
+  if (node.key?.type === 'Literal' && typeof node.key.value === 'string') return node.key.value;
+
+  return null;
+};
+
+/**
+ * @param {any} classNode
+ * @param {string} memberName
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const isReferencedFromTemplateOrHost = (classNode, memberName, context) => {
+  const angularMetadata = getAngularMetadata(classNode);
+
+  if (!angularMetadata) {
+    return false;
+  }
+
+  return isReferencedFromTemplateOrHostMetadata(memberName, angularMetadata.metadata, context);
+};
+
+module.exports = {
+  getAngularMetadata,
+  getMemberName,
+  isReferencedFromTemplateOrHost,
+};

package/src/rules/internals/implemented-contract-members.js

@@ -0,0 +1,294 @@
+// @ts-check
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+
+/** @type {Map<string, import('typescript').SourceFile | null>} */
+const SOURCE_FILE_CACHE = new Map();
+
+/**
+ * @param {string} filePath
+ */
+const readFileIfExists = (filePath) => {
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf8');
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+};
+
+/**
+ * @param {{ filePath: string, text?: string | null }} config
+ */
+const getSourceFile = ({ filePath, text = null }) => {
+  if (text !== null) {
+    return ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  }
+
+  if (SOURCE_FILE_CACHE.has(filePath)) {
+    return SOURCE_FILE_CACHE.get(filePath) ?? null;
+  }
+
+  const fileText = readFileIfExists(filePath);
+
+  if (fileText === null) {
+    SOURCE_FILE_CACHE.set(filePath, null);
+    return null;
+  }
+
+  const sourceFile = ts.createSourceFile(filePath, fileText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  SOURCE_FILE_CACHE.set(filePath, sourceFile);
+  return sourceFile;
+};
+
+/**
+ * @param {string} importingFilePath
+ * @param {string} specifier
+ */
+const resolveRelativeModule = (importingFilePath, specifier) => {
+  if (!specifier.startsWith('.')) {
+    return null;
+  }
+
+  const basePath = path.resolve(path.dirname(importingFilePath), specifier);
+  const candidates = [
+    `${basePath}.ts`,
+    `${basePath}.tsx`,
+    `${basePath}.d.ts`,
+    path.join(basePath, 'index.ts'),
+    path.join(basePath, 'index.d.ts'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * @param {import('typescript').TypeElement | import('typescript').ClassElement} member
+ */
+const getMemberName = (member) => {
+  if (!member.name) return null;
+
+  if (ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name)) {
+    return member.name.text;
+  }
+
+  if (ts.isStringLiteral(member.name) || ts.isNumericLiteral(member.name)) {
+    return String(member.name.text);
+  }
+
+  return null;
+};
+
+/**
+ * @param {{ sourceFile: import('typescript').SourceFile, typeName: string, currentFilePath: string, visited: Set<string>, currentFileText?: string | null }} config
+ */
+const collectMemberNamesForType = ({ sourceFile, typeName, currentFilePath, visited, currentFileText = null }) => {
+  const visitKey = `${sourceFile.fileName}::${typeName}`;
+  if (visited.has(visitKey)) {
+    return new Set();
+  }
+
+  visited.add(visitKey);
+
+  /** @type {Set<string>} */
+  const memberNames = new Set();
+
+  /**
+   * @param {import('typescript').TypeNode | undefined} typeNode
+   * @param {string} filePath
+   * @param {string | null} fileText
+   */
+  const collectFromTypeNode = (typeNode, filePath, fileText) => {
+    if (!typeNode) {
+      return;
+    }
+
+    if (ts.isTypeLiteralNode(typeNode)) {
+      for (const member of typeNode.members) {
+        const memberName = getMemberName(member);
+        if (memberName) memberNames.add(memberName);
+      }
+
+      return;
+    }
+
+    if (ts.isIntersectionTypeNode(typeNode)) {
+      for (const part of typeNode.types) {
+        collectFromTypeNode(part, filePath, fileText);
+      }
+
+      return;
+    }
+
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+      const referencedMembers = collectMemberNamesForTypeByName({
+        sourceFile: getSourceFile({ filePath, text: fileText }),
+        typeName: typeNode.typeName.text,
+        currentFilePath: filePath,
+        visited,
+        currentFileText: fileText,
+      });
+
+      for (const referencedMember of referencedMembers) {
+        memberNames.add(referencedMember);
+      }
+    }
+  };
+
+  const statements = sourceFile.statements;
+
+  for (const statement of statements) {
+    if (ts.isInterfaceDeclaration(statement) && statement.name.text === typeName) {
+      for (const member of statement.members) {
+        const memberName = getMemberName(member);
+        if (memberName) memberNames.add(memberName);
+      }
+
+      if (statement.heritageClauses) {
+        for (const clause of statement.heritageClauses) {
+          if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+
+          for (const heritageType of clause.types) {
+            if (!ts.isIdentifier(heritageType.expression)) continue;
+
+            const inheritedMembers = collectMemberNamesForTypeByName({
+              sourceFile,
+              typeName: heritageType.expression.text,
+              currentFilePath,
+              visited,
+              currentFileText,
+            });
+
+            for (const inheritedMember of inheritedMembers) {
+              memberNames.add(inheritedMember);
+            }
+          }
+        }
+      }
+
+      return memberNames;
+    }
+
+    if (ts.isTypeAliasDeclaration(statement) && statement.name.text === typeName) {
+      collectFromTypeNode(
+        statement.type,
+        sourceFile.fileName,
+        sourceFile.fileName === currentFilePath ? currentFileText : null,
+      );
+      return memberNames;
+    }
+  }
+
+  for (const statement of statements) {
+    if (!ts.isImportDeclaration(statement)) continue;
+    if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    if (!statement.importClause || !statement.importClause.namedBindings) continue;
+    if (!ts.isNamedImports(statement.importClause.namedBindings)) continue;
+
+    for (const element of statement.importClause.namedBindings.elements) {
+      const localName = element.name.text;
+      if (localName !== typeName) continue;
+
+      const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+      const resolvedModulePath = resolveRelativeModule(sourceFile.fileName, statement.moduleSpecifier.text);
+      if (!resolvedModulePath) {
+        return memberNames;
+      }
+
+      const importedSourceFile = getSourceFile({ filePath: resolvedModulePath });
+      if (!importedSourceFile) {
+        return memberNames;
+      }
+
+      const importedMembers = collectMemberNamesForTypeByName({
+        sourceFile: importedSourceFile,
+        typeName: importedName,
+        currentFilePath: resolvedModulePath,
+        visited,
+      });
+
+      for (const importedMember of importedMembers) {
+        memberNames.add(importedMember);
+      }
+
+      return memberNames;
+    }
+  }
+
+  return memberNames;
+};
+
+/**
+ * @param {{ sourceFile: import('typescript').SourceFile | null, typeName: string, currentFilePath: string, visited: Set<string>, currentFileText?: string | null }} config
+ */
+const collectMemberNamesForTypeByName = ({
+  sourceFile,
+  typeName,
+  currentFilePath,
+  visited,
+  currentFileText = null,
+}) => {
+  if (!sourceFile) {
+    return new Set();
+  }
+
+  return collectMemberNamesForType({
+    sourceFile,
+    typeName,
+    currentFilePath,
+    visited,
+    currentFileText,
+  });
+};
+
+/**
+ * @param {{ classNode: any, context: import('eslint').Rule.RuleContext }} config
+ */
+const getImplementedContractMemberNames = ({ classNode, context }) => {
+  const filename = context.physicalFilename || context.filename;
+  if (!filename || filename === '<input>' || filename === '<text>') {
+    return new Set();
+  }
+
+  const currentSourceFile = getSourceFile({ filePath: filename, text: context.sourceCode.text });
+  if (!currentSourceFile) {
+    return new Set();
+  }
+
+  /** @type {Set<string>} */
+  const memberNames = new Set();
+
+  for (const implementedType of classNode.implements || []) {
+    if (!implementedType.expression || implementedType.expression.type !== 'Identifier') continue;
+
+    const typeMemberNames = collectMemberNamesForTypeByName({
+      sourceFile: currentSourceFile,
+      typeName: implementedType.expression.name,
+      currentFilePath: filename,
+      visited: new Set(),
+      currentFileText: context.sourceCode.text,
+    });
+
+    for (const memberName of typeMemberNames) {
+      memberNames.add(memberName);
+    }
+  }
+
+  return memberNames;
+};
+
+module.exports = {
+  getImplementedContractMemberNames,
+};

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

@@ -0,0 +1,158 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows injecting Angular's ActivatedRoute (fully replaced),
+ * and disallows reading route state directly from an injected Router instance.
+ *
+ * inject(Router) is allowed — it is still needed for navigation (.navigate(),
+ * .navigateByUrl(), .createUrlTree(), etc.).
+ * Reading state properties off it is NOT allowed — use the @ethlete/core signal
+ * utilities instead.
+ *
+ * ❌ ActivatedRoute (fully replaced):
+ *   inject(ActivatedRoute)
+ *   import { ActivatedRoute } from '@angular/router';
+ *
+ * ❌ Router state property reads:
+ *   this.router.url           → injectUrl()
+ *   this.router.events        → injectRouterEvent()
+ *   this.router.routerState   → injectRouterState()
+ *   this.router.snapshot      → injectRouterState()
+ *   this.router.lastSuccessfulNavigation  → injectRouterState()
+ *   this.router.currentNavigation        → injectRouterState()
+ *
+ * ✅ inject(Router) is still fine for navigation:
+ *   router.navigate(['/path'])
+ *   router.navigateByUrl('/path')
+ *   router.createUrlTree(['/path'])
+ *
+ * ✅ Use the @ethlete/core router utilities for state:
+ *   injectUrl(), injectRoute(), injectRouterEvent(), injectRouterState(),
+ *   injectIsRouterInitialized(), injectQueryParam(key), injectPathParam(key),
+ *   injectQueryParams(), injectPathParams(), injectFragment(),
+ *   injectRouteData(), injectRouteDataItem(key), injectRouteTitle(),
+ *   injectQueryParamChanges(), injectPathParamChanges()
+ */
+
+/**
+ * Router properties that expose route state and must not be read directly.
+ * @type {Map<string, string>}
+ */
+const ROUTER_STATE_PROPS = new Map([
+  ['url', "injectUrl() from '@ethlete/core'"],
+  ['events', "injectRouterEvent() from '@ethlete/core'"],
+  ['routerState', "injectRouterState() from '@ethlete/core'"],
+  ['snapshot', "injectRouterState() from '@ethlete/core'"],
+  ['lastSuccessfulNavigation', "injectRouterState() from '@ethlete/core'"],
+  ['currentNavigation', "injectRouterState() from '@ethlete/core'"],
+]);
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noAngularRouterApi = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        "Disallow injecting 'ActivatedRoute' (fully replaced) and reading state properties off an injected 'Router'.",
+      recommended: true,
+    },
+    messages: {
+      noActivatedRoute:
+        "Do not inject 'ActivatedRoute'. Use reactive signal utilities from '@ethlete/core' instead: 'injectQueryParam(key)', 'injectPathParam(key)', 'injectQueryParams()', 'injectPathParams()', 'injectFragment()', 'injectRouteData()', 'injectRouteDataItem(key)', or 'injectRouteTitle()'. All return reactive signals and are SSR-safe.",
+      noRouterStateProp:
+        "Do not read 'router.{{prop}}' directly. Use {{replacement}} instead — it returns a reactive signal and is SSR-safe. Use inject(Router) only for navigation (.navigate(), .navigateByUrl()).",
+    },
+    schema: [],
+  },
+  create(context) {
+    /**
+     * Names of variables/properties assigned from inject(Router).
+     * We track identifiers whose initializer is inject(Router) so we can
+     * detect property access on them anywhere in the file.
+     * @type {Set<string>}
+     */
+    const routerBindings = new Set();
+
+    return {
+      // ── 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'
+        ) {
+          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'
+        ) {
+          routerBindings.add(node.key.name);
+        }
+      },
+
+      // ── Detect router.{stateProp} access ───────────────────────────────────
+      MemberExpression(node) {
+        if (node.property.type !== 'Identifier') return;
+        const prop = node.property.name;
+        if (!ROUTER_STATE_PROPS.has(prop)) return;
+
+        // Check object is a known router binding (direct: router.url)
+        // or a this.router.url / self.router.url pattern
+        const obj = node.object;
+        const isDirectBinding = obj.type === 'Identifier' && routerBindings.has(obj.name);
+        const isThisBinding =
+          obj.type === 'MemberExpression' &&
+          obj.object.type === 'ThisExpression' &&
+          obj.property.type === 'Identifier' &&
+          routerBindings.has(obj.property.name);
+
+        if (!isDirectBinding && !isThisBinding) return;
+
+        context.report({
+          node,
+          messageId: 'noRouterStateProp',
+          data: { prop, replacement: ROUTER_STATE_PROPS.get(prop) },
+        });
+      },
+
+      // ── 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;
+          }
+        }
+      },
+
+      // ── 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') {
+          context.report({ node, messageId: 'noActivatedRoute' });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noAngularRouterApi;