@ethlete/eslint-plugin 0.1.0-next.1 → 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-empty-angular-metadata-arrays.js

@@ -0,0 +1,104 @@
+// @ts-check
+'use strict';
+
+/** @typedef {'Component' | 'Directive'} TDecoratorName */
+
+/**
+ * @param {import('estree').Property['key']} key
+ */
+const getPropertyName = (key) => {
+  if (key.type === 'Identifier') return key.name;
+  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+  return null;
+};
+
+/**
+ * @param {import('eslint').Rule.Node} node
+ * @returns {TDecoratorName | null}
+ */
+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('eslint').SourceCode} sourceCode
+ * @param {any} metadata
+ * @param {any} property
+ */
+const getRemovalRange = (sourceCode, metadata, property) => {
+  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
+  const propertyIndex = properties.indexOf(property);
+  const openingBrace = sourceCode.getFirstToken(metadata);
+  const closingBrace = sourceCode.getLastToken(metadata);
+
+  if (!openingBrace || !closingBrace) return property.range;
+  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
+  if (propertyIndex < properties.length - 1) return [property.range[0], properties[propertyIndex + 1].range[0]];
+
+  return [properties[propertyIndex - 1].range[1], property.range[1]];
+};
+
+const MESSAGE_IDS = {
+  hostDirectives: 'noEmptyHostDirectives',
+  imports: 'noEmptyImports',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEmptyAngularMetadataArrays = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow empty Angular metadata arrays such as imports: [] and hostDirectives: [].',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noEmptyImports: 'Remove empty imports: [] from Angular metadata.',
+      noEmptyHostDirectives: 'Remove empty hostDirectives: [] from Angular metadata.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      /** @param {import('eslint').Rule.Node} node */
+      Decorator(node) {
+        const decoratorName = getDecoratorName(node);
+        if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
+
+        const decorator = /** @type {any} */ (node);
+        const expression = decorator.expression;
+        if (expression.type !== 'CallExpression' || expression.arguments.length === 0) return;
+
+        const metadata = expression.arguments[0];
+        if (!metadata || metadata.type !== 'ObjectExpression') return;
+
+        for (const property of metadata.properties) {
+          if (property.type !== 'Property') continue;
+
+          const propertyName = getPropertyName(property.key);
+          if (propertyName !== 'imports' && propertyName !== 'hostDirectives') continue;
+          if (property.value.type !== 'ArrayExpression' || property.value.elements.length > 0) continue;
+
+          context.report({
+            node: property,
+            messageId: MESSAGE_IDS[propertyName],
+            fix(fixer) {
+              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noEmptyAngularMetadataArrays;

package/src/rules/no-empty-newlines-between-imports.js

@@ -0,0 +1,45 @@
+// @ts-check
+'use strict';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEmptyNewlinesBetweenImports = {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'Disallow empty blank lines between consecutive import declarations.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noEmptyLine: 'Remove empty blank lines between import declarations.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      Program(node) {
+        const importDeclarations = node.body.filter((statement) => statement.type === 'ImportDeclaration');
+
+        for (let index = 1; index < importDeclarations.length; index += 1) {
+          const previousImport = importDeclarations[index - 1];
+          const currentImport = importDeclarations[index];
+          const textBetween = sourceCode.text.slice(previousImport.range[1], currentImport.range[0]);
+
+          if (/\S/.test(textBetween)) continue;
+          if (!/\n\s*\n/.test(textBetween)) continue;
+
+          context.report({
+            node: currentImport,
+            messageId: 'noEmptyLine',
+            fix(fixer) {
+              return fixer.replaceTextRange([previousImport.range[1], currentImport.range[0]], '\n');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noEmptyNewlinesBetweenImports;