tessl/npm-eslint-plugin-eslint-plugin

An ESLint plugin for linting ESLint plugins with 32 rules, preset configurations, and utility functions for rule development.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Rule Linting

Name: tessl/npm-eslint-plugin-eslint-plugin
Author: tessl

26 specialized rules for linting ESLint rule files, ensuring proper metadata, message handling, and best practices in rule development.

Capabilities

Meta Property Rules

Rules that enforce proper structure and content of rule meta objects.

/**
 * Requires rules to have a type property in meta
 */
declare const requireMetaType: Rule.RuleModule;

/**
 * Requires rules to have a documentation URL in meta.docs
 */
declare const requireMetaDocsUrl: Rule.RuleModule;

/**
 * Requires rules to have a description in meta.docs
 */
declare const requireMetaDocsDescription: Rule.RuleModule;

/**
 * Requires rules to have recommended status in meta.docs
 */
declare const requireMetaDocsRecommended: Rule.RuleModule;

/**
 * Requires rules to have fixable property when they provide fixes
 */
declare const requireMetaFixable: Rule.RuleModule;

/**
 * Requires rules to have hasSuggestions property when they provide suggestions
 */
declare const requireMetaHasSuggestions: Rule.RuleModule;

/**
 * Requires rules to have a valid schema
 */
declare const requireMetaSchema: Rule.RuleModule;

/**
 * Requires rules to implement default options
 */
declare const requireMetaDefaultOptions: Rule.RuleModule;

/**
 * Requires schema descriptions for rule options
 */
declare const requireMetaSchemaDescription: Rule.RuleModule;

/**
 * Enforces meta property ordering in rule objects
 */
declare const metaPropertyOrdering: Rule.RuleModule;

Usage Examples:

// Rule with proper meta structure
module.exports = {
  meta: {
    type: 'problem',                    // Required by require-meta-type
    docs: {
      description: 'Description here',  // Required by require-meta-docs-description
      url: 'https://example.com/rule',  // Required by require-meta-docs-url
      recommended: true                 // Required by require-meta-docs-recommended
    },
    fixable: 'code',                   // Required by require-meta-fixable if rule provides fixes
    hasSuggestions: true,              // Required by require-meta-has-suggestions if rule provides suggestions
    schema: [                          // Required by require-meta-schema
      {
        type: 'object',
        description: 'Options object'   // Required by require-meta-schema-description
      }
    ]
  },
  create(context) {
    // Rule implementation
  }
};

Message Handling Rules

Rules that enforce proper message ID usage and prevent common message-related mistakes.

/**
 * Prefer messageIds over messages in context.report()
 */
declare const preferMessageIds: Rule.RuleModule;

/**
 * Disallow messageIds that are missing from messages
 */
declare const noMissingMessageIds: Rule.RuleModule;

/**
 * Disallow unused messageIds in rule messages
 */
declare const noUnusedMessageIds: Rule.RuleModule;

/**
 * Disallow missing placeholders in rule messages
 */
declare const noMissingPlaceholders: Rule.RuleModule;

/**
 * Disallow unused placeholders in rule messages
 */
declare const noUnusedPlaceholders: Rule.RuleModule;

/**
 * Prefer placeholders over concatenation in rule messages
 */
declare const preferPlaceholders: Rule.RuleModule;

/**
 * Enforce consistent format of rule report messages
 */
declare const reportMessageFormat: Rule.RuleModule;

Usage Examples:

// Good: Using messageIds with proper placeholders
module.exports = {
  meta: {
    messages: {
      unexpected: 'Unexpected {{type}} at {{location}}.',
      missing: 'Missing required property.'
    }
  },
  create(context) {
    return {
      Property(node) {
        context.report({
          node,
          messageId: 'unexpected',  // Good: using messageId
          data: {
            type: node.type,        // Good: providing data for placeholder
            location: 'here'
          }
        });
      }
    };
  }
};

// Bad: Direct message without messageId
context.report({
  node,
  message: 'This is bad'  // Bad: prefer messageIds
});

Deprecated API Rules

Rules that prevent usage of deprecated ESLint APIs and patterns.

/**
 * Disallow usage of deprecated methods on rule context objects
 */
declare const noDeprecatedContextMethods: Rule.RuleModule;

/**
 * Disallow usage of deprecated report API
 */
declare const noDeprecatedReportApi: Rule.RuleModule;

/**
 * Disallow use of meta.replacedBy property
 */
declare const noMetaReplacedBy: Rule.RuleModule;

Usage Examples:

// Bad: Using deprecated context methods
create(context) {
  const sourceCode = context.getSourceCode();  // Bad: deprecated method
  return {
    Program(node) {
      sourceCode.getSource(node);  // Bad: deprecated method
    }
  };
}

// Good: Using current API
create(context) {
  const sourceCode = context.sourceCode;  // Good: current API
  return {
    Program(node) {
      sourceCode.getText(node);  // Good: current method
    }
  };
}

Schema and Property Rules

Rules that ensure proper schema usage and prevent problematic property patterns.

/**
 * Disallow default values in meta.schema
 */
declare const noMetaSchemaDefault: Rule.RuleModule;

/**
 * Disallow property access on AST nodes
 */
declare const noPropertyInNode: Rule.RuleModule;

Fixer and Output Rules

Rules that ensure proper fixer function implementation and return statements.

/**
 * Require return statement in fixer functions
 */
declare const fixerReturn: Rule.RuleModule;

/**
 * Disallow unnecessary token range operations
 */
declare const noUselessTokenRange: Rule.RuleModule;

/**
 * Prefer replaceText over remove/insertTextAfter/insertTextBefore
 */
declare const preferReplaceText: Rule.RuleModule;

Usage Examples:

// Good: Proper fixer implementation
create(context) {
  return {
    Rule(node) {
      context.report({
        node,
        messageId: 'problem',
        fix(fixer) {
          return fixer.replaceText(node, 'replacement');  // Good: returns fix
        }
      });
    }
  };
}

// Bad: Fixer without return
fix(fixer) {
  fixer.replaceText(node, 'replacement');  // Bad: missing return
}

Rule Style and Structure Rules

Rules that enforce consistent rule patterns and preferred structures.

/**
 * Prefer object-style rule format over function-style
 */
declare const preferObjectRule: Rule.RuleModule;

/**
 * Prefer using null over undefined for test case output
 */
declare const preferOutputNull: Rule.RuleModule;

Complete Rules List

All 26 rules for linting ESLint rule files:

declare const allRuleRules: {
  'fixer-return': Rule.RuleModule;
  'meta-property-ordering': Rule.RuleModule;
  'no-deprecated-context-methods': Rule.RuleModule;
  'no-deprecated-report-api': Rule.RuleModule;
  'no-meta-replaced-by': Rule.RuleModule;
  'no-meta-schema-default': Rule.RuleModule;
  'no-missing-message-ids': Rule.RuleModule;
  'no-missing-placeholders': Rule.RuleModule;
  'no-property-in-node': Rule.RuleModule;
  'no-unused-message-ids': Rule.RuleModule;
  'no-unused-placeholders': Rule.RuleModule;
  'no-useless-token-range': Rule.RuleModule;
  'prefer-message-ids': Rule.RuleModule;
  'prefer-object-rule': Rule.RuleModule;
  'prefer-placeholders': Rule.RuleModule;
  'prefer-replace-text': Rule.RuleModule;
  'report-message-format': Rule.RuleModule;
  'require-meta-default-options': Rule.RuleModule;
  'require-meta-docs-description': Rule.RuleModule;
  'require-meta-docs-recommended': Rule.RuleModule;
  'require-meta-docs-url': Rule.RuleModule;
  'require-meta-fixable': Rule.RuleModule;
  'require-meta-has-suggestions': Rule.RuleModule;
  'require-meta-schema-description': Rule.RuleModule;
  'require-meta-schema': Rule.RuleModule;
  'require-meta-type': Rule.RuleModule;
};