TSLint

npm install tslint typescript

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

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

# 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

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}`);

// 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;
}

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>>;
}

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;
}

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 [];
    }
}

// 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

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