eslint-etc

What is eslint-etc?

The eslint-etc package provides utility functions and types for working with ESLint rules, making it easier to create and manage custom ESLint rules.

What are eslint-etc's main functionalities?

getParserServices

The getParserServices function retrieves the parser services from the ESLint context, which is useful when working with TypeScript nodes in custom ESLint rules.

const { getParserServices } = require('eslint-etc');

module.exports = {
  create(context) {
    const parserServices = getParserServices(context);
    // Use parserServices to interact with TypeScript nodes
  }
};

getTypeServices

The getTypeServices function retrieves type services from the ESLint context, allowing you to get type information for nodes when creating custom ESLint rules.

const { getTypeServices } = require('eslint-etc');

module.exports = {
  create(context) {
    const typeServices = getTypeServices(context);
    // Use typeServices to get type information
  }
};

getTypeChecker

The getTypeChecker function retrieves the TypeScript type checker from the ESLint context, enabling you to perform type checking in custom ESLint rules.

const { getTypeChecker } = require('eslint-etc');

module.exports = {
  create(context) {
    const typeChecker = getTypeChecker(context);
    // Use typeChecker to perform type checking
  }
};

Other packages similar to eslint-etc

typescript-eslint

The typescript-eslint package provides a set of tools for using ESLint with TypeScript, including a parser and a set of rules. It is more comprehensive than eslint-etc, as it includes a parser and a large set of rules specifically for TypeScript.

eslint-plugin-ts

The eslint-plugin-ts package offers a collection of ESLint rules for TypeScript. While it provides a set of rules similar to eslint-etc, it does not offer the same utility functions for creating custom rules.

eslint-plugin-typescript

The eslint-plugin-typescript package provides additional TypeScript-specific rules for ESLint. It focuses more on providing rules rather than utility functions for creating custom rules, making it less flexible than eslint-etc for custom rule development.

README

eslint-etc

More utils for use with eslint.

I use these utils to implement and test my own ESLint rules. That's their primary purpose, so the documentation is ... light.

fromFixture

fromFixture allows TSLint-like fixtures to be used to test ESlint rules. Using fixtures means that you don't have to specify lines and columns. Instead, you underline the failure locations within the fixture, like this:

{
  invalid: [
    fromFixture(stripIndent`
      const name = "alice";
            ~~~~            [foo { "identifier": "name" }]
                   ~~~~~~~  [bar]
      const role = 'cto';
            ~~~~            [foo { "identifier": "role" }]
    `),
    fromFixture(stripIndent`
      const name = "alice";
            ~~~~            [foo { "identifier": "name" }]
      const role = 'cto';
            ~~~~            [foo { "identifier": "role" }]
    `, {
      options: [{ bar: false }]
    }),
  ]
}

which is equivalent to the following:

{
  invalid: [{
    code: `const name = "alice";
const role = 'cto';`,
    errors: [{
      column: 7,
      endColumn: 11,
      line: 1,
      endLine: 1,
      messageId: "foo",
      data: {
        identifier: "name",
      },
    }, {
      column: 14,
      endColumn: 21,
      line: 1,
      endLine: 1,
      messageId: "bar",
      data: {},
    }, {
      column: 7,
      endColumn: 11,
      line: 2,
      endLine: 2,
      messageId: "foo",
      data: {
        identifier: "role",
      },
    }]
  }, {
    code: `const name = "alice";
const role = 'cto';`,
    errors: [{
      column: 7,
      endColumn: 11,
      line: 1,
      endLine: 1,
      messageId: "foo",
      data: {
        identifier: "name",
      },
    }, {
      column: 7,
      endColumn: 11,
      line: 2,
      endLine: 2,
      messageId: "foo",
      data: {
        identifier: "role",
      },
    }],
    options: [{
      bar: false
    }]
  }]
}

Specifying data in the fixture is optional. If it's omitted, data defaults to {}.

The second, optional, argument passed to fromFixture can be used to pass additional test case properties - options and output, etc.

Suggestions

A suggestions array can be passed to fromFixture via its second, optional parameter and, when passed, a suggest annotation can be used within the fixture, like this:

fromFixture(stripIndent`
  const a = "alice";
            ~~~~~~~ [foo suggest]
`, {
  suggestions: [{
    messageId: "suggestionForFoo",
    output: "/* suggestion output goes here */"
  }]
}),

And it's possible to include multiple suggest annotations and suggestions in a single fixture:

fromFixture(stripIndent`
  const a = "alice";
            ~~~~~~~ [foo suggest 0]
  const b = "bob";
            ~~~~~ [bar suggest 1]
`, {
  suggestions: [{
    messageId: "suggestionForFoo",
    output: "/* suggestion for foo output goes here */"
  }, {
    messageId: "suggestionForBar",
    output: "/* suggestion for bar output goes here */"
  }]
}),

The suggest annotations work with the suggestions array in the following manner:

• If suggest is specified with no indices, all suggestions are associated with the annotated error.
• If suggest is specified with indices, suggestions at those indices are associated with the annotated error.
• If suggest is not specified, no suggestions are associated with the annotated error.
• And if suggestions are specified without a suggest annotation being used, fromFixture will throw an error.

And if the rule has both a fixer and suggestions, you can specify an output - for the fixer - in conjunction with a suggestions array:

fromFixture(stripIndent`
  const a = "alice";
            ~~~~~~~ [foo suggest]
`, {
  output: "/* fixer output goes here */",
  suggestions: [{
    messageId: "suggestionForFoo",
    output: "/* suggestion output goes here */"
  }]
}),

Changelog

5.2.1 (2023-03-29)

Fixes

• Widen the TypeScript peer dependency. (6e56ec2)

<a name="5.2.0"></a>