vite-plugin-linter/dist/index.d.ts

Plugin for linting files with Vite

export { FilterPattern } from '@rollup/pluginutils';
import { b as Linter, a as LinterResult } from './shared/vite-plugin-linter.CYE9xG0y.js';
export { I as IncludeMode, c as LinterPluginOptions, L as LinterResultData, l as linterPlugin } from './shared/vite-plugin-linter.CYE9xG0y.js';
import { ESLint } from 'eslint';
import { ConfigEnv } from 'vite';
import ts from 'typescript';

interface EsLinterOptions {
    /**
     * Options used when called via the build command.
     * Defaults: cache: false, fix: false
     */
    buildOptions?: EsLintOptions;
    /**
     * The current Vite configuration environment
     */
    configEnv: ConfigEnv;
    /**
     * Options used when called via the serve command.
     * Defaults: cache: true, cacheLocation: "./node_modules/.cache/.eslintcache", fix: false
     */
    serveOptions?: EsLintOptions;
}
interface EsLintOptions extends ESLint.Options {
    /**
     * If the cache file should be removed before each start
     */
    clearCacheOnStart?: boolean;
    /**
     * Output formatter. Default is stylish
     */
    formatter?: string | ESLint.Formatter;
}
declare class EsLinter implements Linter<ESLint.LintResult> {
    readonly name = "EsLinter";
    private eslint;
    private formatter;
    private readonly options;
    constructor(options?: EsLinterOptions);
    format(results: ESLint.LintResult[]): Promise<string>;
    lintBuild(files: string[]): Promise<ESLint.LintResult[]>;
    lintServe(files: string[], output: (result: LinterResult<ESLint.LintResult>) => void): Promise<void>;
    private lint;
    private loadLinter;
    private loadFormatter;
}

interface TypeScriptLinterOptions extends ts.CompilerOptions {
    /**
     * Path to the TypeScript config file. Defaults to tsconfig.json
     */
    configFilePath?: string;
}
declare class TypeScriptLinter implements Linter<ts.Diagnostic> {
    readonly name = "TypeScriptLinter";
    private formatHost;
    private options;
    private optionsLoadedFromFile;
    private watchingFiles;
    private watcher;
    constructor(options?: TypeScriptLinterOptions);
    format(results: ts.Diagnostic[]): Promise<string>;
    lintBuild(files: string[]): Promise<readonly ts.Diagnostic[]>;
    lintServe(files: string[], output: (result: LinterResult<ts.Diagnostic>) => void): void;
    private getCustomTypeRootFiles;
    private loadOptions;
}

declare function normalizePath(id: string): string;
declare function onlyUnique(value: string, index: number, self: string[]): boolean;

export { EsLinter, Linter, LinterResult, TypeScriptLinter, normalizePath, onlyUnique };
export type { EsLintOptions, EsLinterOptions, TypeScriptLinterOptions };