typescript-eslint/typescript-eslint

Features

• TypeScript Validators - Enables static analysis and linting for TypeScript codebases by leveraging the compiler type checker.
• Type-Aware Analysis Engines - Leverages type information from the compiler to identify complex issues and enforce patterns that require understanding underlying data structures.
• Language Parsers - Converts source code into an abstract syntax tree that allows standard analysis tools to inspect and report on language-specific syntax.
• Type-Aware Inspection Engines - Performs deep code inspection by accessing compiler type information to detect complex errors.
• TypeScript Linting Plugins - Provides a set of rules and parsers that enable standard linting workflows to inspect TypeScript projects.
• Type-Aware Linting - Leverages compiler type information to detect complex errors that standard syntax-only tools cannot identify.
• Code Quality and Analysis - Applies predefined rule sets to identify common programming errors and maintain consistent formatting through static analysis.
• Compiler-Level Analyzers - Performs static analysis by leveraging type information from the compiler to identify complex patterns and errors.
• Type Integrity Enforcement - Restricts unsafe types and explicit any declarations to ensure strict type integrity throughout the codebase.
• Compiler-Integrated Analysis - Integrates directly with the compiler to perform deep, type-aware analysis of code relationships.
• Coding Standards Enforcement - Applies a comprehensive suite of rules to identify common bugs, enforce best practices, and maintain stylistic consistency.
• Managed Code Analyzers - Accesses the compiler type checker to identify nuanced bugs and best practice violations that require deep understanding of code structure.
• Static Code Analysis Tools - Provides a framework for parsing source code into syntax trees to identify bugs and enforce consistency.
• Static Analysis Rules - Applies modular visitor patterns to traverse syntax trees and enforce coding standards.
• Core Rule Extensions - Provides language-compatible versions of standard analysis rules that replace base rules to ensure accurate inspection of modern syntax.
• Static Code Analyzers - Identifies best practice violations, potential bugs, and stylistic inconsistencies by applying static analysis rules.
• Analysis Configuration Automators - Automatically detects project configuration files to simplify the setup of type-aware analysis across complex repositories.
• Unsafe Type Detectors - Flags code patterns where typed values are assigned, called, returned, or passed as arguments to prevent the spread of unsafe types.
• Type Safety - Identifies and flags unsafe patterns that bypass type checking to maintain strict type integrity.
• Any Type Restrictions - Flags explicit any usage to encourage safer, more precise type definitions throughout the codebase.
• Incompatible Rule Replacements - Provides specialized versions of standard analysis rules that correctly parse and inspect language syntax where original core rules would crash.
• Project Configuration Management - Discovers and maps project configuration files to analysis rules automatically to eliminate manual path management.
• Developer Tools - Tooling for TypeScript support in ESLint.
• Static Analysis Tools - TypeScript language extension for ESLint.
• Type Restriction Rules - Defines a configurable list of specific type names to ban throughout a codebase while supporting custom error messages.
• Monorepo Linting Configuration - Simplifies the configuration of linting rules and type-aware analysis across interconnected projects.
• Function Signature Enforcement - Promotes the use of explicit function signatures by identifying generic types that lack specific parameter and return information.
• Exception Type Enforcers - Requires that caught exceptions and rejection callbacks use the unknown type instead of any to ensure safer handling.
• Standardized AST Transformation - Converts source code into a standardized syntax tree structure to enable consistent inspection.
• Development Workflow Automation - Integrates static analysis into development workflows to catch errors before code is committed.
• Object Type Restrictions - Identifies and flags the use of empty object types which often cause confusion by representing any non-nullish value.
• Type Suppression Regulators - Enforces policies on the use of inline directives to ensure that type-checking bypasses are intentional, documented, and removed when unnecessary.
• Compatibility Bridges - Wraps and extends core linting rules to ensure accurate inspection of modern language features.
• Primitive Type Restrictions - Flags the use of uppercase wrapper object types in favor of standard lower-case primitive types.
• Suppression Comment Governors - Enforces best practices for inline directives to prevent accidental global rule disabling and ensure justifications are provided.
• Project Configuration Discovery - Automatically detects and maps project settings to analysis rules to simplify setup in complex environments.
• External File Analyzers - Performs type-aware analysis for files not explicitly included in project configuration files by defining glob patterns.
• Syntax Traversal - Uses recursive tree-walking mechanisms to execute analysis logic at every node of the syntax tree.

Star history