@types/eslint-scope

  • Version 3.7.1
  • Published
  • 6.77 kB
  • 2 dependencies
  • MIT license

Install

npm i @types/eslint-scope
yarn add @types/eslint-scope
pnpm add @types/eslint-scope

Overview

TypeScript definitions for eslint-scope

Index

Variables

variable version

const version: string;

    Functions

    function analyze

    analyze: (ast: {}, options?: AnalysisOptions) => ScopeManager;

      Classes

      class Reference

      class Reference implements eslint.Scope.Reference {}

        property from

        from: Scope;

          property identifier

          identifier: any;

            property init

            init: boolean;

              property resolved

              resolved: Variable;

                property writeExpr

                writeExpr: any;

                  method isRead

                  isRead: () => boolean;

                    method isReadOnly

                    isReadOnly: () => boolean;

                      method isReadWrite

                      isReadWrite: () => boolean;

                        method isWrite

                        isWrite: () => boolean;

                          method isWriteOnly

                          isWriteOnly: () => boolean;

                            class Scope

                            class Scope implements eslint.Scope.Scope {}

                              property block

                              block: any;

                                property childScopes

                                childScopes: Scope[];

                                  property functionExpressionScope

                                  functionExpressionScope: boolean;

                                    property isStrict

                                    isStrict: boolean;

                                      property references

                                      references: Reference[];

                                        property set

                                        set: Map<string, Variable>;

                                          property through

                                          through: Reference[];

                                            property type

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

                                              property upper

                                              upper: Scope;

                                                property variables

                                                variables: Variable[];

                                                  property variableScope

                                                  variableScope: Scope;

                                                    class ScopeManager

                                                    class ScopeManager implements eslint.Scope.ScopeManager {}

                                                      property globalScope

                                                      globalScope: Scope;

                                                        property scopes

                                                        scopes: Scope[];

                                                          method acquire

                                                          acquire: (node: {}, inner?: boolean) => Scope | null;

                                                            method getDeclaredVariables

                                                            getDeclaredVariables: (node: {}) => Variable[];

                                                              class Variable

                                                              class Variable implements eslint.Scope.Variable {}

                                                                property defs

                                                                defs: any[];

                                                                  property identifiers

                                                                  identifiers: any[];

                                                                    property name

                                                                    name: string;

                                                                      property references

                                                                      references: Reference[];

                                                                        Interfaces

                                                                        interface AnalysisOptions

                                                                        interface AnalysisOptions {}

                                                                          property directive

                                                                          directive?: boolean | undefined;

                                                                            property ecmaVersion

                                                                            ecmaVersion?: number | undefined;

                                                                              property fallback

                                                                              fallback?: string | ((node: {}) => string[]) | undefined;

                                                                                property ignoreEval

                                                                                ignoreEval?: boolean | undefined;

                                                                                  property impliedStrict

                                                                                  impliedStrict?: boolean | undefined;

                                                                                    property nodejsScope

                                                                                    nodejsScope?: boolean | undefined;

                                                                                      property optimistic

                                                                                      optimistic?: boolean | undefined;

                                                                                        property sourceType

                                                                                        sourceType?: 'script' | 'module' | undefined;

                                                                                          Package Files (1)

                                                                                          Dependencies (2)

                                                                                          Dev Dependencies (0)

                                                                                          No dev dependencies.

                                                                                          Peer Dependencies (0)

                                                                                          No peer dependencies.

                                                                                          Badge

                                                                                          To add a badge like this onejsDocs.io badgeto 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/@types/eslint-scope.

                                                                                          • Markdown
                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/eslint-scope)
                                                                                          • HTML
                                                                                            <a href="https://www.jsdocs.io/package/@types/eslint-scope"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>