or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

best-practices-rules.mdcode-quality-rules.mdindex.mdplugin-configuration.mdstyle-formatting-rules.mdtype-safety-rules.md
tile.json

tessl/npm-typescript-eslint--eslint-plugin

TypeScript plugin for ESLint providing comprehensive lint rules for TypeScript codebases

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@typescript-eslint/eslint-plugin@8.42.x

To install, run

npx @tessl/cli install tessl/npm-typescript-eslint--eslint-plugin@8.42.0

index.mddocs/

TypeScript ESLint Plugin

The TypeScript ESLint Plugin is a comprehensive ESLint plugin specifically designed for TypeScript codebases, providing 131 lint rules that help developers write better, more consistent TypeScript code. It integrates seamlessly with the TypeScript compiler and ESLint ecosystem to provide static analysis and code quality enforcement for TypeScript projects.

Package Information

  • Package Name: @typescript-eslint/eslint-plugin
  • Package Type: npm (ESLint plugin)
  • Language: TypeScript/JavaScript
  • Installation: npm install @typescript-eslint/eslint-plugin

Core Imports

// Main plugin import
import plugin from "@typescript-eslint/eslint-plugin";

// Individual rules access
import rules from "@typescript-eslint/eslint-plugin/use-at-your-own-risk/rules";

// Raw plugin with additional exports
import { plugin, parser, flatConfigs } from "@typescript-eslint/eslint-plugin/use-at-your-own-risk/raw-plugin";

For CommonJS:

// Main plugin import
const plugin = require("@typescript-eslint/eslint-plugin");

// Individual rules access
const rules = require("@typescript-eslint/eslint-plugin/use-at-your-own-risk/rules");

// Raw plugin with additional exports
const { plugin, parser, flatConfigs } = require("@typescript-eslint/eslint-plugin/use-at-your-own-risk/raw-plugin");

Basic Usage

// Basic ESLint configuration (legacy format)
module.exports = {
  parser: "@typescript-eslint/parser",
  plugins: ["@typescript-eslint"],
  extends: [
    "@typescript-eslint/recommended",
    "@typescript-eslint/recommended-type-checked"
  ],
  parserOptions: {
    project: "./tsconfig.json"
  },
  rules: {
    "@typescript-eslint/no-unused-vars": "error",
    "@typescript-eslint/explicit-function-return-type": "warn"
  }
};

// Flat configuration format (ESLint 9+)
import tseslint from "@typescript-eslint/eslint-plugin/use-at-your-own-risk/raw-plugin";

export default [
  ...tseslint.flatConfigs["flat/recommended"],
  {
    languageOptions: {
      parser: tseslint.parser,
      parserOptions: {
        project: "./tsconfig.json"
      }
    },
    plugins: {
      "@typescript-eslint": tseslint.plugin
    },
    rules: {
      "@typescript-eslint/no-unused-vars": "error"
    }
  }
];

Architecture

The TypeScript ESLint Plugin is built around several key components:

  • Plugin System: ESLint plugin architecture providing rules, configurations, and metadata
  • Rule Engine: 108 individual lint rules covering TypeScript-specific language features and best practices
  • Configuration Presets: Pre-configured rule sets (recommended, strict, stylistic) for different project needs
  • Type Integration: Seamless integration with TypeScript compiler for type-aware linting
  • Dual Config Support: Compatible with both legacy ESLint RC and modern flat configuration formats

Capabilities

Plugin Configuration

Core plugin setup and configuration presets for different project requirements. Provides both legacy and modern configuration formats.

interface PluginExport {
  configs: Record<string, ClassicConfig.Config>;
  meta: FlatConfig.PluginMeta;
  rules: TypeScriptESLintRules;
}

interface RawPluginExport {
  flatConfigs: Record<string, FlatConfig.Config | FlatConfig.ConfigArray>;
  parser: FlatConfig.Parser;
  plugin: PluginExport;
}

Plugin Configuration

Type Safety Rules

Rules focused on TypeScript type safety, preventing common type-related errors and enforcing proper type usage.

// Example type safety rules
interface TypeSafetyRules {
  "no-unsafe-assignment": RuleModule;
  "no-unsafe-call": RuleModule;
  "no-unsafe-member-access": RuleModule;
  "no-unsafe-return": RuleModule;
  "no-floating-promises": RuleModule;
  "await-thenable": RuleModule;
  "no-misused-promises": RuleModule;
}

Type Safety Rules

Code Quality Rules

Rules that enforce code quality, consistency, and best practices specific to TypeScript development.

// Example code quality rules
interface CodeQualityRules {
  "consistent-type-imports": RuleModule;
  "consistent-type-definitions": RuleModule;
  "explicit-function-return-type": RuleModule;
  "explicit-member-accessibility": RuleModule;
  "no-duplicate-enum-values": RuleModule;
  "no-empty-interface": RuleModule;
}

Code Quality Rules

Style and Formatting Rules

Rules focused on code style, naming conventions, and formatting preferences for TypeScript code.

// Example stylistic rules
interface StyleRules {
  "naming-convention": RuleModule;
  "member-ordering": RuleModule;
  "array-type": RuleModule;
  "consistent-type-assertions": RuleModule;
  "method-signature-style": RuleModule;
  "class-literal-property-style": RuleModule;
}

Style and Formatting Rules

Best Practices Rules

Rules that promote TypeScript and JavaScript best practices, preventing common pitfalls and anti-patterns.

// Example best practice rules
interface BestPracticeRules {
  "prefer-optional-chain": RuleModule;
  "prefer-nullish-coalescing": RuleModule;
  "prefer-as-const": RuleModule;
  "prefer-for-of": RuleModule;
  "prefer-includes": RuleModule;
  "no-unnecessary-type-assertion": RuleModule;
}

Best Practices Rules

Core Types

interface RuleModuleWithMetaDocs<
  TMessageIds extends string,
  TOptions extends readonly unknown[],
  TDocs extends object
> {
  meta: RuleMetaData<TMessageIds, TDocs>;
  create(context: RuleContext<TMessageIds, TOptions>): RuleListener;
}

interface ESLintPluginDocs {
  extendsBaseRule?: boolean | string;
  recommended?: RuleRecommendation | RuleRecommendationAcrossConfigs<unknown[]>;
  requiresTypeChecking?: boolean;
}

type ESLintPluginRuleModule = RuleModuleWithMetaDocs<
  string,
  readonly unknown[],
  ESLintPluginDocs
>;

interface TypeScriptESLintRules {
  [ruleName: string]: ESLintPluginRuleModule;
}

interface ClassicConfig {
  extends?: string[];
  plugins?: string[];
  rules?: Record<string, RuleConfig>;
  parser?: string;
  parserOptions?: ParserOptions;
}

interface FlatConfig {
  languageOptions?: {
    parser?: Parser;
    parserOptions?: ParserOptions;
  };
  plugins?: Record<string, Plugin>;
  rules?: Record<string, RuleConfig>;
}