eslint

eslint

Version 10.2.0
Published 11 days ago
2.9 MB
30 dependencies
MIT license

Install

npm i eslint

yarn add eslint

pnpm add eslint

Overview

An AST-based pattern checker for JavaScript.

Index

Functions

function loadESLint

loadESLint: () => Promise<typeof ESLint>;

Loads the correct ESLint constructor.

Classes

class ESLint

class ESLint {}

constructor

constructor(options?: ESLint.Options);

property configType

static configType: string;

property defaultConfig

static readonly defaultConfig: ConfigObject<Rules>[];

The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint. Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present.

property version

static readonly version: string;

method calculateConfigForFile

calculateConfigForFile: (filePath: string) => Promise<any>;

method findConfigFile

findConfigFile: (filePath?: string) => Promise<string | undefined>;

method fromOptionsModule

static fromOptionsModule: (optionsURL: {
    readonly href: string;
}) => Promise<ESLint>;

method getErrorResults

static getErrorResults: (results: ESLint.LintResult[]) => ESLint.LintResult[];

method getRulesMetaForResults

getRulesMetaForResults: (
    results: ESLint.LintResult[]
) => ESLint.LintResultData['rulesMeta'];

method hasFlag

hasFlag: (flag: string) => boolean;

method isPathIgnored

isPathIgnored: (filePath: string) => Promise<boolean>;

method lintFiles

lintFiles: (patterns: string | string[]) => Promise<ESLint.LintResult[]>;

method lintText

lintText: (
    code: string,
    options?: {
        filePath?: string | undefined;
        warnIgnored?: boolean | undefined;
    }
) => Promise<ESLint.LintResult[]>;

method loadFormatter

loadFormatter: (nameOrPath?: string) => Promise<ESLint.LoadedFormatter>;

method outputFixes

static outputFixes: (results: ESLint.LintResult[]) => Promise<void>;

class Linter

class Linter {}

constructor

constructor(options?: { cwd?: string | undefined; configType?: 'flat' });

property version

static readonly version: string;

property version

version: string;

method getFixPassCount

getFixPassCount: () => Linter.Stats['fixPasses'];

method getSourceCode

getSourceCode: () => SourceCode;

method getTimes

getTimes: () => Linter.Stats['times'];

method verify

verify: {
    (
        code: SourceCode | string,
        config: Linter.Config | Linter.Config[],
        filename?: string
    ): Linter.LintMessage[];
    (
        code: string | SourceCode,
        config: any,
        options: Linter.LintOptions
    ): CoreLintMessage[];
};

method verifyAndFix

verifyAndFix: {
    (
        code: string,
        config: Linter.Config | Linter.Config[],
        filename?: string
    ): Linter.FixReport;
    (code: string, config: any, options: Linter.FixOptions): Linter.FixReport;
};

class RuleTester

class RuleTester {}

constructor

constructor(config?: ConfigObject<Rules>);

property describe

static describe: (...args: any) => any;

property it

static it: (...args: any) => any;

property itOnly

static itOnly: (...args: any) => any;

method getDefaultConfig

static getDefaultConfig: () => ConfigObject<Rules>;

method only

static only: (
    item: string | RuleTester.ValidTestCase | RuleTester.InvalidTestCase
) => RuleTester.ValidTestCase | RuleTester.InvalidTestCase;

method resetDefaultConfig

static resetDefaultConfig: () => void;

method run

run: (
    name: string,
    rule: RuleDefinition,
    tests: {
        valid: Array<string | RuleTester.ValidTestCase>;
        invalid: RuleTester.InvalidTestCase[];
        assertionOptions?: {
            requireMessage?: boolean | 'message' | 'messageId';
            requireLocation?: boolean;
            requireData?: boolean | 'error' | 'suggestion';
        };
    }
) => void;

method setDefaultConfig

static setDefaultConfig: (config: ConfigObject<Rules>) => void;

class SourceCode

class SourceCode
    implements
        TextSourceCode<{
            LangOptions: Linter.LanguageOptions;
            RootNode: AST.Program;
            SyntaxElementWithLoc: AST.Token | ESTree.Node;
            ConfigNode: ESTree.Comment;
        }> {}

constructor

constructor(text: string, ast: AST.Program);

constructor

constructor(config: SourceCode.Config);

property ast

ast: AST.Program;

property getFirstToken

getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions;

property getFirstTokenBetween

getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

property getFirstTokens

getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions;

property getFirstTokensBetween

getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions;

property getLastToken

getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions;

property getLastTokenBetween

getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

property getLastTokens

getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions;

property getLastTokensBetween

getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions;

property getTokenAfter

getTokenAfter: SourceCode.UnaryCursorWithSkipOptions;

property getTokenBefore

getTokenBefore: SourceCode.UnaryCursorWithSkipOptions;

property getTokens

getTokens: ((
    node: ESTree.Node,
    beforeCount?: number,
    afterCount?: number
) => AST.Token[]) &
    SourceCode.UnaryNodeCursorWithCountOptions;

property getTokensAfter

getTokensAfter: SourceCode.UnaryCursorWithCountOptions;

property getTokensBefore

getTokensBefore: SourceCode.UnaryCursorWithCountOptions;

property getTokensBetween

getTokensBetween: SourceCode.BinaryCursorWithCountOptions;

property hasBOM

hasBOM: boolean;

property lines

lines: string[];

property parserServices

parserServices: any;

property scopeManager

scopeManager: Scope.ScopeManager;

property text

text: string;

property visitorKeys

visitorKeys: SourceCode.VisitorKeys;

method commentsExistBetween

commentsExistBetween: (
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment
) => boolean;

method getAllComments

getAllComments: () => ESTree.Comment[];

method getAncestors

getAncestors: (node: ESTree.Node) => ESTree.Node[];

method getCommentsAfter

getCommentsAfter: (nodeOrToken: ESTree.Node | AST.Token) => ESTree.Comment[];

method getCommentsBefore

getCommentsBefore: (nodeOrToken: ESTree.Node | AST.Token) => ESTree.Comment[];

method getCommentsInside

getCommentsInside: (node: ESTree.Node) => ESTree.Comment[];

method getDeclaredVariables

getDeclaredVariables: (node: ESTree.Node) => Scope.Variable[];

method getIndexFromLoc

getIndexFromLoc: (location: ESTree.Position) => number;

method getLines

getLines: () => string[];

method getLoc

getLoc: (syntaxElement: AST.Token | ESTree.Node) => ESTree.SourceLocation;

method getLocFromIndex

getLocFromIndex: (index: number) => ESTree.Position;

method getNodeByRangeIndex

getNodeByRangeIndex: (index: number) => ESTree.Node | null;

method getRange

getRange: (syntaxElement: AST.Token | ESTree.Node) => SourceRange;

method getScope

getScope: (node: ESTree.Node) => Scope.Scope;

method getText

getText: (
    node?: ESTree.Node,
    beforeCount?: number,
    afterCount?: number
) => string;

method getTokenByRangeStart

getTokenByRangeStart: {
    (offset: number, options?: { includeComments: false }): AST.Token | null;
    (offset: number, options: { includeComments: boolean }): any;
};

method isGlobalReference

isGlobalReference: (node: ESTree.Identifier) => boolean;

method isSpaceBetween

isSpaceBetween: (
    first: ESTree.Node | AST.Token,
    second: ESTree.Node | AST.Token
) => boolean;

method markVariableAsUsed

markVariableAsUsed: (name: string, refNode?: ESTree.Node) => boolean;

method splitLines

static splitLines: (text: string) => string[];

method traverse

traverse: () => Iterable<TraversalStep>;

Interfaces

interface JSXIdentifier

interface JSXIdentifier extends ESTree.BaseNode {}

property name

name: string;

property type

type: 'JSXIdentifier';

Type Aliases

type JSRuleDefinition

type JSRuleDefinition<Options extends Partial<JSRuleDefinitionTypeOptions> = {}> =
    CustomRuleDefinitionType<
        {
            LangOptions: Linter.LanguageOptions;
            Code: SourceCode;
            Visitor: Rule.RuleListener;
            Node: JSSyntaxElement;
        },
        Options
    >;

type JSRuleDefinitionTypeOptions

type JSRuleDefinitionTypeOptions = CustomRuleTypeDefinitions;

type JSSyntaxElement

type JSSyntaxElement = {
    type: string;
    loc?: ESTree.SourceLocation | null | undefined;
};

Namespaces

namespace AST

namespace AST {}

interface Program

interface Program extends ESTree.Program {}

property comments

comments: ESTree.Comment[];

property loc

loc: SourceLocation;

property range

range: Range;

property tokens

tokens: Token[];

interface SourceLocation

interface SourceLocation {}

property end

end: ESTree.Position;

property start

start: ESTree.Position;

interface Token

interface Token {}

property loc

loc: SourceLocation;

property range

range: Range;

property type

type: TokenType;

property value

value: string;

type Range

type Range = SourceRange;

type TokenType

type TokenType =
    | 'Boolean'
    | 'Null'
    | 'Identifier'
    | 'PrivateIdentifier'
    | 'Keyword'
    | 'Punctuator'
    | 'JSXIdentifier'
    | 'JSXText'
    | 'Numeric'
    | 'String'
    | 'Template'
    | 'RegularExpression';

namespace ESLint

namespace ESLint {}

interface DeprecatedRuleUse

interface DeprecatedRuleUse {}

Information about deprecated rules.

property info

info?: DeprecatedInfo | undefined;

The raw deprecated info provided by the rule. - Undefined if the rule's meta.deprecated property is a boolean. - Unset when using the legacy eslintrc configuration.

property replacedBy

replacedBy: string[];

The rule IDs that replace this deprecated rule.

property ruleId

ruleId: string;

The rule ID.

interface LintResult

interface LintResult {}

A linting result.

property errorCount

errorCount: number;

Number of errors for the result.

property fatalErrorCount

fatalErrorCount: number;

Number of fatal errors for the result.

property filePath

filePath: string;

The path to the file that was linted.

property fixableErrorCount

fixableErrorCount: number;

Number of fixable errors for the result.

property fixableWarningCount

fixableWarningCount: number;

Number of fixable warnings for the result.

property messages

messages: Linter.LintMessage[];

All of the messages for the result.

property output

output?: string | undefined;

The source code of the file that was linted, with as many fixes applied as possible.

property source

source?: string | undefined;

The source code of the file that was linted.

property stats

stats?: Linter.Stats | undefined;

The performance statistics collected with the stats flag.

property suppressedMessages

suppressedMessages: Linter.SuppressedLintMessage[];

All of the suppressed messages for the result.

property usedDeprecatedRules

usedDeprecatedRules: DeprecatedRuleUse[];

The list of used deprecated rules.

property warningCount

warningCount: number;

Number of warnings for the result.

interface LintResultData

interface LintResultData extends ResultsMeta {}

property cwd

cwd: string;

property rulesMeta

rulesMeta: {
    [ruleId: string]: Rule.RuleMetaData;
};

interface LoadedFormatter

interface LoadedFormatter {}

The type of an object resolved by ESLint.loadFormatter.

method format

format: (
    results: LintResult[],
    resultsMeta?: ResultsMeta
) => string | Promise<string>;

Used to call the underlying formatter.
Parameter results
An array of lint results to format.
Parameter resultsMeta
An object with optional color and maxWarningsExceeded properties that will be passed to the underlying formatter function along with other properties set by ESLint. This argument can be omitted if color and maxWarningsExceeded are not needed. The formatter output.

interface MaxWarningsExceeded

interface MaxWarningsExceeded {}

Information provided when the maximum warning threshold is exceeded.

property foundWarnings

foundWarnings: number;

Number of warnings found while linting.

property maxWarnings

maxWarnings: number;

Number of warnings to trigger nonzero exit code.

interface Options

interface Options {}

The options with which to configure the ESLint instance.

property allowInlineConfig

allowInlineConfig?: boolean | undefined;

Enable or disable inline configuration comments.

property applySuppressions

applySuppressions?: boolean | undefined;

If true, apply suppressions automatically. Defaults to false.

property baseConfig

baseConfig?: Linter.Config | Linter.Config[] | null | undefined;

Base config, extended by all configs used with this instance.

property cache

cache?: boolean | undefined;

Enable result caching.

property cacheLocation

cacheLocation?: string | undefined;

The cache file to use instead of .eslintcache.

property cacheStrategy

cacheStrategy?: CacheStrategy | undefined;

The strategy used to detect changed files.

property concurrency

concurrency?: number | 'auto' | 'off' | undefined;

Maximum number of linting threads, "auto" to choose automatically, "off" for no multithreading.

property cwd

cwd?: string | undefined;

The value to use for the current working directory.

property errorOnUnmatchedPattern

errorOnUnmatchedPattern?: boolean | undefined;

If false then ESLint#lintFiles() doesn't throw even if no target files found. Defaults to true.

property fix

fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;

Execute in autofix mode. If a function, should return a boolean.

property fixTypes

fixTypes?: FixType[] | null | undefined;

Array of rule types to apply fixes for.

property flags

flags?: string[] | undefined;

Array of feature flags to enable.

property globInputPaths

globInputPaths?: boolean | undefined;

Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file path is assumed to be a non-glob path to an existing file.

property ignore

ignore?: boolean | undefined;

False disables all ignore patterns except for the default ones.

property ignorePatterns

ignorePatterns?: string[] | null | undefined;

Ignore file patterns to use in addition to config ignores. These patterns are relative to cwd.

property overrideConfig

overrideConfig?: Linter.Config | Linter.Config[] | null | undefined;

Override config, overrides all configs used with this instance.

property overrideConfigFile

overrideConfigFile?: string | true | null | undefined;

Searches for default config file when falsy; doesn't do any config file lookup when true; considered to be a config filename when a string.

property passOnNoPatterns

passOnNoPatterns?: boolean | undefined;

When set to true, missing patterns cause the linting operation to short circuit and not report any failures.

property plugins

plugins?: Record<string, Plugin> | null | undefined;

An array of plugin implementations.

property ruleFilter

ruleFilter?:
    | ((arg: {
          ruleId: string;
          severity: Exclude<Linter.Severity, 0>;
      }) => boolean)
    | undefined;

Default is () => true. A predicate function that filters rules to be run. This function is called with an object containing ruleId and severity, and returns true if the rule should be run.

property stats

stats?: boolean | undefined;

True enables added statistics on lint results.

property suppressionsLocation

suppressionsLocation?: string | undefined;

Path to suppressions file. Relative to cwd. Defaults to eslint-suppressions.json in cwd.

property warnIgnored

warnIgnored?: boolean | undefined;

Show warnings when the file list includes ignored files.

interface ResultsMeta

interface ResultsMeta {}

Metadata about results for formatters.

property color

color?: boolean | undefined;

Whether or not to use color in the formatter output. - If --color was set, this property is true. - If --no-color was set, it is false. - If neither option was provided, the property is omitted.

property maxWarningsExceeded

maxWarningsExceeded?: MaxWarningsExceeded | undefined;

Present if the maxWarnings threshold was exceeded.

type CacheStrategy

type CacheStrategy = 'content' | 'metadata';

type ConfigData

type ConfigData<Rules extends Linter.RulesRecord = RulesConfig> = Omit<
    Linter.LegacyConfig<Rules>,
    '$schema'
>;

type EditInfo

type EditInfo = Rule.Fix;

type Environment

type Environment = EnvironmentConfig;

type FixType

type FixType = 'directive' | 'problem' | 'suggestion' | 'layout';

type Formatter

type Formatter = LoadedFormatter;

type FormatterFunction

type FormatterFunction = (
    results: LintResult[],
    context: LintResultData
) => string | Promise<string>;

The expected signature of a custom formatter.
Parameter results
An array of lint results to format.
Parameter context
Additional information for the formatter. The formatter output.

type ObjectMetaProperties

type ObjectMetaProperties = CoreObjectMetaProperties;

type Plugin

type Plugin = CorePlugin;

namespace Linter

namespace Linter {}

interface ESLintParseResult

interface ESLintParseResult {}

property ast

ast: AST.Program;

The AST object.

property scopeManager

scopeManager?: Scope.ScopeManager | undefined;

The scope manager of the AST.

property services

services?: SourceCode.ParserServices | undefined;

The services that the parser provides.

property visitorKeys

visitorKeys?: SourceCode.VisitorKeys | undefined;

The visitor keys of the AST.

interface FixOptions

interface FixOptions extends LintOptions {}

property fix

fix?: boolean | undefined;

interface FixReport

interface FixReport {}

property fixed

fixed: boolean;

property messages

messages: LintMessage[];

property output

output: string;

interface LanguageOptions

interface LanguageOptions extends GenericLanguageOptions {}

property ecmaVersion

ecmaVersion?: EcmaVersion | undefined;

The version of ECMAScript to support. May be any year (i.e., 2022) or version (i.e., 5). Set to "latest" for the most recent supported version. "latest"

property globals

globals?: Globals | undefined;

An object specifying additional objects that should be added to the global scope during linting.

property parser

parser?: Parser | undefined;

An object containing a parse() or parseForESLint() method. If not configured, the default ESLint parser (Espree) will be used.

property parserOptions

parserOptions?: Linter.ParserOptions | undefined;

An object specifying additional options that are passed directly to the parser() method on the parser. The available options are parser-dependent

property sourceType

sourceType?: SourceType | undefined;

The type of JavaScript source code. Possible values are "script" for traditional script files, "module" for ECMAScript modules (ESM), and "commonjs" for CommonJS files. (default: "module" for .js and .mjs files; "commonjs" for .cjs files)

interface LintOptions

interface LintOptions {}

Options used for linting code with Linter#verify and Linter#verifyAndFix.

property allowInlineConfig

allowInlineConfig?: boolean | undefined;

property disableFixes

disableFixes?: boolean | undefined;

property filename

filename?: string | undefined;

property filterCodeBlock

filterCodeBlock?: ((filename: string, text: string) => boolean) | undefined;

property postprocess

postprocess?: ((problemLists: LintMessage[][]) => LintMessage[]) | undefined;

property preprocess

preprocess?: ((code: string) => string[]) | undefined;

property reportUnusedDisableDirectives

reportUnusedDisableDirectives?: boolean | undefined;

interface LintSuppression

interface LintSuppression {}

property justification

justification: string;

property kind

kind: string;

interface ParserOptions

interface ParserOptions {}

Parser options.
See Also
- [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)

property allowReserved

allowReserved?: boolean | undefined;

Allow the use of reserved words as identifiers (if ecmaVersion is 3).
false

property ecmaFeatures

ecmaFeatures?:
    | {
          /**
           * Allow `return` statements in the global scope.
           *
           * @default false
           */
          globalReturn?: boolean | undefined;
          /**
           * Enable global [strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) (if `ecmaVersion` is 5 or greater).
           *
           * @default false
           */
          impliedStrict?: boolean | undefined;
          /**
           * Enable [JSX](https://facebook.github.io/jsx/).
           *
           * @default false
           */
          jsx?: boolean | undefined;
          [key: string]: any;
      }
    | undefined;

An object indicating which additional language features you'd like to use.
See Also
- https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options

index signature

[key: string]: any;

interface Stats

interface Stats {}

Performance statistics.

property fixPasses

fixPasses: number;

The number of times ESLint has applied at least one fix after linting.

property times

times: { passes: TimePass[] };

The times spent on (parsing, fixing, linting) a file, where the linting refers to the timing information for each rule.

interface SuppressedLintMessage

interface SuppressedLintMessage extends LintMessage {}

property suppressions

suppressions: LintSuppression[];

The suppression info.

interface TimePass

interface TimePass {}

property fix

fix: { total: number };

The fix object containing all fix time information.

property parse

parse: { total: number };

The parse object containing all parse time information.

property rules

rules?: Record<string, { total: number }>;

The rules object containing all lint time information for each rule.

property total

total: number;

The total time that is spent on (parsing, fixing, linting) a file.

type BaseConfig

type BaseConfig<
    Rules extends RulesConfig = RulesConfig,
    OverrideRules extends RulesConfig = Rules
> = CoreBaseConfig<Rules, OverrideRules>;

ESLint legacy configuration.
See Also
- [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)

type Config

type Config<Rules extends RulesConfig = RulesConfig> = ConfigObject<Rules>;

type ConfigOverride

type ConfigOverride<Rules extends RulesConfig = RulesConfig> =
    CoreConfigOverride<Rules>;

The overwrites that apply more differing configuration to specific files or directories.

type EcmaVersion

type EcmaVersion = CoreEcmaVersion;

The ECMAScript version of the code being linted.

type ESTreeParser

type ESTreeParser = ESLint.ObjectMetaProperties &
    (
        | { parse(text: string, options?: any): AST.Program }
        | { parseForESLint(text: string, options?: any): ESLintParseResult }
    );

type FlatConfig

type FlatConfig<Rules extends RulesConfig = RulesConfig> = Config<Rules>;

Deprecated
Use Config instead of FlatConfig

type GlobalConf

type GlobalConf = GlobalAccess;

type Globals

type Globals = GlobalsConfig;

type HasRules

type HasRules<Rules extends RulesConfig = RulesConfig> = CoreHasRules<Rules>;

A configuration object that may have a rules block.

type LegacyConfig

type LegacyConfig<
    Rules extends RulesConfig = RulesConfig,
    OverrideRules extends RulesConfig = Rules
> = LegacyConfigObject<Rules, OverrideRules>;

ESLint legacy configuration.
See Also
- [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)

type LinterOptions

type LinterOptions = LinterOptionsConfig;

type LintMessage

type LintMessage = CoreLintMessage;

type LintSuggestion

type LintSuggestion = CoreLintSuggestion;

type NonESTreeParser

type NonESTreeParser = ESLint.ObjectMetaProperties &
    (
        | {
              parse(text: string, options?: any): unknown;
          }
        | {
              parseForESLint(
                  text: string,
                  options?: any
              ): Omit<ESLintParseResult, 'ast' | 'scopeManager'> & {
                  ast: unknown;
                  scopeManager?: unknown;
              };
          }
    );

type Parser

type Parser = NonESTreeParser | ESTreeParser;

type Processor

type Processor<T extends string | ProcessorFile = string | ProcessorFile> =
    CoreProcessor<T>;

type ProcessorFile

type ProcessorFile = CoreProcessorFile;

type RuleEntry

type RuleEntry<Options extends any[] = any[]> = RuleConfig<Options>;

The severity level for the rule or an array containing the rule severity level, followed by the rule options.
See Also
- [Rules](https://eslint.org/docs/latest/use/configure/rules)

type RuleSeverity

type RuleSeverity = CoreSeverity;

The numeric or human readable severity level for a rule.
See Also
- [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)

type RuleSeverityAndOptions

type RuleSeverityAndOptions<Options extends any[] = any[]> = [
    RuleSeverity,
    ...Partial<Options>
];

An array containing the rule severity level, followed by the rule options.
See Also
- [Rules](https://eslint.org/docs/latest/use/configure/rules)

type RulesRecord

type RulesRecord = RulesConfig;

The rules config object is a key/value map of rule names and their severity and options.

type Severity

type Severity = SeverityLevel;

The numeric severity level for a rule.
- 0 means off. - 1 means warn. - 2 means error.
See Also
- [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)

type SourceType

type SourceType = JavaScriptSourceType;

The type of JavaScript source code.

type StringSeverity

type StringSeverity = SeverityName;

The human readable severity level for a rule.
See Also
- [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)

namespace Rule

namespace Rule {}

interface CodePath

interface CodePath {}

property childCodePaths

childCodePaths: CodePath[];

property finalSegments

finalSegments: CodePathSegment[];

property id

id: string;

property initialSegment

initialSegment: CodePathSegment;

property origin

origin: CodePathOrigin;

property returnedSegments

returnedSegments: CodePathSegment[];

property thrownSegments

thrownSegments: CodePathSegment[];

property upper

upper: CodePath | null;

interface CodePathSegment

interface CodePathSegment {}

property id

id: string;

property nextSegments

nextSegments: CodePathSegment[];

property prevSegments

prevSegments: CodePathSegment[];

property reachable

reachable: boolean;

interface NodeListener

interface NodeListener
    extends CustomRuleVisitorWithExit<
        {
            [Node in Rule.Node as Node['type']]?: ((node: Node) => void) | undefined;
        } & {
            // A `Program` visitor's node type has no `parent` property.
            Program?: ((node: AST.Program) => void) | undefined;
        }
    > {}

interface NodeParentExtension

interface NodeParentExtension {}

property parent

parent: Node;

interface RuleContext

interface RuleContext
    extends CoreRuleContext<{
        LangOptions: Linter.LanguageOptions;
        Code: SourceCode;
        RuleOptions: any[];
        Node: JSSyntaxElement;
        MessageIds: string;
    }> {}

interface RuleListener

interface RuleListener extends NodeListener {}

method onCodePathEnd

onCodePathEnd: (codePath: CodePath, node: Node) => void;

method onCodePathSegmentEnd

onCodePathSegmentEnd: (segment: CodePathSegment, node: Node) => void;

method onCodePathSegmentLoop

onCodePathSegmentLoop: (
    fromSegment: CodePathSegment,
    toSegment: CodePathSegment,
    node: Node
) => void;

method onCodePathSegmentStart

onCodePathSegmentStart: (segment: CodePathSegment, node: Node) => void;

method onCodePathStart

onCodePathStart: (codePath: CodePath, node: Node) => void;

method onUnreachableCodePathSegmentEnd

onUnreachableCodePathSegmentEnd: (segment: CodePathSegment, node: Node) => void;

method onUnreachableCodePathSegmentStart

onUnreachableCodePathSegmentStart: (
    segment: CodePathSegment,
    node: Node
) => void;

index signature

[key: string]:
    | ((codePath: CodePath, node: Node) => void)
    | ((segment: CodePathSegment, node: Node) => void)
    | ((
          fromSegment: CodePathSegment,
          toSegment: CodePathSegment,
          node: Node
      ) => void)
    | ((node: Node) => void)
    | NodeListener[keyof NodeListener]
    | undefined;

interface RuleModule

interface RuleModule
    extends RuleDefinition<{
        LangOptions: Linter.LanguageOptions;
        Code: SourceCode;
        RuleOptions: any[];
        Visitor: RuleListener;
        Node: JSSyntaxElement;
        MessageIds: string;
        ExtRuleDocs: {};
    }> {}

method create

create: (context: RuleContext) => RuleListener;

type CodePathOrigin

type CodePathOrigin =
    | 'program'
    | 'function'
    | 'class-field-initializer'
    | 'class-static-block';

type Fix

type Fix = RuleTextEdit;

type Node

type Node =
    | (AST.Program & { parent: null })
    | (Exclude<ESTree.Node, ESTree.Program> & NodeParentExtension);

type NodeTypes

type NodeTypes = ESTree.Node['type'];

type ReportDescriptor

type ReportDescriptor = ViolationReport<JSSyntaxElement>;

type ReportDescriptorLocation

type ReportDescriptorLocation = ViolationLocation<JSSyntaxElement>;

type ReportDescriptorMessage

type ReportDescriptorMessage = ViolationMessage;

type ReportDescriptorOptions

type ReportDescriptorOptions = ViolationReportBase;

type ReportDescriptorOptionsBase

type ReportDescriptorOptionsBase = Omit<ViolationReportBase, 'suggest'>;

Deprecated
Use ReportDescriptorOptions instead.

type ReportFixer

type ReportFixer = CoreRuleFixer;

type RuleFixer

type RuleFixer = RuleTextEditor<ESTree.Node | AST.Token>;

type RuleMetaData

type RuleMetaData = RulesMeta;

type SuggestionDescriptorMessage

type SuggestionDescriptorMessage = SuggestionMessage;

type SuggestionReportDescriptor

type SuggestionReportDescriptor = SuggestedEdit;

type SuggestionReportOptions

type SuggestionReportOptions = SuggestedEditBase;

namespace RuleTester

namespace RuleTester {}

interface InvalidTestCase

interface InvalidTestCase extends ValidTestCase {}

property errors

errors: number | Array<TestCaseError | string | RegExp>;

property output

output?: string | null | undefined;

interface SuggestionOutput

interface SuggestionOutput {}

property data

data?: MessagePlaceholderData | undefined;

property desc

desc?: string;

property messageId

messageId?: string;

property output

output: string;

interface TestCaseError

interface TestCaseError {}

property column

column?: number | undefined;

property data

data?: MessagePlaceholderData | undefined;

property endColumn

endColumn?: number | undefined;

property endLine

endLine?: number | undefined;

property line

line?: number | undefined;

property message

message?: string | RegExp;

property messageId

messageId?: string;

property suggestions

suggestions?: SuggestionOutput[] | number | undefined;

interface ValidTestCase

interface ValidTestCase
    extends Omit<
        Linter.Config,
        | 'name'
        | 'basePath'
        | 'files'
        | 'ignores'
        | 'linterOptions'
        | 'plugins'
        | 'rules'
    > {}

property after

after?: () => void;

property before

before?: () => void;

property code

code: string;

property filename

filename?: string | undefined;

property name

name?: string;

property only

only?: boolean;

property options

options?: any[];

namespace Scope

namespace Scope {}

interface Reference

interface Reference {}

property from

from: Scope;

property identifier

identifier: ESTree.Identifier | JSXIdentifier;

property init

init?: boolean;

property resolved

resolved: Variable | null;

property writeExpr

writeExpr?: ESTree.Expression | null;

method isRead

isRead: () => boolean;

method isReadOnly

isReadOnly: () => boolean;

method isReadWrite

isReadWrite: () => boolean;

method isWrite

isWrite: () => boolean;

method isWriteOnly

isWriteOnly: () => boolean;

interface Scope

interface Scope {}

property block

block: ESTree.Node;

property childScopes

childScopes: Scope[];

property functionExpressionScope

functionExpressionScope: boolean;

property implicit

implicit?: {
    variables: Variable[];
    set: Map<string, Variable>;
};

property isStrict

isStrict: boolean;

property references

references: Reference[];

property set

set: Map<string, Variable>;

property through

through: Reference[];

property type

type:
    | 'block'
    | 'catch'
    | 'class'
    | 'class-field-initializer'
    | 'class-static-block'
    | 'for'
    | 'function'
    | 'function-expression-name'
    | 'global'
    | 'module'
    | 'switch'
    | 'with';

property upper

upper: Scope | null;

property variables

variables: Variable[];

property variableScope

variableScope: Scope;

interface ScopeManager

interface ScopeManager {}

property globalScope

globalScope: Scope | null;

property scopes

scopes: Scope[];

method acquire

acquire: (node: ESTree.Node, inner?: boolean) => Scope | null;

method addGlobals

addGlobals: (names: ReadonlyArray<string>) => void;

method getDeclaredVariables

getDeclaredVariables: (node: ESTree.Node) => Variable[];

interface Variable

interface Variable {}

property defs

defs: Definition[];

property identifiers

identifiers: ESTree.Identifier[];

property name

name: string;

property references

references: Reference[];

property scope

scope: Scope;

type Definition

type Definition = DefinitionType & { name: ESTree.Identifier };

type DefinitionType

type DefinitionType =
    | { type: 'CatchClause'; node: ESTree.CatchClause; parent: null }
    | {
          type: 'ClassName';
          node: ESTree.ClassDeclaration | ESTree.ClassExpression;
          parent: null;
      }
    | {
          type: 'FunctionName';
          node: ESTree.FunctionDeclaration | ESTree.FunctionExpression;
          parent: null;
      }
    | {
          type: 'ImplicitGlobalVariable';
          node:
              | ESTree.AssignmentExpression
              | ESTree.ForInStatement
              | ESTree.ForOfStatement;
          parent: null;
      }
    | {
          type: 'ImportBinding';
          node:
              | ESTree.ImportSpecifier
              | ESTree.ImportDefaultSpecifier
              | ESTree.ImportNamespaceSpecifier;
          parent: ESTree.ImportDeclaration;
      }
    | {
          type: 'Parameter';
          node:
              | ESTree.FunctionDeclaration
              | ESTree.FunctionExpression
              | ESTree.ArrowFunctionExpression;
          parent: null;
      }
    | {
          type: 'Variable';
          node: ESTree.VariableDeclarator;
          parent: ESTree.VariableDeclaration;
      };

namespace SourceCode

namespace SourceCode {}

interface BinaryCursorWithCountOptions

interface BinaryCursorWithCountOptions {}

call signature

<T extends AST.Token>(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options:
        | ((token: AST.Token) => token is T)
        | {
              filter: (token: AST.Token) => token is T;
              includeComments?: false | undefined;
              count?: number | undefined;
          }
): T[];

call signature

<T extends AST.Token | ESTree.Comment>(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter: (
            tokenOrComment: AST.Token | ESTree.Comment
        ) => tokenOrComment is T;
        includeComments: boolean;
        count?: number | undefined;
    }
): T[];

call signature

(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options?:
        | {
              filter?: ((token: AST.Token) => boolean) | undefined;
              includeComments?: false | undefined;
              count?: number | undefined;
          }
        | ((token: AST.Token) => boolean)
        | number
): AST.Token[];

call signature

(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
        includeComments: boolean;
        count?: number | undefined;
    }
): Array<AST.Token | ESTree.Comment>;

interface BinaryCursorWithSkipOptions

interface BinaryCursorWithSkipOptions {}

call signature

<T extends AST.Token>(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options:
        | ((token: AST.Token) => token is T)
        | {
              filter: (token: AST.Token) => token is T;
              includeComments?: false | undefined;
              skip?: number | undefined;
          }
): T | null;

call signature

<T extends AST.Token | ESTree.Comment>(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter: (
            tokenOrComment: AST.Token | ESTree.Comment
        ) => tokenOrComment is T;
        includeComments: boolean;
        skip?: number | undefined;
    }
): T | null;

call signature

(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options?:
        | {
              filter?: ((token: AST.Token) => boolean) | undefined;
              includeComments?: false | undefined;
              skip?: number | undefined;
          }
        | ((token: AST.Token) => boolean)
        | number
): AST.Token | null;

call signature

(
    left: ESTree.Node | AST.Token | ESTree.Comment,
    right: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
        includeComments: boolean;
        skip?: number | undefined;
    }
): AST.Token | ESTree.Comment | null;

interface Config

interface Config {}

property ast

ast: AST.Program;

property hasBOM

hasBOM?: boolean | undefined;

property parserServices

parserServices?: ParserServices | null | undefined;

property scopeManager

scopeManager?: Scope.ScopeManager | null | undefined;

property text

text: string;

property visitorKeys

visitorKeys?: VisitorKeys | null | undefined;

interface UnaryCursorWithCountOptions

interface UnaryCursorWithCountOptions {}

call signature

<T extends AST.Token>(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options:
        | ((token: AST.Token) => token is T)
        | {
              filter: (token: AST.Token) => token is T;
              includeComments?: false | undefined;
              count?: number | undefined;
          }
): T[];

call signature

<T extends AST.Token | ESTree.Comment>(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter: (
            tokenOrComment: AST.Token | ESTree.Comment
        ) => tokenOrComment is T;
        includeComments: boolean;
        count?: number | undefined;
    }
): T[];

call signature

(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options?:
        | {
              filter?: ((token: AST.Token) => boolean) | undefined;
              includeComments?: false | undefined;
              count?: number | undefined;
          }
        | ((token: AST.Token) => boolean)
        | number
): AST.Token[];

call signature

(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
        includeComments: boolean;
        count?: number | undefined;
    }
): Array<AST.Token | ESTree.Comment>;

interface UnaryCursorWithSkipOptions

interface UnaryCursorWithSkipOptions {}

call signature

<T extends AST.Token>(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options:
        | ((token: AST.Token) => token is T)
        | {
              filter: (token: AST.Token) => token is T;
              includeComments?: false | undefined;
              skip?: number | undefined;
          }
): T | null;

call signature

<T extends AST.Token | ESTree.Comment>(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter: (
            tokenOrComment: AST.Token | ESTree.Comment
        ) => tokenOrComment is T;
        includeComments: boolean;
        skip?: number | undefined;
    }
): T | null;

call signature

(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options?:
        | {
              filter?: ((token: AST.Token) => boolean) | undefined;
              includeComments?: false | undefined;
              skip?: number | undefined;
          }
        | ((token: AST.Token) => boolean)
        | number
): AST.Token | null;

call signature

(
    node: ESTree.Node | AST.Token | ESTree.Comment,
    options: {
        filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
        includeComments: boolean;
        skip?: number | undefined;
    }
): AST.Token | ESTree.Comment | null;

interface UnaryNodeCursorWithCountOptions

interface UnaryNodeCursorWithCountOptions {}

call signature

<T extends AST.Token>(
    node: ESTree.Node,
    options:
        | ((token: AST.Token) => token is T)
        | {
              filter: (token: AST.Token) => token is T;
              includeComments?: false | undefined;
              count?: number | undefined;
          }
): T[];

call signature

<T extends AST.Token | ESTree.Comment>(
    node: ESTree.Node,
    options: {
        filter: (
            tokenOrComment: AST.Token | ESTree.Comment
        ) => tokenOrComment is T;
        includeComments: boolean;
        count?: number | undefined;
    }
): T[];

call signature

(
    node: ESTree.Node,
    options?:
        | {
              filter?: ((token: AST.Token) => boolean) | undefined;
              includeComments?: false | undefined;
              count?: number | undefined;
          }
        | ((token: AST.Token) => boolean)
        | number
): AST.Token[];

call signature

(
    node: ESTree.Node,
    options: {
        filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
        includeComments: boolean;
        count?: number | undefined;
    }
): Array<AST.Token | ESTree.Comment>;

interface UnaryNodeCursorWithSkipOptions

interface UnaryNodeCursorWithSkipOptions {}

call signature

<T extends AST.Token>(
    node: ESTree.Node,
    options:
        | ((token: AST.Token) => token is T)
        | {
              filter: (token: AST.Token) => token is T;
              includeComments?: false | undefined;
              skip?: number | undefined;
          }
): T | null;

call signature

<T extends AST.Token | ESTree.Comment>(
    node: ESTree.Node,
    options: {
        filter: (
            tokenOrComment: AST.Token | ESTree.Comment
        ) => tokenOrComment is T;
        includeComments: boolean;
        skip?: number | undefined;
    }
): T | null;

call signature

(
    node: ESTree.Node,
    options?:
        | {
              filter?: ((token: AST.Token) => boolean) | undefined;
              includeComments?: false | undefined;
              skip?: number | undefined;
          }
        | ((token: AST.Token) => boolean)
        | number
): AST.Token | null;

call signature

(
    node: ESTree.Node,
    options: {
        filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
        includeComments: boolean;
        skip?: number | undefined;
    }
): AST.Token | ESTree.Comment | null;

interface VisitorKeys

interface VisitorKeys {}

index signature

[nodeType: string]: string[];

type ParserServices

type ParserServices = any;

Package Files (1)

lib/types/index.d.ts

Peer Dependencies (1)

jiti

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/eslint.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/eslint)

HTML

<a href="https://www.jsdocs.io/package/eslint"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 11 days ago.
Package analyzed in 5152 ms.
Missing or incorrect documentation? Open an issue for this package.