TypeScript definitions for @babel/traverse. 

TypeScript definitions for @babel/traverse

types

@types/babel__traverse

// Type definitions for @babel/traverse 7.14

// Project: https://github.com/babel/babel/tree/main/packages/babel-traverse, https://babeljs.io

// Definitions by: Troy Gerwien <https://github.com/yortus>

//                 Marvin Hagemeister <https://github.com/marvinhagemeister>

//                 Ryan Petrich <https://github.com/rpetrich>

//                 Melvin Groenhoff <https://github.com/mgroenhoff>

//                 Dean L. <https://github.com/dlgrit>

//                 Ifiok Jr. <https://github.com/ifiokjr>

//                 ExE Boss <https://github.com/ExE-Boss>

//                 Daniel Tschinder <https://github.com/danez>

// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

        parent: Node | Node[] | null | undefined,

     * `explode()` will take a `Visitor` object with all of the various shorthands

     * that we support, and validates & normalizes it into a common format, ready

     * - `Identifier() { ... }` -> `Identifier: { enter() { ... } }`

     * - `"Identifier|NumericLiteral": { ... }` -> `Identifier: { ... }, NumericLiteral: { ... }`

     * - Aliases in `@babel/types`: e.g. `Property: { ... }` -> `ObjectProperty: { ... }, ClassProperty: { ... }`

     * - Visitors of virtual types are wrapped, so that they are only visited when their dynamic check passes

     * - `enter` and `exit` functions are wrapped in arrays, to ease merging of visitors

        [Type in Node['type']]?: VisitNodeObject<S, Extract<Node, { type: Type }>>;

    function verify(visitor: Visitor): void;

    function merge<S = {}>(visitors: Array<Visitor<S>>, states?: S[]): Visitor<unknown>;

export interface TraverseOptions<S = Node> extends Visitor<S> {

export type ArrayKeys<T> = keyof { [P in keyof T as T[P] extends any[] ? P : never]: P };

    constructor(path: NodePath, parentScope?: Scope);

    bindings: { [name: string]: Binding };

    /** Traverse node with current scope and path. */

    traverse<S>(node: Node | Node[], opts: TraverseOptions<S>, state: S): void;

    traverse(node: Node | Node[], opts?: TraverseOptions, state?: any): void;

    /** Generate a unique identifier and add it to the current scope. */

    generateDeclaredUidIdentifier(name?: string): t.Identifier;

    generateUidIdentifier(name?: string): t.Identifier;

    /** Generate a unique `_id1` binding. */

    /** Generate a unique identifier based on a node. */

    generateUidIdentifierBasedOnNode(parent: Node, defaultName?: string): t.Identifier;

     * Determine whether evaluating the specific input `node` is a consequenceless reference. ie.

     * evaluating it wont result in potentially arbitrary code from being ran. The following are

     * whitelisted and determined not to cause side effects:

    /** Possibly generate a memoised identifier if it is not static and has consequences. */

    maybeGenerateMemoised(node: Node, dontPush?: boolean): t.Identifier;

    checkBlockScopedCollisions(local: Node, kind: string, name: string, id: object): void;

    rename(oldName: string, newName?: string, block?: Node): void;

    toArray(node: Node, i?: number): Node;

    registerDeclaration(path: NodePath): void;

    registerConstantViolation(path: NodePath): void;

    registerBinding(kind: string, path: NodePath, bindingPath?: NodePath): void;

    isPure(node: Node, constantsOnly?: boolean): boolean;

    push(opts: { id: t.LVal; init?: t.Expression; unique?: boolean; kind?: 'var' | 'let' | 'const' }): void;

    push(opts: { id: t.LVal; init?: t.Expression | undefined; unique?: boolean | undefined; kind?: 'var' | 'let' | 'const' | undefined }): void;

    /** Walks the scope tree and gathers **all** bindings. */

    getAllBindings(...kinds: string[]): object;

    bindingIdentifierEquals(name: string, node: Node): boolean;

    getBinding(name: string): Binding | undefined;

    getOwnBinding(name: string): Binding | undefined;

    getBindingIdentifier(name: string): t.Identifier;

    getOwnBindingIdentifier(name: string): t.Identifier;

    hasOwnBinding(name: string): boolean;

    hasBinding(name: string, noGlobals?: boolean): boolean;

    parentHasBinding(name: string, noGlobals?: boolean): boolean;

    /** Move a binding of `name` to another `scope`. */

    moveBindingTo(name: string, scope: Scope): void;

    removeOwnBinding(name: string): void;

    kind: 'var' | 'let' | 'const' | 'module';

export type Visitor<S = {}> = VisitNodeObject<S, Node> &

        [Type in Node['type']]?: VisitNode<S, Extract<Node, { type: Type }>>;

        [K in keyof t.Aliases]?: VisitNode<S, t.Aliases[K]>;

export type VisitNode<S, P extends Node> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;

export type VisitNodeFunction<S, P extends Node> = (this: S, path: NodePath<P>, state: S) => void;

type NodeType = Node['type'] | keyof t.Aliases;

export interface VisitNodeObject<S, P extends Node> {

    enter?: VisitNodeFunction<S, P> | undefined;

    exit?: VisitNodeFunction<S, P> | undefined;

     * @deprecated will be removed in Babel 8

export type NodePaths<T extends Node | readonly Node[]> = T extends readonly Node[]

    ? { -readonly [K in keyof T]: NodePath<Extract<T[K], Node>> }

    parentPath: T extends t.Program ? null : NodePath;

    type: T extends null | undefined ? undefined : T extends Node ? T['type'] : string | undefined;

    getData(key: string, def?: any): any;

    buildCodeFrameError<TError extends Error>(msg: string, Error?: new (msg: string) => TError): TError;

    traverse<T>(visitor: Visitor<T>, state: T): void;

    // Example: https://github.com/babel/babel/blob/63204ae51e020d84a5b246312f5eeb4d981ab952/packages/babel-traverse/src/path/modification.js#L83

    debug(buildMessage: () => string): void;

    static get<C extends Node, K extends keyof C>(opts: {

    //#region ------------------------- ancestry -------------------------

     * Starting at the parent path of the current `NodePath` and going up the

     * tree, return the first `NodePath` that causes the provided `callback`

     * to return a truthy value, or `null` if the `callback` never returns a

    findParent(callback: (path: NodePath) => boolean): NodePath | null;

     * Starting at current `NodePath` and going up the tree, return the first

     * `NodePath` that causes the provided `callback` to return a truthy value,

     * or `null` if the `callback` never returns a truthy value.

    find(callback: (path: NodePath) => boolean): NodePath | null;

    /** Get the parent function of the current path. */

    getFunctionParent(): NodePath<t.Function> | null;

    /** Walk up the tree until we hit a parent node path in a list. */

    getStatementParent(): NodePath<t.Statement> | null;

     * Get the deepest common ancestor and then from it, get the earliest relationship path

     * Earliest is defined as being "before" all the other nodes in terms of list container

    getEarliestCommonAncestorFrom(paths: NodePath[]): NodePath;

    /** Get the earliest path in the tree where the provided `paths` intersect. */

        filter?: (deepest: Node, i: number, ancestries: NodePath[]) => NodePath,

     * Build an array of node paths containing the entire ancestry of the current node path.

     * NOTE: The current node path is included in this.

    getAncestry(): [this, ...NodePath[]];

     * A helper to find if `this` path is an ancestor of `maybeDescendant`

    isAncestor(maybeDescendant: NodePath): boolean;

     * A helper to find if `this` path is a descendant of `maybeAncestor`

    isDescendant(maybeAncestor: NodePath): boolean;

    inType(...candidateTypes: string[]): boolean;

    //#region ------------------------- inference -------------------------

    /** Infer the type of the current `NodePath`. */

    isBaseType(baseName: string, soft?: boolean): boolean;

    couldBeBaseType(name: string): boolean;

    baseTypeStrictlyMatches(right: NodePath): boolean;

    isGenericType(genericName: string): boolean;

    //#region ------------------------- replacement -------------------------

     * Replace a node with an array of multiple. This method performs the following steps:

     *  - Inherit the comments of first provided node with that of the current node.

     *  - Insert the provided nodes after the current node.

    replaceWithMultiple<Nodes extends readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;

     * Parse a string as an expression and replace the current node with the result.

     * NOTE: This is typically not a good idea to use. Building source strings when

     * transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's

     * easier to use, your transforms will be extremely brittle.

    replaceWithSourceString(replacement: any): [NodePath];

    /** Replace the current node with another. */

    replaceWith<T extends Node>(replacement: T | NodePath<T>): [NodePath<T>];

     * This method takes an array of statements nodes and then explodes it

     * into expressions. This method retains completion records which is

     * extremely important to retain original semantics.

    replaceExpressionWithStatements<Nodes extends readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;

    "description": "TypeScript definitions for @babel/traverse",

    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse",

            "url": "https://github.com/yortus",

            "name": "Marvin Hagemeister",

            "url": "https://github.com/marvinhagemeister",

            "githubUsername": "marvinhagemeister"

            "url": "https://github.com/rpetrich",

            "url": "https://github.com/mgroenhoff",

            "githubUsername": "mgroenhoff"

            "url": "https://github.com/dlgrit",

            "url": "https://github.com/ifiokjr",

            "url": "https://github.com/ExE-Boss",

            "url": "https://github.com/danez",

        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",

        "directory": "types/babel__traverse"

    "typesPublisherContentHash": "018a94bdfb68ec320c195ade1ed72b7e91dbc1ae0de5f8eea2d3ad225c6967e2",

    "typesPublisherContentHash": "cfba5af15311ea4d54ce047c1682ab2e092412306271db84b56d4aec74387468",

> `npm install --save @types/babel__traverse`

This package contains type definitions for @babel/traverse (https://github.com/babel/babel/tree/main/packages/babel-traverse).

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse.

 * Last updated: Sun, 27 Jun 2021 13:31:14 GMT

 * Last updated: Tue, 06 Jul 2021 18:05:41 GMT

 * Dependencies: [@types/babel__types](https://npmjs.com/package/@types/babel__types)

These definitions were written by [Troy Gerwien](https://github.com/yortus), [Marvin Hagemeister](https://github.com/marvinhagemeister), [Ryan Petrich](https://github.com/rpetrich), [Melvin Groenhoff](https://github.com/mgroenhoff), [Dean L.](https://github.com/dlgrit), [Ifiok Jr.](https://github.com/ifiokjr), [ExE Boss](https://github.com/ExE-Boss), and [Daniel Tschinder](https://github.com/danez).

		@@ -64,4 +64,4 @@ // Type definitions for @babel/traverse 7.14
		export interface TraverseOptions<S = Node> extends Visitor<S> {
		scope?: Scope;
		noScope?: boolean;
		scope?: Scope \| undefined;
		noScope?: boolean \| undefined;
		}
		@@ -144,3 +144,3 @@

		push(opts: { id: t.LVal; init?: t.Expression; unique?: boolean; kind?: 'var' \| 'let' \| 'const' }): void;
		push(opts: { id: t.LVal; init?: t.Expression \| undefined; unique?: boolean \| undefined; kind?: 'var' \| 'let' \| 'const' \| undefined }): void;

		@@ -214,9 +214,9 @@ getProgramParent(): Scope;
		export interface VisitNodeObject<S, P extends Node> {
		enter?: VisitNodeFunction<S, P>;
		exit?: VisitNodeFunction<S, P>;
		denylist?: NodeType[];
		enter?: VisitNodeFunction<S, P> \| undefined;
		exit?: VisitNodeFunction<S, P> \| undefined;
		denylist?: NodeType[] \| undefined;
		/**
		* @deprecated will be removed in Babel 8
		*/
		blacklist?: NodeType[];
		blacklist?: NodeType[] \| undefined;
		}
		@@ -277,3 +277,3 @@
		container: C;
		listKey?: string;
		listKey?: string \| undefined;
		key: K;
		@@ -280,0 +280,0 @@ }): NodePath<C[K]>;

		{
		"name": "@types/babel__traverse",
		"version": "7.14.0",
		"version": "7.14.1",
		"description": "TypeScript definitions for @babel/traverse",
		@@ -67,4 +67,4 @@ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse",
		},
		"typesPublisherContentHash": "018a94bdfb68ec320c195ade1ed72b7e91dbc1ae0de5f8eea2d3ad225c6967e2",
		"typesPublisherContentHash": "cfba5af15311ea4d54ce047c1682ab2e092412306271db84b56d4aec74387468",
		"typeScriptVersion": "3.6"
		}

		@@ -11,3 +11,3 @@ # Installation
		### Additional Details
		* Last updated: Sun, 27 Jun 2021 13:31:14 GMT
		* Last updated: Tue, 06 Jul 2021 18:05:41 GMT
		* Dependencies: [@types/babel__types](https://npmjs.com/package/@types/babel__types)
		@@ -14,0 +14,0 @@ * Global values: none

Improved metrics