@types/babel__traverse

Version 7.17.1
Published 18 days ago
123 kB
1 dependency
MIT license

Install

npm i @types/babel__traverse

yarn add @types/babel__traverse

pnpm add @types/babel__traverse

Overview

TypeScript definitions for @babel/traverse

Index

Variables

variable traverse

const traverse: {
    <S>(
        parent: Node | Node[] | null | undefined,
        opts: TraverseOptions<S>,
        scope: Scope | undefined,
        state: S,
        parentPath?: NodePath
    ): void;
    (
        parent: Node | Node[] | null | undefined,
        opts?: TraverseOptions,
        scope?: Scope,
        state?: any,
        parentPath?: NodePath
    ): void;
    visitors: typeof visitors;
    verify: typeof visitors.verify;
    explode: typeof visitors.explode;
};

Classes

class Binding

class Binding {}

constructor

constructor(opts: {
    existing: Binding;
    identifier: t.Identifier;
    scope: Scope;
    path: NodePath;
    kind: 'var' | 'let' | 'const';
});

property constant

constant: boolean;

property constantViolations

constantViolations: NodePath<Node>[];

property identifier

identifier: t.Identifier;

property kind

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

property path

path: NodePath<Node>;

property referenced

referenced: boolean;

property referencePaths

referencePaths: NodePath<Node>[];

property references

references: number;

property scope

scope: Scope;

class Hub

class Hub implements HubInterface {}

constructor

constructor();

method addHelper

addHelper: (name: string) => any;

method buildError

buildError: <E extends Error>(
    node: Node,
    msg: string,
    Constructor: new (message?: string) => E
) => E;

method getCode

getCode: () => string | undefined;

method getScope

getScope: () => Scope | undefined;

class NodePath

class NodePath<T = Node> {}

constructor

constructor(hub: Hub, parent: Node);

property container

container: object | object[];

property context

context: TraversalContext;

property contexts

contexts: TraversalContext[];

property data

data: {};

property hub

hub: Hub;

property inList

inList: boolean;

property key

key: string | number;

property listKey

listKey: string;

property node

node: {};

property opts

opts: {};

property parent

parent: Node;

property parentKey

parentKey: string;

property parentPath

parentPath: NodePath<Node>;

property removed

removed: boolean;

property scope

scope: Scope;

property shouldSkip

shouldSkip: boolean;

property shouldStop

shouldStop: boolean;

property skipKeys

skipKeys: {};

property state

state: any;

property type

type: {};

property typeAnnotation

typeAnnotation: {};

method addComment

addComment: (type: string, content: string, line?: boolean) => void;

method addComments

addComments: (type: string, comments: any[]) => void;

Give node comments of the specified type.

method assertAnyTypeAnnotation

assertAnyTypeAnnotation: (props?: object | null) => void;

method assertArrayExpression

assertArrayExpression: (props?: object | null) => void;

method assertArrayPattern

assertArrayPattern: (props?: object | null) => void;

method assertArrayTypeAnnotation

assertArrayTypeAnnotation: (props?: object | null) => void;

method assertArrowFunctionExpression

assertArrowFunctionExpression: (props?: object | null) => void;

method assertAssignmentExpression

assertAssignmentExpression: (props?: object | null) => void;

method assertAssignmentPattern

assertAssignmentPattern: (props?: object | null) => void;

method assertAwaitExpression

assertAwaitExpression: (props?: object | null) => void;

method assertBigIntLiteral

assertBigIntLiteral: (props?: object | null) => void;

method assertBinary

assertBinary: (props?: object | null) => void;

method assertBinaryExpression

assertBinaryExpression: (props?: object | null) => void;

method assertBindExpression

assertBindExpression: (props?: object | null) => void;

method assertBindingIdentifier

assertBindingIdentifier: (props?: object | null) => void;

method assertBlock

assertBlock: (props?: object | null) => void;

method assertBlockParent

assertBlockParent: (props?: object | null) => void;

method assertBlockScoped

assertBlockScoped: (props?: object | null) => void;

method assertBlockStatement

assertBlockStatement: (props?: object | null) => void;

method assertBooleanLiteral

assertBooleanLiteral: (props?: object | null) => void;

method assertBooleanLiteralTypeAnnotation

assertBooleanLiteralTypeAnnotation: (props?: object | null) => void;

method assertBooleanTypeAnnotation

assertBooleanTypeAnnotation: (props?: object | null) => void;

method assertBreakStatement

assertBreakStatement: (props?: object | null) => void;

method assertCallExpression

assertCallExpression: (props?: object | null) => void;

method assertCatchClause

assertCatchClause: (props?: object | null) => void;

method assertClass

assertClass: (props?: object | null) => void;

method assertClassBody

assertClassBody: (props?: object | null) => void;

method assertClassDeclaration

assertClassDeclaration: (props?: object | null) => void;

method assertClassExpression

assertClassExpression: (props?: object | null) => void;

method assertClassImplements

assertClassImplements: (props?: object | null) => void;

method assertClassMethod

assertClassMethod: (props?: object | null) => void;

method assertClassPrivateMethod

assertClassPrivateMethod: (props?: object | null) => void;

method assertClassPrivateProperty

assertClassPrivateProperty: (props?: object | null) => void;

method assertClassProperty

assertClassProperty: (props?: object | null) => void;

method assertCompletionStatement

assertCompletionStatement: (props?: object | null) => void;

method assertConditional

assertConditional: (props?: object | null) => void;

method assertConditionalExpression

assertConditionalExpression: (props?: object | null) => void;

method assertContinueStatement

assertContinueStatement: (props?: object | null) => void;

method assertDebuggerStatement

assertDebuggerStatement: (props?: object | null) => void;

method assertDeclaration

assertDeclaration: (props?: object | null) => void;

method assertDeclareClass

assertDeclareClass: (props?: object | null) => void;

method assertDeclaredPredicate

assertDeclaredPredicate: (props?: object | null) => void;

method assertDeclareExportAllDeclaration

assertDeclareExportAllDeclaration: (props?: object | null) => void;

method assertDeclareExportDeclaration

assertDeclareExportDeclaration: (props?: object | null) => void;

method assertDeclareFunction

assertDeclareFunction: (props?: object | null) => void;

method assertDeclareInterface

assertDeclareInterface: (props?: object | null) => void;

method assertDeclareModule

assertDeclareModule: (props?: object | null) => void;

method assertDeclareModuleExports

assertDeclareModuleExports: (props?: object | null) => void;

method assertDeclareOpaqueType

assertDeclareOpaqueType: (props?: object | null) => void;

method assertDeclareTypeAlias

assertDeclareTypeAlias: (props?: object | null) => void;

method assertDeclareVariable

assertDeclareVariable: (props?: object | null) => void;

method assertDecorator

assertDecorator: (props?: object | null) => void;

method assertDirective

assertDirective: (props?: object | null) => void;

method assertDirectiveLiteral

assertDirectiveLiteral: (props?: object | null) => void;

method assertDoExpression

assertDoExpression: (props?: object | null) => void;

method assertDoWhileStatement

assertDoWhileStatement: (props?: object | null) => void;

method assertEmptyStatement

assertEmptyStatement: (props?: object | null) => void;

method assertEmptyTypeAnnotation

assertEmptyTypeAnnotation: (props?: object | null) => void;

method assertExistsTypeAnnotation

assertExistsTypeAnnotation: (props?: object | null) => void;

method assertExportAllDeclaration

assertExportAllDeclaration: (props?: object | null) => void;

method assertExportDeclaration

assertExportDeclaration: (props?: object | null) => void;

method assertExportDefaultDeclaration

assertExportDefaultDeclaration: (props?: object | null) => void;

method assertExportDefaultSpecifier

assertExportDefaultSpecifier: (props?: object | null) => void;

method assertExportNamedDeclaration

assertExportNamedDeclaration: (props?: object | null) => void;

method assertExportNamespaceSpecifier

assertExportNamespaceSpecifier: (props?: object | null) => void;

method assertExportSpecifier

assertExportSpecifier: (props?: object | null) => void;

method assertExpression

assertExpression: (props?: object | null) => void;

method assertExpressionStatement

assertExpressionStatement: (props?: object | null) => void;

method assertExpressionWrapper

assertExpressionWrapper: (props?: object | null) => void;

method assertFile

assertFile: (props?: object | null) => void;

method assertFlow

assertFlow: (props?: object | null) => void;

method assertFlowBaseAnnotation

assertFlowBaseAnnotation: (props?: object | null) => void;

method assertFlowDeclaration

assertFlowDeclaration: (props?: object | null) => void;

method assertFlowPredicate

assertFlowPredicate: (props?: object | null) => void;

method assertFlowType

assertFlowType: (props?: object | null) => void;

method assertFor

assertFor: (props?: object | null) => void;

method assertForInStatement

assertForInStatement: (props?: object | null) => void;

method assertForOfStatement

assertForOfStatement: (props?: object | null) => void;

method assertForStatement

assertForStatement: (props?: object | null) => void;

method assertForXStatement

assertForXStatement: (props?: object | null) => void;

method assertFunction

assertFunction: (props?: object | null) => void;

method assertFunctionDeclaration

assertFunctionDeclaration: (props?: object | null) => void;

method assertFunctionExpression

assertFunctionExpression: (props?: object | null) => void;

method assertFunctionParent

assertFunctionParent: (props?: object | null) => void;

method assertFunctionTypeAnnotation

assertFunctionTypeAnnotation: (props?: object | null) => void;

method assertFunctionTypeParam

assertFunctionTypeParam: (props?: object | null) => void;

method assertGenerated

assertGenerated: (props?: object | null) => void;

method assertGenericTypeAnnotation

assertGenericTypeAnnotation: (props?: object | null) => void;

method assertIdentifier

assertIdentifier: (props?: object | null) => void;

method assertIfStatement

assertIfStatement: (props?: object | null) => void;

method assertImmutable

assertImmutable: (props?: object | null) => void;

method assertImport

assertImport: (props?: object | null) => void;

method assertImportDeclaration

assertImportDeclaration: (props?: object | null) => void;

method assertImportDefaultSpecifier

assertImportDefaultSpecifier: (props?: object | null) => void;

method assertImportNamespaceSpecifier

assertImportNamespaceSpecifier: (props?: object | null) => void;

method assertImportSpecifier

assertImportSpecifier: (props?: object | null) => void;

method assertInferredPredicate

assertInferredPredicate: (props?: object | null) => void;

method assertInterfaceDeclaration

assertInterfaceDeclaration: (props?: object | null) => void;

method assertInterfaceExtends

assertInterfaceExtends: (props?: object | null) => void;

method assertInterfaceTypeAnnotation

assertInterfaceTypeAnnotation: (props?: object | null) => void;

method assertInterpreterDirective

assertInterpreterDirective: (props?: object | null) => void;

method assertIntersectionTypeAnnotation

assertIntersectionTypeAnnotation: (props?: object | null) => void;

method assertJSX

assertJSX: (props?: object | null) => void;

method assertJSXAttribute

assertJSXAttribute: (props?: object | null) => void;

method assertJSXClosingElement

assertJSXClosingElement: (props?: object | null) => void;

method assertJSXClosingFragment

assertJSXClosingFragment: (props?: object | null) => void;

method assertJSXElement

assertJSXElement: (props?: object | null) => void;

method assertJSXEmptyExpression

assertJSXEmptyExpression: (props?: object | null) => void;

method assertJSXExpressionContainer

assertJSXExpressionContainer: (props?: object | null) => void;

method assertJSXFragment

assertJSXFragment: (props?: object | null) => void;

method assertJSXIdentifier

assertJSXIdentifier: (props?: object | null) => void;

method assertJSXMemberExpression

assertJSXMemberExpression: (props?: object | null) => void;

method assertJSXNamespacedName

assertJSXNamespacedName: (props?: object | null) => void;

method assertJSXOpeningElement

assertJSXOpeningElement: (props?: object | null) => void;

method assertJSXOpeningFragment

assertJSXOpeningFragment: (props?: object | null) => void;

method assertJSXSpreadAttribute

assertJSXSpreadAttribute: (props?: object | null) => void;

method assertJSXSpreadChild

assertJSXSpreadChild: (props?: object | null) => void;

method assertJSXText

assertJSXText: (props?: object | null) => void;

method assertLabeledStatement

assertLabeledStatement: (props?: object | null) => void;

method assertLiteral

assertLiteral: (props?: object | null) => void;

method assertLogicalExpression

assertLogicalExpression: (props?: object | null) => void;

method assertLoop

assertLoop: (props?: object | null) => void;

method assertLVal

assertLVal: (props?: object | null) => void;

method assertMemberExpression

assertMemberExpression: (props?: object | null) => void;

method assertMetaProperty

assertMetaProperty: (props?: object | null) => void;

method assertMethod

assertMethod: (props?: object | null) => void;

method assertMixedTypeAnnotation

assertMixedTypeAnnotation: (props?: object | null) => void;

method assertModuleDeclaration

assertModuleDeclaration: (props?: object | null) => void;

method assertModuleSpecifier

assertModuleSpecifier: (props?: object | null) => void;

method assertNewExpression

assertNewExpression: (props?: object | null) => void;

method assertNoop

assertNoop: (props?: object | null) => void;

method assertNullableTypeAnnotation

assertNullableTypeAnnotation: (props?: object | null) => void;

method assertNullLiteral

assertNullLiteral: (props?: object | null) => void;

method assertNullLiteralTypeAnnotation

assertNullLiteralTypeAnnotation: (props?: object | null) => void;

method assertNumberLiteral

assertNumberLiteral: (props?: object | null) => void;

Deprecated
Use assertNumericLiteral

method assertNumberLiteralTypeAnnotation

assertNumberLiteralTypeAnnotation: (props?: object | null) => void;

method assertNumberTypeAnnotation

assertNumberTypeAnnotation: (props?: object | null) => void;

method assertNumericLiteral

assertNumericLiteral: (props?: object | null) => void;

method assertObjectExpression

assertObjectExpression: (props?: object | null) => void;

method assertObjectMember

assertObjectMember: (props?: object | null) => void;

method assertObjectMethod

assertObjectMethod: (props?: object | null) => void;

method assertObjectPattern

assertObjectPattern: (props?: object | null) => void;

method assertObjectProperty

assertObjectProperty: (props?: object | null) => void;

method assertObjectTypeAnnotation

assertObjectTypeAnnotation: (props?: object | null) => void;

method assertObjectTypeCallProperty

assertObjectTypeCallProperty: (props?: object | null) => void;

method assertObjectTypeIndexer

assertObjectTypeIndexer: (props?: object | null) => void;

method assertObjectTypeInternalSlot

assertObjectTypeInternalSlot: (props?: object | null) => void;

method assertObjectTypeProperty

assertObjectTypeProperty: (props?: object | null) => void;

method assertObjectTypeSpreadProperty

assertObjectTypeSpreadProperty: (props?: object | null) => void;

method assertOpaqueType

assertOpaqueType: (props?: object | null) => void;

method assertOptionalCallExpression

assertOptionalCallExpression: (props?: object | null) => void;

method assertOptionalMemberExpression

assertOptionalMemberExpression: (props?: object | null) => void;

method assertParenthesizedExpression

assertParenthesizedExpression: (props?: object | null) => void;

method assertPattern

assertPattern: (props?: object | null) => void;

method assertPatternLike

assertPatternLike: (props?: object | null) => void;

method assertPipelineBareFunction

assertPipelineBareFunction: (props?: object | null) => void;

method assertPipelinePrimaryTopicReference

assertPipelinePrimaryTopicReference: (props?: object | null) => void;

method assertPipelineTopicExpression

assertPipelineTopicExpression: (props?: object | null) => void;

method assertPrivate

assertPrivate: (props?: object | null) => void;

method assertPrivateName

assertPrivateName: (props?: object | null) => void;

method assertProgram

assertProgram: (props?: object | null) => void;

method assertProperty

assertProperty: (props?: object | null) => void;

method assertPure

assertPure: (props?: object | null) => void;

method assertPureish

assertPureish: (props?: object | null) => void;

method assertQualifiedTypeIdentifier

assertQualifiedTypeIdentifier: (props?: object | null) => void;

method assertReferenced

assertReferenced: (props?: object | null) => void;

method assertReferencedIdentifier

assertReferencedIdentifier: (props?: object | null) => void;

method assertReferencedMemberExpression

assertReferencedMemberExpression: (props?: object | null) => void;

method assertRegexLiteral

assertRegexLiteral: (props?: object | null) => void;

Deprecated
Use assertRegExpLiteral

method assertRegExpLiteral

assertRegExpLiteral: (props?: object | null) => void;

method assertRestElement

assertRestElement: (props?: object | null) => void;

method assertRestProperty

assertRestProperty: (props?: object | null) => void;

Deprecated
Use assertRestElement

method assertReturnStatement

assertReturnStatement: (props?: object | null) => void;

method assertScopable

assertScopable: (props?: object | null) => void;

method assertScope

assertScope: (props?: object | null) => void;

method assertSequenceExpression

assertSequenceExpression: (props?: object | null) => void;

method assertSpreadElement

assertSpreadElement: (props?: object | null) => void;

method assertSpreadProperty

assertSpreadProperty: (props?: object | null) => void;

Deprecated
Use assertSpreadElement

method assertStatement

assertStatement: (props?: object | null) => void;

method assertStringLiteral

assertStringLiteral: (props?: object | null) => void;

method assertStringLiteralTypeAnnotation

assertStringLiteralTypeAnnotation: (props?: object | null) => void;

method assertStringTypeAnnotation

assertStringTypeAnnotation: (props?: object | null) => void;

method assertSuper

assertSuper: (props?: object | null) => void;

method assertSwitchCase

assertSwitchCase: (props?: object | null) => void;

method assertSwitchStatement

assertSwitchStatement: (props?: object | null) => void;

method assertTaggedTemplateExpression

assertTaggedTemplateExpression: (props?: object | null) => void;

method assertTemplateElement

assertTemplateElement: (props?: object | null) => void;

method assertTemplateLiteral

assertTemplateLiteral: (props?: object | null) => void;

method assertTerminatorless

assertTerminatorless: (props?: object | null) => void;

method assertThisExpression

assertThisExpression: (props?: object | null) => void;

method assertThisTypeAnnotation

assertThisTypeAnnotation: (props?: object | null) => void;

method assertThrowStatement

assertThrowStatement: (props?: object | null) => void;

method assertTryStatement

assertTryStatement: (props?: object | null) => void;

method assertTSAnyKeyword

assertTSAnyKeyword: (props?: object | null) => void;

method assertTSArrayType

assertTSArrayType: (props?: object | null) => void;

method assertTSAsExpression

assertTSAsExpression: (props?: object | null) => void;

method assertTSBooleanKeyword

assertTSBooleanKeyword: (props?: object | null) => void;

method assertTSCallSignatureDeclaration

assertTSCallSignatureDeclaration: (props?: object | null) => void;

method assertTSConditionalType

assertTSConditionalType: (props?: object | null) => void;

method assertTSConstructorType

assertTSConstructorType: (props?: object | null) => void;

method assertTSConstructSignatureDeclaration

assertTSConstructSignatureDeclaration: (props?: object | null) => void;

method assertTSDeclareFunction

assertTSDeclareFunction: (props?: object | null) => void;

method assertTSDeclareMethod

assertTSDeclareMethod: (props?: object | null) => void;

method assertTSEntityName

assertTSEntityName: (props?: object | null) => void;

method assertTSEnumDeclaration

assertTSEnumDeclaration: (props?: object | null) => void;

method assertTSEnumMember

assertTSEnumMember: (props?: object | null) => void;

method assertTSExportAssignment

assertTSExportAssignment: (props?: object | null) => void;

method assertTSExpressionWithTypeArguments

assertTSExpressionWithTypeArguments: (props?: object | null) => void;

method assertTSExternalModuleReference

assertTSExternalModuleReference: (props?: object | null) => void;

method assertTSFunctionType

assertTSFunctionType: (props?: object | null) => void;

method assertTSImportEqualsDeclaration

assertTSImportEqualsDeclaration: (props?: object | null) => void;

method assertTSImportType

assertTSImportType: (props?: object | null) => void;

method assertTSIndexedAccessType

assertTSIndexedAccessType: (props?: object | null) => void;

method assertTSIndexSignature

assertTSIndexSignature: (props?: object | null) => void;

method assertTSInferType

assertTSInferType: (props?: object | null) => void;

method assertTSInterfaceBody

assertTSInterfaceBody: (props?: object | null) => void;

method assertTSInterfaceDeclaration

assertTSInterfaceDeclaration: (props?: object | null) => void;

method assertTSIntersectionType

assertTSIntersectionType: (props?: object | null) => void;

method assertTSLiteralType

assertTSLiteralType: (props?: object | null) => void;

method assertTSMappedType

assertTSMappedType: (props?: object | null) => void;

method assertTSMethodSignature

assertTSMethodSignature: (props?: object | null) => void;

method assertTSModuleBlock

assertTSModuleBlock: (props?: object | null) => void;

method assertTSModuleDeclaration

assertTSModuleDeclaration: (props?: object | null) => void;

method assertTSNamespaceExportDeclaration

assertTSNamespaceExportDeclaration: (props?: object | null) => void;

method assertTSNeverKeyword

assertTSNeverKeyword: (props?: object | null) => void;

method assertTSNonNullExpression

assertTSNonNullExpression: (props?: object | null) => void;

method assertTSNullKeyword

assertTSNullKeyword: (props?: object | null) => void;

method assertTSNumberKeyword

assertTSNumberKeyword: (props?: object | null) => void;

method assertTSObjectKeyword

assertTSObjectKeyword: (props?: object | null) => void;

method assertTSOptionalType

assertTSOptionalType: (props?: object | null) => void;

method assertTSParameterProperty

assertTSParameterProperty: (props?: object | null) => void;

method assertTSParenthesizedType

assertTSParenthesizedType: (props?: object | null) => void;

method assertTSPropertySignature

assertTSPropertySignature: (props?: object | null) => void;

method assertTSQualifiedName

assertTSQualifiedName: (props?: object | null) => void;

method assertTSRestType

assertTSRestType: (props?: object | null) => void;

method assertTSStringKeyword

assertTSStringKeyword: (props?: object | null) => void;

method assertTSSymbolKeyword

assertTSSymbolKeyword: (props?: object | null) => void;

method assertTSThisType

assertTSThisType: (props?: object | null) => void;

method assertTSTupleType

assertTSTupleType: (props?: object | null) => void;

method assertTSType

assertTSType: (props?: object | null) => void;

method assertTSTypeAliasDeclaration

assertTSTypeAliasDeclaration: (props?: object | null) => void;

method assertTSTypeAnnotation

assertTSTypeAnnotation: (props?: object | null) => void;

method assertTSTypeAssertion

assertTSTypeAssertion: (props?: object | null) => void;

method assertTSTypeElement

assertTSTypeElement: (props?: object | null) => void;

method assertTSTypeLiteral

assertTSTypeLiteral: (props?: object | null) => void;

method assertTSTypeOperator

assertTSTypeOperator: (props?: object | null) => void;

method assertTSTypeParameter

assertTSTypeParameter: (props?: object | null) => void;

method assertTSTypeParameterDeclaration

assertTSTypeParameterDeclaration: (props?: object | null) => void;

method assertTSTypeParameterInstantiation

assertTSTypeParameterInstantiation: (props?: object | null) => void;

method assertTSTypePredicate

assertTSTypePredicate: (props?: object | null) => void;

method assertTSTypeQuery

assertTSTypeQuery: (props?: object | null) => void;

method assertTSTypeReference

assertTSTypeReference: (props?: object | null) => void;

method assertTSUndefinedKeyword

assertTSUndefinedKeyword: (props?: object | null) => void;

method assertTSUnionType

assertTSUnionType: (props?: object | null) => void;

method assertTSUnknownKeyword

assertTSUnknownKeyword: (props?: object | null) => void;

method assertTSVoidKeyword

assertTSVoidKeyword: (props?: object | null) => void;

method assertTupleTypeAnnotation

assertTupleTypeAnnotation: (props?: object | null) => void;

method assertTypeAlias

assertTypeAlias: (props?: object | null) => void;

method assertTypeAnnotation

assertTypeAnnotation: (props?: object | null) => void;

method assertTypeCastExpression

assertTypeCastExpression: (props?: object | null) => void;

method assertTypeofTypeAnnotation

assertTypeofTypeAnnotation: (props?: object | null) => void;

method assertTypeParameter

assertTypeParameter: (props?: object | null) => void;

method assertTypeParameterDeclaration

assertTypeParameterDeclaration: (props?: object | null) => void;

method assertTypeParameterInstantiation

assertTypeParameterInstantiation: (props?: object | null) => void;

method assertUnaryExpression

assertUnaryExpression: (props?: object | null) => void;

method assertUnaryLike

assertUnaryLike: (props?: object | null) => void;

method assertUnionTypeAnnotation

assertUnionTypeAnnotation: (props?: object | null) => void;

method assertUpdateExpression

assertUpdateExpression: (props?: object | null) => void;

method assertUser

assertUser: (props?: object | null) => void;

method assertUserWhitespacable

assertUserWhitespacable: (props?: object | null) => void;

method assertVar

assertVar: (props?: object | null) => void;

method assertVariableDeclaration

assertVariableDeclaration: (props?: object | null) => void;

method assertVariableDeclarator

assertVariableDeclarator: (props?: object | null) => void;

method assertVariance

assertVariance: (props?: object | null) => void;

method assertVoidTypeAnnotation

assertVoidTypeAnnotation: (props?: object | null) => void;

method assertWhile

assertWhile: (props?: object | null) => void;

method assertWhileStatement

assertWhileStatement: (props?: object | null) => void;

method assertWithStatement

assertWithStatement: (props?: object | null) => void;

method assertYieldExpression

assertYieldExpression: (props?: object | null) => void;

method baseTypeStrictlyMatches

baseTypeStrictlyMatches: (right: NodePath) => boolean;

method buildCodeFrameError

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

method call

call: (key: string) => boolean;

method canHaveVariableDeclarationOrExpression

canHaveVariableDeclarationOrExpression: () => boolean;

This checks whether or not we're in one of the following positions:
for (KEY in right); for (KEY;;);
This is because these spots allow VariableDeclarations AND normal expressions so we need to tell the path replacement that it's ok to replace this with an expression.

method canSwapBetweenExpressionAndStatement

canSwapBetweenExpressionAndStatement: (replacement: Node) => boolean;

This checks whether we are swapping an arrow function's body between an expression and a block statement (or vice versa).
This is because arrow functions may implicitly return an expression, which is the same as containing a block statement.

method couldBeBaseType

couldBeBaseType: (name: string) => boolean;

method debug

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

method equals

equals: (key: string, value: any) => boolean;

Check whether the path node key strict equals value.

method evaluate

evaluate: () => { confident: boolean; value: any };

Walk the input node and statically evaluate it.
Returns an object in the form { confident, value }. confident indicates whether or not we had to drop out of evaluating the expression because of hitting an unknown node that we couldn't confidently find the value of.
Example:
t.evaluate(parse("5 + 5")) // { confident: true, value: 10 } t.evaluate(parse("!true")) // { confident: true, value: false } t.evaluate(parse("foo + foo")) // { confident: false, value: undefined }

method evaluateTruthy

evaluateTruthy: () => boolean;

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.

method find

find: (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.

method findParent

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

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 truthy value.

method get

static get: <C extends Node, K extends keyof C>(opts: {
    hub: HubInterface;
    parentPath: NodePath | null;
    parent: Node;
    container: C;
    listKey?: string | undefined;
    key: K;
}) => NodePath<C[K]>;

method getAllNextSiblings

getAllNextSiblings: () => NodePath[];

method getAllPrevSiblings

getAllPrevSiblings: () => NodePath[];

method getAncestry

getAncestry: () => [this, ...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.

method getBindingIdentifiers

getBindingIdentifiers: (duplicates?: boolean) => Node[];

method getCompletionRecords

getCompletionRecords: () => NodePath[];

method getData

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

method getDeepestCommonAncestorFrom

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

Get the earliest path in the tree where the provided paths intersect.

method getEarliestCommonAncestorFrom

getEarliestCommonAncestorFrom: (paths: NodePath[]) => NodePath;

Get the deepest common ancestor and then from it, get the earliest relationship path to that ancestor.
Earliest is defined as being "before" all the other nodes in terms of list container position and visiting key.

method getFunctionParent

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

Get the parent function of the current path.

method getNextSibling

getNextSibling: () => NodePath;

method getOpposite

getOpposite: () => NodePath;

method getOuterBindingIdentifiers

getOuterBindingIdentifiers: (duplicates?: boolean) => Node[];

method getPathLocation

getPathLocation: () => string;

method getPrevSibling

getPrevSibling: () => NodePath;

method getScope

getScope: (scope: Scope) => Scope;

method getSibling

getSibling: (key: string | number) => NodePath;

method getSource

getSource: () => string;

Get the source code associated with this node.

method getStatementParent

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

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

method getTypeAnnotation

getTypeAnnotation: () => t.FlowType;

Infer the type of the current NodePath.

method has

has: (key: string) => boolean;

Check whether we have the input key. If the key references an array then we check if the array has any items, otherwise we just check if it's falsy.

method hasNode

hasNode: () => this is NodePath<NonNullable<this['node']>>;

method hoist

hoist: (scope: Scope) => void;

Hoist the current node to the highest scope possible and return a UID referencing it.

method insertAfter

insertAfter: <Nodes extends unknown>(nodes: Nodes) => NodePaths<Nodes>;

Insert the provided nodes after the current one. When inserting nodes after an expression, ensure that the completion record is correct by pushing the current node.

method insertBefore

insertBefore: <Nodes extends unknown>(nodes: Nodes) => NodePaths<Nodes>;

Insert the provided nodes before the current one.

method inType

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

method is

is: (key: string) => boolean;

Alias of has.

method isAncestor

isAncestor: (maybeDescendant: NodePath) => boolean;

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

method isAnyTypeAnnotation

isAnyTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.AnyTypeAnnotation>;

method isArrayExpression

isArrayExpression: (
    props?: object | null
) => this is NodePath<t.ArrayExpression>;

method isArrayPattern

isArrayPattern: (props?: object | null) => this is NodePath<t.ArrayPattern>;

method isArrayTypeAnnotation

isArrayTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.ArrayTypeAnnotation>;

method isArrowFunctionExpression

isArrowFunctionExpression: (
    props?: object | null
) => this is NodePath<t.ArrowFunctionExpression>;

method isAssignmentExpression

isAssignmentExpression: (
    props?: object | null
) => this is NodePath<t.AssignmentExpression>;

method isAssignmentPattern

isAssignmentPattern: (
    props?: object | null
) => this is NodePath<t.AssignmentPattern>;

method isAwaitExpression

isAwaitExpression: (
    props?: object | null
) => this is NodePath<t.AwaitExpression>;

method isBaseType

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

method isBigIntLiteral

isBigIntLiteral: (props?: object | null) => this is NodePath<t.BigIntLiteral>;

method isBinary

isBinary: (props?: object | null) => this is NodePath<t.Binary>;

method isBinaryExpression

isBinaryExpression: (
    props?: object | null
) => this is NodePath<t.BinaryExpression>;

method isBindExpression

isBindExpression: (props?: object | null) => this is NodePath<t.BindExpression>;

method isBindingIdentifier

isBindingIdentifier: (props?: object | null) => this is NodePath<t.Identifier>;

method isBlacklisted

isBlacklisted: () => boolean;

method isBlock

isBlock: (props?: object | null) => this is NodePath<t.Block>;

method isBlockParent

isBlockParent: (props?: object | null) => this is NodePath<t.BlockParent>;

method isBlockScoped

isBlockScoped: (props?: object | null) => this is NodePath<any>;

method isBlockStatement

isBlockStatement: (props?: object | null) => this is NodePath<t.BlockStatement>;

method isBooleanLiteral

isBooleanLiteral: (props?: object | null) => this is NodePath<t.BooleanLiteral>;

method isBooleanLiteralTypeAnnotation

isBooleanLiteralTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.BooleanLiteralTypeAnnotation>;

method isBooleanTypeAnnotation

isBooleanTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.BooleanTypeAnnotation>;

method isBreakStatement

isBreakStatement: (props?: object | null) => this is NodePath<t.BreakStatement>;

method isCallExpression

isCallExpression: (props?: object | null) => this is NodePath<t.CallExpression>;

method isCatchClause

isCatchClause: (props?: object | null) => this is NodePath<t.CatchClause>;

method isClass

isClass: (props?: object | null) => this is NodePath<t.Class>;

method isClassBody

isClassBody: (props?: object | null) => this is NodePath<t.ClassBody>;

method isClassDeclaration

isClassDeclaration: (
    props?: object | null
) => this is NodePath<t.ClassDeclaration>;

method isClassExpression

isClassExpression: (
    props?: object | null
) => this is NodePath<t.ClassExpression>;

method isClassImplements

isClassImplements: (
    props?: object | null
) => this is NodePath<t.ClassImplements>;

method isClassMethod

isClassMethod: (props?: object | null) => this is NodePath<t.ClassMethod>;

method isClassPrivateMethod

isClassPrivateMethod: (
    props?: object | null
) => this is NodePath<t.ClassPrivateMethod>;

method isClassPrivateProperty

isClassPrivateProperty: (
    props?: object | null
) => this is NodePath<t.ClassPrivateProperty>;

method isClassProperty

isClassProperty: (props?: object | null) => this is NodePath<t.ClassProperty>;

method isCompletionRecord

isCompletionRecord: (allowInsideFunction?: boolean) => boolean;

Check whether the current path references a completion record

method isCompletionStatement

isCompletionStatement: (
    props?: object | null
) => this is NodePath<t.CompletionStatement>;

method isConditional

isConditional: (props?: object | null) => this is NodePath<t.Conditional>;

method isConditionalExpression

isConditionalExpression: (
    props?: object | null
) => this is NodePath<t.ConditionalExpression>;

method isContinueStatement

isContinueStatement: (
    props?: object | null
) => this is NodePath<t.ContinueStatement>;

method isDebuggerStatement

isDebuggerStatement: (
    props?: object | null
) => this is NodePath<t.DebuggerStatement>;

method isDeclaration

isDeclaration: (props?: object | null) => this is NodePath<t.Declaration>;

method isDeclareClass

isDeclareClass: (props?: object | null) => this is NodePath<t.DeclareClass>;

method isDeclaredPredicate

isDeclaredPredicate: (
    props?: object | null
) => this is NodePath<t.DeclaredPredicate>;

method isDeclareExportAllDeclaration

isDeclareExportAllDeclaration: (
    props?: object | null
) => this is NodePath<t.DeclareExportAllDeclaration>;

method isDeclareExportDeclaration

isDeclareExportDeclaration: (
    props?: object | null
) => this is NodePath<t.DeclareExportDeclaration>;

method isDeclareFunction

isDeclareFunction: (
    props?: object | null
) => this is NodePath<t.DeclareFunction>;

method isDeclareInterface

isDeclareInterface: (
    props?: object | null
) => this is NodePath<t.DeclareInterface>;

method isDeclareModule

isDeclareModule: (props?: object | null) => this is NodePath<t.DeclareModule>;

method isDeclareModuleExports

isDeclareModuleExports: (
    props?: object | null
) => this is NodePath<t.DeclareModuleExports>;

method isDeclareOpaqueType

isDeclareOpaqueType: (
    props?: object | null
) => this is NodePath<t.DeclareOpaqueType>;

method isDeclareTypeAlias

isDeclareTypeAlias: (
    props?: object | null
) => this is NodePath<t.DeclareTypeAlias>;

method isDeclareVariable

isDeclareVariable: (
    props?: object | null
) => this is NodePath<t.DeclareVariable>;

method isDecorator

isDecorator: (props?: object | null) => this is NodePath<t.Decorator>;

method isDescendant

isDescendant: (maybeAncestor: NodePath) => boolean;

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

method isDirective

isDirective: (props?: object | null) => this is NodePath<t.Directive>;

method isDirectiveLiteral

isDirectiveLiteral: (
    props?: object | null
) => this is NodePath<t.DirectiveLiteral>;

method isDoExpression

isDoExpression: (props?: object | null) => this is NodePath<t.DoExpression>;

method isDoWhileStatement

isDoWhileStatement: (
    props?: object | null
) => this is NodePath<t.DoWhileStatement>;

method isEmptyStatement

isEmptyStatement: (props?: object | null) => this is NodePath<t.EmptyStatement>;

method isEmptyTypeAnnotation

isEmptyTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.EmptyTypeAnnotation>;

method isExistsTypeAnnotation

isExistsTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.ExistsTypeAnnotation>;

method isExportAllDeclaration

isExportAllDeclaration: (
    props?: object | null
) => this is NodePath<t.ExportAllDeclaration>;

method isExportDeclaration

isExportDeclaration: (
    props?: object | null
) => this is NodePath<t.ExportDeclaration>;

method isExportDefaultDeclaration

isExportDefaultDeclaration: (
    props?: object | null
) => this is NodePath<t.ExportDefaultDeclaration>;

method isExportDefaultSpecifier

isExportDefaultSpecifier: (
    props?: object | null
) => this is NodePath<t.ExportDefaultSpecifier>;

method isExportNamedDeclaration

isExportNamedDeclaration: (
    props?: object | null
) => this is NodePath<t.ExportNamedDeclaration>;

method isExportNamespaceSpecifier

isExportNamespaceSpecifier: (
    props?: object | null
) => this is NodePath<t.ExportNamespaceSpecifier>;

method isExportSpecifier

isExportSpecifier: (
    props?: object | null
) => this is NodePath<t.ExportSpecifier>;

method isExpression

isExpression: (props?: object | null) => this is NodePath<t.Expression>;

method isExpressionStatement

isExpressionStatement: (
    props?: object | null
) => this is NodePath<t.ExpressionStatement>;

method isExpressionWrapper

isExpressionWrapper: (
    props?: object | null
) => this is NodePath<t.ExpressionWrapper>;

method isFile

isFile: (props?: object | null) => this is NodePath<t.File>;

method isFlow

isFlow: (props?: object | null) => this is NodePath<t.Flow>;

method isFlowBaseAnnotation

isFlowBaseAnnotation: (
    props?: object | null
) => this is NodePath<t.FlowBaseAnnotation>;

method isFlowDeclaration

isFlowDeclaration: (
    props?: object | null
) => this is NodePath<t.FlowDeclaration>;

method isFlowPredicate

isFlowPredicate: (props?: object | null) => this is NodePath<t.FlowPredicate>;

method isFlowType

isFlowType: (props?: object | null) => this is NodePath<t.FlowType>;

method isFor

isFor: (props?: object | null) => this is NodePath<t.For>;

method isForInStatement

isForInStatement: (props?: object | null) => this is NodePath<t.ForInStatement>;

method isForOfStatement

isForOfStatement: (props?: object | null) => this is NodePath<t.ForOfStatement>;

method isForStatement

isForStatement: (props?: object | null) => this is NodePath<t.ForStatement>;

method isForXStatement

isForXStatement: (props?: object | null) => this is NodePath<t.ForXStatement>;

method isFunction

isFunction: (props?: object | null) => this is NodePath<t.Function>;

method isFunctionDeclaration

isFunctionDeclaration: (
    props?: object | null
) => this is NodePath<t.FunctionDeclaration>;

method isFunctionExpression

isFunctionExpression: (
    props?: object | null
) => this is NodePath<t.FunctionExpression>;

method isFunctionParent

isFunctionParent: (props?: object | null) => this is NodePath<t.FunctionParent>;

method isFunctionTypeAnnotation

isFunctionTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.FunctionTypeAnnotation>;

method isFunctionTypeParam

isFunctionTypeParam: (
    props?: object | null
) => this is NodePath<t.FunctionTypeParam>;

method isGenerated

isGenerated: (props?: object | null) => boolean;

method isGenericType

isGenericType: (genericName: string) => boolean;

method isGenericTypeAnnotation

isGenericTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.GenericTypeAnnotation>;

method isIdentifier

isIdentifier: (props?: object | null) => this is NodePath<t.Identifier>;

method isIfStatement

isIfStatement: (props?: object | null) => this is NodePath<t.IfStatement>;

method isImmutable

isImmutable: (props?: object | null) => this is NodePath<t.Immutable>;

method isImport

isImport: (props?: object | null) => this is NodePath<t.Import>;

method isImportDeclaration

isImportDeclaration: (
    props?: object | null
) => this is NodePath<t.ImportDeclaration>;

method isImportDefaultSpecifier

isImportDefaultSpecifier: (
    props?: object | null
) => this is NodePath<t.ImportDefaultSpecifier>;

method isImportNamespaceSpecifier

isImportNamespaceSpecifier: (
    props?: object | null
) => this is NodePath<t.ImportNamespaceSpecifier>;

method isImportSpecifier

isImportSpecifier: (
    props?: object | null
) => this is NodePath<t.ImportSpecifier>;

method isInferredPredicate

isInferredPredicate: (
    props?: object | null
) => this is NodePath<t.InferredPredicate>;

method isInterfaceDeclaration

isInterfaceDeclaration: (
    props?: object | null
) => this is NodePath<t.InterfaceDeclaration>;

method isInterfaceExtends

isInterfaceExtends: (
    props?: object | null
) => this is NodePath<t.InterfaceExtends>;

method isInterfaceTypeAnnotation

isInterfaceTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.InterfaceTypeAnnotation>;

method isInterpreterDirective

isInterpreterDirective: (
    props?: object | null
) => this is NodePath<t.InterpreterDirective>;

method isIntersectionTypeAnnotation

isIntersectionTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.IntersectionTypeAnnotation>;

method isJSX

isJSX: (props?: object | null) => this is NodePath<t.JSX>;

method isJSXAttribute

isJSXAttribute: (props?: object | null) => this is NodePath<t.JSXAttribute>;

method isJSXClosingElement

isJSXClosingElement: (
    props?: object | null
) => this is NodePath<t.JSXClosingElement>;

method isJSXClosingFragment

isJSXClosingFragment: (
    props?: object | null
) => this is NodePath<t.JSXClosingFragment>;

method isJSXElement

isJSXElement: (props?: object | null) => this is NodePath<t.JSXElement>;

method isJSXEmptyExpression

isJSXEmptyExpression: (
    props?: object | null
) => this is NodePath<t.JSXEmptyExpression>;

method isJSXExpressionContainer

isJSXExpressionContainer: (
    props?: object | null
) => this is NodePath<t.JSXExpressionContainer>;

method isJSXFragment

isJSXFragment: (props?: object | null) => this is NodePath<t.JSXFragment>;

method isJSXIdentifier

isJSXIdentifier: (props?: object | null) => this is NodePath<t.JSXIdentifier>;

method isJSXMemberExpression

isJSXMemberExpression: (
    props?: object | null
) => this is NodePath<t.JSXMemberExpression>;

method isJSXNamespacedName

isJSXNamespacedName: (
    props?: object | null
) => this is NodePath<t.JSXNamespacedName>;

method isJSXOpeningElement

isJSXOpeningElement: (
    props?: object | null
) => this is NodePath<t.JSXOpeningElement>;

method isJSXOpeningFragment

isJSXOpeningFragment: (
    props?: object | null
) => this is NodePath<t.JSXOpeningFragment>;

method isJSXSpreadAttribute

isJSXSpreadAttribute: (
    props?: object | null
) => this is NodePath<t.JSXSpreadAttribute>;

method isJSXSpreadChild

isJSXSpreadChild: (props?: object | null) => this is NodePath<t.JSXSpreadChild>;

method isJSXText

isJSXText: (props?: object | null) => this is NodePath<t.JSXText>;

method isLabeledStatement

isLabeledStatement: (
    props?: object | null
) => this is NodePath<t.LabeledStatement>;

method isLiteral

isLiteral: (props?: object | null) => this is NodePath<t.Literal>;

method isLogicalExpression

isLogicalExpression: (
    props?: object | null
) => this is NodePath<t.LogicalExpression>;

method isLoop

isLoop: (props?: object | null) => this is NodePath<t.Loop>;

method isLVal

isLVal: (props?: object | null) => this is NodePath<t.LVal>;

method isMemberExpression

isMemberExpression: (
    props?: object | null
) => this is NodePath<t.MemberExpression>;

method isMetaProperty

isMetaProperty: (props?: object | null) => this is NodePath<t.MetaProperty>;

method isMethod

isMethod: (props?: object | null) => this is NodePath<t.Method>;

method isMixedTypeAnnotation

isMixedTypeAnnotation: (
    props?: object | null
) => this is NodePath<t.MixedTypeAnnotation>;

@types/babel__traverse

Install

Overview

Index

Variables

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable traverse

Classes

class Binding

constructor

property constant

property constantViolations

property identifier

property kind

property path

property referenced

property referencePaths

property references

property scope

class Hub

constructor

method addHelper

method buildError

method getCode

method getScope

class NodePath

constructor

property container

property context

property contexts

property data

property hub

property inList

property key

property listKey

property node

property opts

property parent

property parentKey

property parentPath

property removed

property scope

property shouldSkip

property shouldStop

property skipKeys

property state

property type

property typeAnnotation

method addComment

method addComments

method assertAnyTypeAnnotation

method assertArrayExpression

method assertArrayPattern

method assertArrayTypeAnnotation

method assertArrowFunctionExpression

method assertAssignmentExpression

method assertAssignmentPattern

method assertAwaitExpression

method assertBigIntLiteral

method assertBinary

method assertBinaryExpression

method assertBindExpression

method assertBindingIdentifier

method assertBlock

method assertBlockParent

method assertBlockScoped

method assertBlockStatement

method assertBooleanLiteral

method assertBooleanLiteralTypeAnnotation

method assertBooleanTypeAnnotation

method assertBreakStatement

method assertCallExpression

method assertCatchClause

method assertClass

method assertClassBody

method assertClassDeclaration