@types/eslint-scope

What is @types/eslint-scope?

@types/eslint-scope provides TypeScript type definitions for the eslint-scope package, which is used to analyze the scope of variables in JavaScript code. This package is particularly useful for developers who are building tools that need to understand variable scoping, such as linters, code analyzers, and compilers.

What are @types/eslint-scope's main functionalities?

Scope Analysis

This feature allows you to analyze the scope of variables in a given piece of JavaScript code. The code sample demonstrates how to parse JavaScript code into an Abstract Syntax Tree (AST) using espree and then analyze the scope using eslint-scope.

const eslintScope = require('eslint-scope');
const espree = require('espree');

const code = 'function foo() { var bar = 1; }';
const ast = espree.parse(code, { ecmaVersion: 6 });
const scopeManager = eslintScope.analyze(ast);

scopeManager.scopes.forEach(scope => {
  console.log(scope.variables);
});

Variable Tracking

This feature allows you to track variables within different scopes. The code sample shows how to parse JavaScript code and then log the names of all variables found in each scope.

const eslintScope = require('eslint-scope');
const espree = require('espree');

const code = 'let x = 10; function test() { let y = 20; }';
const ast = espree.parse(code, { ecmaVersion: 6 });
const scopeManager = eslintScope.analyze(ast);

scopeManager.scopes.forEach(scope => {
  scope.variables.forEach(variable => {
    console.log(variable.name);
  });
});

Reference Tracking

This feature allows you to track references to variables within different scopes. The code sample demonstrates how to parse JavaScript code and then log the names of all references found in each scope.

const eslintScope = require('eslint-scope');
const espree = require('espree');

const code = 'let a = 1; function foo() { console.log(a); }';
const ast = espree.parse(code, { ecmaVersion: 6 });
const scopeManager = eslintScope.analyze(ast);

scopeManager.scopes.forEach(scope => {
  scope.references.forEach(reference => {
    console.log(reference.identifier.name);
  });
});

Other packages similar to @types/eslint-scope

eslint

ESLint is a popular linting tool for JavaScript and TypeScript. It includes scope analysis as part of its linting process, but it is a more comprehensive tool that also includes rule enforcement, code style checking, and more.

acorn

Acorn is a fast, small, JavaScript parser that can be used to generate an AST from JavaScript code. While it does not provide scope analysis out of the box, it can be used in conjunction with other tools to achieve similar functionality.

babel-eslint

babel-eslint is a parser that allows ESLint to lint all valid Babel code. It extends the capabilities of ESLint to support experimental syntax not yet supported by ESLint itself. It can be used to analyze the scope of variables in modern JavaScript code.

README

Installation

npm install --save @types/eslint-scope

Summary

This package contains type definitions for eslint-scope (https://github.com/eslint/eslint-scope).

Details

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/eslint-scope.

index.d.ts

import * as eslint from "eslint";
import * as estree from "estree";

export const version: string;

export class ScopeManager implements eslint.Scope.ScopeManager {
    scopes: Scope[];
    globalScope: Scope;
    acquire(node: {}, inner?: boolean): Scope | null;
    getDeclaredVariables(node: {}): Variable[];
}

export class Scope implements eslint.Scope.Scope {
    type:
        | "block"
        | "catch"
        | "class"
        | "for"
        | "function"
        | "function-expression-name"
        | "global"
        | "module"
        | "switch"
        | "with"
        | "TDZ";
    isStrict: boolean;
    upper: Scope | null;
    childScopes: Scope[];
    variableScope: Scope;
    block: estree.Node;
    variables: Variable[];
    set: Map<string, Variable>;
    references: Reference[];
    through: Reference[];
    functionExpressionScope: boolean;
}

export class Variable implements eslint.Scope.Variable {
    name: string;
    scope: Scope;
    identifiers: estree.Identifier[];
    references: Reference[];
    defs: eslint.Scope.Definition[];
}

export class Reference implements eslint.Scope.Reference {
    identifier: estree.Identifier;
    from: Scope;
    resolved: Variable | null;
    writeExpr: estree.Node | null;
    init: boolean;

    isWrite(): boolean;
    isRead(): boolean;
    isWriteOnly(): boolean;
    isReadOnly(): boolean;
    isReadWrite(): boolean;
}

export interface AnalysisOptions {
    optimistic?: boolean;
    directive?: boolean;
    ignoreEval?: boolean;
    nodejsScope?: boolean;
    impliedStrict?: boolean;
    fallback?: string | ((node: {}) => string[]);
    sourceType?: "script" | "module";
    ecmaVersion?: number;
}

export function analyze(ast: {}, options?: AnalysisOptions): ScopeManager;

Additional Details

• Last updated: Mon, 06 Nov 2023 22:41:05 GMT
• Dependencies: @types/eslint, @types/estree

Credits

These definitions were written by Toru Nagashima.