@ethlete/eslint-plugin 0.1.0-next.2 → 0.1.0-next.3

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-public-property.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getMemberName, isReferencedFromTemplateOrHost } = require('./internals/angular-member-visibility');
+
 /**
  * @param {any} node
  */
@@ -23,24 +25,57 @@ const noPublicProperty = {
     messages: {
       noPublicProperty:
         'No public keyword on class properties. The only exception is an injected member that intentionally exposes an external API.',
+      shouldBeProtected:
+        'Member `{{name}}` should be protected instead of public because it is referenced from a template or host binding.',
     },
   },
   create(context) {
+    /**
+     * @param {any} node
+     */
+    const removePublicFix = (node) => {
+      const publicToken = context.sourceCode.getFirstToken(node, (token) => token.value === 'public');
+      const nextToken = publicToken ? context.sourceCode.getTokenAfter(publicToken) : null;
+      if (!publicToken || !nextToken) return null;
+
+      return (fixer) => fixer.removeRange([publicToken.range[0], nextToken.range[0]]);
+    };
+
+    /**
+     * @param {any} node
+     */
+    const replacePublicWithProtectedFix = (node) => {
+      const publicToken = context.sourceCode.getFirstToken(node, (token) => token.value === 'public');
+      if (!publicToken) return null;
+
+      return (fixer) => fixer.replaceText(publicToken, 'protected');
+    };
+
     return {
       PropertyDefinition(node) {
         if (node.accessibility !== 'public') return;
         if (isInjectCall(node.value)) return;
 
+        const classNode = node.parent && node.parent.type === 'ClassBody' ? node.parent.parent : null;
+        const memberName = getMemberName(node);
+        const isTemplateVisible =
+          classNode && memberName ? isReferencedFromTemplateOrHost(classNode, memberName, context) : false;
+
+        if (isTemplateVisible) {
+          context.report({
+            node,
+            messageId: 'shouldBeProtected',
+            data: { name: memberName },
+            fix: replacePublicWithProtectedFix(node),
+          });
+
+          return;
+        }
+
         context.report({
           node,
           messageId: 'noPublicProperty',
-          fix(fixer) {
-            const publicToken = context.sourceCode.getFirstToken(node, (token) => token.value === 'public');
-            const nextToken = publicToken ? context.sourceCode.getTokenAfter(publicToken) : null;
-            if (!publicToken || !nextToken) return null;
-
-            return fixer.removeRange([publicToken.range[0], nextToken.range[0]]);
-          },
+          fix: removePublicFix(node),
         });
       },
     };

package/src/rules/no-redundant-internal.js

@@ -0,0 +1,94 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('eslint').Rule.Node} node
+ */
+const getAttachedInternalComment = (sourceCode, node) => {
+  const comments = sourceCode.getCommentsBefore(node);
+  const attachedComment = comments[comments.length - 1];
+
+  if (!attachedComment || attachedComment.type !== 'Block') {
+    return null;
+  }
+
+  const textBetween = sourceCode.text.slice(attachedComment.range[1], node.range[0]);
+
+  if (textBetween.trim() !== '') {
+    return null;
+  }
+
+  return /@internal\b/u.test(attachedComment.value) ? attachedComment : null;
+};
+
+/**
+ * @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 'member';
+};
+
+/**
+ * @param {any} node
+ */
+const getMemberKind = (node) => {
+  if (node.type === 'MethodDefinition') return 'method';
+  return 'property';
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noRedundantInternal = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow redundant @internal usage on class members that are already hidden by accessibility.',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      redundantInternal:
+        '`@internal` is redundant on {{kind}} `{{name}}` because {{accessibility}} members are already hidden from consumers.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    /**
+     * @param {any} node
+     */
+    const checkMember = (node) => {
+      const internalComment = getAttachedInternalComment(sourceCode, node);
+
+      if (!internalComment) {
+        return;
+      }
+
+      if (node.accessibility !== 'private' && node.accessibility !== 'protected') {
+        return;
+      }
+
+      context.report({
+        node: internalComment,
+        messageId: 'redundantInternal',
+        data: {
+          accessibility: node.accessibility,
+          kind: getMemberKind(node),
+          name: getMemberName(node),
+        },
+        fix: (fixer) => fixer.removeRange([internalComment.range[0], node.range[0]]),
+      });
+    };
+
+    return {
+      PropertyDefinition: checkMember,
+      MethodDefinition: checkMember,
+    };
+  },
+};
+
+module.exports = noRedundantInternal;