TypeScript definitions for @babel/traverse. 

TypeScript definitions for @babel/traverse

types

@types/babel__traverse

// Type definitions for @babel/traverse 7.18

// 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:

    findParent<T extends t.Node>(callback: (path: NodePath) => path is NodePath<T>): NodePath<T> | null;

    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<T extends t.Node>(callback: (path: NodePath) => path is NodePath<T>): NodePath<T> | null;

    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>;

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

    //#region ------------------------- evaluation -------------------------

     * Walk the input `node` and statically evaluate if it's truthy.

     * Returning `true` when we're sure that the expression will evaluate to a

     * truthy value, `false` if we're sure that it will evaluate to a falsy

     * value and `undefined` if we aren't sure. Because of this please do not

     * rely on coercion when using this method and check with === if it's false.

     * Walk the input `node` and statically evaluate it.

    "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": "98d58bb0352e7d8aa887b4664af8d5c80797a41eaa1b5b7826e720988fea559a",

    "typesPublisherContentHash": "794d0cb7b862c906728252af03d0e0a3f87677ffe6a927640a79bbd482121d29",

> `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: Tue, 25 Apr 2023 20:32:49 GMT

 * Last updated: Wed, 26 Apr 2023 16:32:46 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).

		{
		"name": "@types/babel__traverse",
		"version": "7.18.4",
		"version": "7.18.5",
		"description": "TypeScript definitions for @babel/traverse",
		@@ -60,4 +60,4 @@ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse",
		},
		"typesPublisherContentHash": "98d58bb0352e7d8aa887b4664af8d5c80797a41eaa1b5b7826e720988fea559a",
		"typesPublisherContentHash": "794d0cb7b862c906728252af03d0e0a3f87677ffe6a927640a79bbd482121d29",
		"typeScriptVersion": "4.3"
		}

		@@ -297,3 +297,2 @@ // Type definitions for @babel/traverse 7.18
		*/
		findParent<T extends t.Node>(callback: (path: NodePath) => path is NodePath<T>): NodePath<T> \| null;
		findParent(callback: (path: NodePath) => boolean): NodePath \| null;
		@@ -306,3 +305,2 @@
		*/
		find<T extends t.Node>(callback: (path: NodePath) => path is NodePath<T>): NodePath<T> \| null;
		find(callback: (path: NodePath) => boolean): NodePath \| null;
		@@ -309,0 +307,0 @@

		@@ -11,3 +11,3 @@ # Installation
		### Additional Details
		* Last updated: Tue, 25 Apr 2023 20:32:49 GMT
		* Last updated: Wed, 26 Apr 2023 16:32:46 GMT
		* Dependencies: [@types/babel__types](https://npmjs.com/package/@types/babel__types)
		@@ -14,0 +14,0 @@ * Global values: none

Worsened metrics