CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-tslint

An extensible static analysis linter for the TypeScript language

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

index.mddocs/

TSLint

TSLint is an extensible static analysis tool that checks TypeScript code for readability, maintainability, and functionality errors. It provides comprehensive linting capabilities with 163+ built-in rules, 13 formatters, custom rule development APIs, and programmatic integration support.

Note: TSLint is deprecated. The TypeScript team recommends migrating to ESLint with @typescript-eslint/parser for new projects.

Installation

npm install tslint typescript

Package Information

  • Package Name: tslint
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install tslint typescript

Core Imports

import { Linter, Configuration } from 'tslint';
import { RuleFailure, AbstractRule } from 'tslint';

CommonJS:

const { Linter, Configuration } = require('tslint');

Basic Usage

Command Line Interface

# Lint TypeScript files
tslint [options] [files...]

# Basic linting
tslint src/**/*.ts

# With configuration
tslint -c tslint.json src/**/*.ts

# Auto-fix violations
tslint --fix src/**/*.ts

# Generate initial configuration
tslint --init

Programmatic Usage

import { Linter, Configuration } from 'tslint';
import * as fs from 'fs';

// Create linter instance
const linter = new Linter({
    fix: false,
    formatter: 'stylish'
});

// Load configuration
const configuration = Configuration.findConfiguration(
    'tslint.json',
    'src/myfile.ts'
).results;

// Lint a file
const sourceCode = fs.readFileSync('src/myfile.ts', 'utf8');
linter.lint('src/myfile.ts', sourceCode, configuration);

// Get results
const result = linter.getResult();
console.log(result.output);
console.log(`Errors: ${result.errorCount}, Warnings: ${result.warningCount}`);

Key API Components

Core Classes

// Main linter class
class Linter {
    constructor(options: ILinterOptions, program?: ts.Program)
    lint(fileName: string, source: string, configuration?: IConfigurationFile): void
    getResult(): LintResult
    
    // Static utilities
    static VERSION: string
    static createProgram(configFile: string, projectDirectory?: string): ts.Program
    static findConfiguration(configFile: string, inputFilePath: string): IConfigurationLoadResult
}
// Linter options interface
interface ILinterOptions {
    fix: boolean;
    formatter?: string | FormatterConstructor;
    formattersDirectory?: string;
    quiet?: boolean;
    rulesDirectory?: string | string[];
}
// Linting result interface
interface LintResult {
    errorCount: number;
    warningCount: number;
    failures: RuleFailure[];
    fixes?: RuleFailure[];
    format: string | FormatterConstructor;
    output: string;
}

Configuration Management

import { Configuration } from 'tslint';

// Find and load configuration
const config = Configuration.findConfiguration(
    './tslint.json',
    './src/file.ts'
);

// Load from specific path
const config2 = Configuration.loadConfigurationFromPath('./tslint.json');

// Configuration interface
interface IConfigurationFile {
    extends: string[];
    jsRules: Map<string, Partial<IOptions>>;
    linterOptions?: {
        exclude: string[];
        format: string;
    };
    rulesDirectory: string[];
    rules: Map<string, Partial<IOptions>>;
}

Rule Development

import { Rules, RuleFailure } from 'tslint';
import * as ts from 'typescript';

// Base rule class
abstract class AbstractRule implements IRule {
    static metadata: IRuleMetadata;
    
    constructor(options: IOptions)
    getOptions(): IOptions
    isEnabled(): boolean
    apply(sourceFile: ts.SourceFile): RuleFailure[]
    applyWithWalker(walker: IWalker): RuleFailure[]
}

// Rule metadata interface
interface IRuleMetadata {
    ruleName: string;
    type: "functionality" | "maintainability" | "style" | "typescript" | "formatting";
    description: string;
    optionsDescription: string;
    options: any;
    optionExamples?: Array<true | any[]>;
    typescriptOnly: boolean;
    hasFix?: boolean;
    requiresTypeInfo?: boolean;
}

// Core rule interfaces
interface IRule {
    getOptions(): IOptions;
    isEnabled(): boolean;
    apply(sourceFile: ts.SourceFile): RuleFailure[];
    applyWithWalker(walker: IWalker): RuleFailure[];
}

interface ITypedRule extends IRule {
    applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[];
}

interface IOptions {
    ruleArguments: any[];
    ruleSeverity: RuleSeverity;
    ruleName: string;
    disabledIntervals: IDisabledInterval[];
}

interface IDisabledInterval {
    startPosition: number;
    endPosition: number;
}

Built-in Features

Rules (163 total)

  • Functionality: 65 rules for correctness and best practices
  • Maintainability: 14 rules for code maintainability
  • Style: 79 rules for coding style and conventions
  • Formatting: 5 rules for code formatting

Formatters (13 total)

  • checkstyle: Checkstyle XML format
  • json: JSON format for machine processing
  • stylish: Human-readable format (default)
  • junit: JUnit XML format
  • prose: Verbose human-readable format
  • And 8 more specialized formatters

Testing Framework

Comprehensive testing utilities for validating custom rules with markup-based test files.

Advanced Features

Type-Aware Linting

import { Rules } from 'tslint';

// Rules that require TypeScript type information
class MyTypedRule extends Rules.TypedRule {
    applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
        // Access type checker for advanced analysis
        const typeChecker = program.getTypeChecker();
        // Implementation
        return [];
    }
}

Comment-Based Rule Control

// Disable rules inline
// tslint:disable-next-line:no-console
console.log('Debug message');

// Disable specific rule for file section  
// tslint:disable:no-unused-variable
let unused = 'temporary';
// tslint:enable:no-unused-variable

Related Documentation

For detailed information on specific areas:

  • Core Linting - Linter class, options, and programmatic usage
  • Configuration - Configuration loading, file formats, and inheritance
  • Built-in Rules - Complete reference of 163+ built-in rules
  • Custom Rules - Rule development APIs and patterns
  • Formatters - Output formatting and custom formatter development
  • Testing - Rule testing framework and utilities
  • CLI Tool - Command-line interface and options

Migration Note

TSLint is deprecated in favor of ESLint with TypeScript support. For new projects, consider using:

npm install eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin

The TypeScript team provides migration tools and guides for transitioning from TSLint to ESLint.

docs

cli.md

configuration.md

formatters.md

index.md

linting.md

rules.md

testing.md

tile.json