Parse, print, and visit GraphQL language source files and AST nodes.

These exports are also available from the root graphql package.

For documentation purposes, these exports are grouped into the following categories:

• AST
• Kinds
• Lexing
• Source
• Parsing
• AST Predicates
• Printing
• Visiting

Category: AST

Classes

Location

Contains a range of UTF-8 character offsets and token references that identify the region of the source from which the AST derived.

Constructor

Creates a Location instance.

Signature:

new Location(
  startToken: Token,
  endToken: Token,
  source: Source,
);

Members

toJSON()

Returns a JSON representation of this location.

Signature:

toJSON(): {
  start: number;
  end: number;
};

import { parse } from 'graphql/language';
 
const document = parse('{ hello }');
const location = document.loc?.toJSON();
 
location; // => { start: 0, end: 9 }

Token

Represents a range of characters represented by a lexical token within a Source.

Constructor

Creates a Token instance.

Signature:

new Token(
  kind: TokenKind,
  start: number,
  end: number,
  line: number,
  column: number,
  value?: string,
);

Members

toJSON()

Returns a JSON representation of this token.

Signature:

toJSON(): {
  kind: TokenKind;
  value?: string;
  line: number;
  column: number;
};

import { Lexer, Source } from 'graphql/language';
 
const lexer = new Lexer(new Source('{ hello }'));
const token = lexer.advance().toJSON();
 
token; // => { kind: '{', value: undefined, line: 1, column: 1 }

Types

ASTNode

Type alias. The list of all possible AST node types.

type ASTNode =
  | NameNode
  | DocumentNode
  | OperationDefinitionNode
  | VariableDefinitionNode
  | VariableNode
  | SelectionSetNode
  | FieldNode
  | ArgumentNode
  | FragmentArgumentNode
  | FragmentSpreadNode
  | InlineFragmentNode
  | FragmentDefinitionNode
  | IntValueNode
  | FloatValueNode
  | StringValueNode
  | BooleanValueNode
  | NullValueNode
  | EnumValueNode
  | ListValueNode
  | ObjectValueNode
  | ObjectFieldNode
  | DirectiveNode
  | NamedTypeNode
  | ListTypeNode
  | NonNullTypeNode
  | SchemaDefinitionNode
  | OperationTypeDefinitionNode
  | ScalarTypeDefinitionNode
  | ObjectTypeDefinitionNode
  | FieldDefinitionNode
  | InputValueDefinitionNode
  | InterfaceTypeDefinitionNode
  | UnionTypeDefinitionNode
  | EnumTypeDefinitionNode
  | EnumValueDefinitionNode
  | InputObjectTypeDefinitionNode
  | DirectiveDefinitionNode
  | SchemaExtensionNode
  | ScalarTypeExtensionNode
  | ObjectTypeExtensionNode
  | InterfaceTypeExtensionNode
  | UnionTypeExtensionNode
  | EnumTypeExtensionNode
  | InputObjectTypeExtensionNode
  | DirectiveExtensionNode
  | TypeCoordinateNode
  | MemberCoordinateNode
  | ArgumentCoordinateNode
  | DirectiveCoordinateNode
  | DirectiveArgumentCoordinateNode;

ASTKindToNode

Type alias. Utility type listing all nodes indexed by their kind.

type ASTKindToNode = mapped object;

NameNode

Interface. An identifier in a GraphQL document.

DocumentNode

Interface. The root AST node for a parsed GraphQL document.

DefinitionNode

Type alias. Any top-level definition that may appear in a GraphQL document.

type DefinitionNode =
  | ExecutableDefinitionNode
  | TypeSystemDefinitionNode
  | TypeSystemExtensionNode;

ExecutableDefinitionNode

Type alias. Any executable definition that may appear in an operation document.

type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;

OperationDefinitionNode

Interface. A query, mutation, or subscription operation definition.

SubscriptionOperationDefinitionNode

Interface. A narrowed OperationDefinitionNode for subscription operations. Subscription operations go through a distinct execution pipeline (source event stream + per-event execution), so narrowing the operation type allows functions in that pipeline to accept only valid input.

interface SubscriptionOperationDefinitionNode extends OperationDefinitionNode

VariableDefinitionNode

Interface. A variable declaration in an operation or experimental fragment definition.

VariableNode

Interface. A variable reference, such as $id.

SelectionSetNode

Interface. A set of fields and fragments selected from an object, interface, or union.

SelectionNode

Type alias. Any selection that may appear inside a selection set.

type SelectionNode =
  | FieldNode
  | FragmentSpreadNode
  | InlineFragmentNode;

FieldNode

Interface. A field selected in an executable GraphQL document.

ArgumentNode

Interface. An argument supplied to a field or directive.

ConstArgumentNode

Interface. An argument node whose value is guaranteed to be constant.

FragmentArgumentNode

Interface. Variable definition declared by a fragment argument.

FragmentSpreadNode

Interface. A named fragment spread, such as ...userFields.

InlineFragmentNode

Interface. An inline fragment spread with an optional type condition.

FragmentDefinitionNode

Interface. A reusable fragment definition declared in an executable document.

ValueNode

Type alias. Any value literal that may appear in an executable GraphQL document.

type ValueNode =
  | VariableNode
  | IntValueNode
  | FloatValueNode
  | StringValueNode
  | BooleanValueNode
  | NullValueNode
  | EnumValueNode
  | ListValueNode
  | ObjectValueNode;

ConstValueNode

Type alias. Any value literal that is guaranteed not to contain a variable reference.

type ConstValueNode =
  | IntValueNode
  | FloatValueNode
  | StringValueNode
  | BooleanValueNode
  | NullValueNode
  | EnumValueNode
  | ConstListValueNode
  | ConstObjectValueNode;

IntValueNode

Interface. An integer value literal.

FloatValueNode

Interface. A floating-point value literal.

StringValueNode

Interface. A string value literal.

BooleanValueNode

Interface. A boolean value literal.

NullValueNode

Interface. A null value literal.

EnumValueNode

Interface. An enum value literal.

ListValueNode

Interface. A list value literal.

ConstListValueNode

Interface. A list value literal whose elements are all constant values.

ObjectValueNode

Interface. An input object value literal.

ConstObjectValueNode

Interface. An input object value literal whose fields are all constant values.

ObjectFieldNode

Interface. A field inside an input object value literal.

ConstObjectFieldNode

Interface. A field inside a constant input object value literal.

DirectiveNode

Interface. A directive applied to an executable or type-system location.

ConstDirectiveNode

Interface. A directive whose arguments are all constant values.

TypeNode

Type alias. Any GraphQL type reference AST node.

type TypeNode =
  | NamedTypeNode
  | ListTypeNode
  | NonNullTypeNode;

NamedTypeNode

Interface. A named type reference.

ListTypeNode

Interface. A list type reference.

NonNullTypeNode

Interface. A non-null type reference.

TypeSystemDefinitionNode

Type alias. Any type-system definition that may appear in a schema document.

type TypeSystemDefinitionNode =
  | SchemaDefinitionNode
  | TypeDefinitionNode
  | DirectiveDefinitionNode;

SchemaDefinitionNode

Interface. A schema definition in a type-system document.

OperationTypeDefinitionNode

Interface. A root operation type declaration inside a schema definition or extension.

TypeDefinitionNode

Type alias. Any named type definition that may appear in a schema document.

type TypeDefinitionNode =
  | ScalarTypeDefinitionNode
  | ObjectTypeDefinitionNode
  | InterfaceTypeDefinitionNode
  | UnionTypeDefinitionNode
  | EnumTypeDefinitionNode
  | InputObjectTypeDefinitionNode;

ScalarTypeDefinitionNode

Interface. A scalar type definition in a type-system document.

ObjectTypeDefinitionNode

Interface. An object type definition in a type-system document.

FieldDefinitionNode

Interface. A field definition declared by an object or interface type.

InputValueDefinitionNode

Interface. An argument or input-field definition.

InterfaceTypeDefinitionNode

Interface. An interface type definition in a type-system document.

UnionTypeDefinitionNode

Interface. A union type definition in a type-system document.

EnumTypeDefinitionNode

Interface. An enum type definition in a type-system document.

EnumValueDefinitionNode

Interface. An enum value definition.

InputObjectTypeDefinitionNode

Interface. An input object type definition in a type-system document.

DirectiveDefinitionNode

Interface. A directive definition in a type-system document.

TypeSystemExtensionNode

Type alias. Any type-system extension that may appear in a schema extension document.

type TypeSystemExtensionNode =
  | SchemaExtensionNode
  | TypeExtensionNode
  | DirectiveExtensionNode;

SchemaExtensionNode

Interface. A schema extension in a type-system document.

TypeExtensionNode

Type alias. Any named type extension that may appear in a schema extension document.

type TypeExtensionNode =
  | ScalarTypeExtensionNode
  | ObjectTypeExtensionNode
  | InterfaceTypeExtensionNode
  | UnionTypeExtensionNode
  | EnumTypeExtensionNode
  | InputObjectTypeExtensionNode;

ScalarTypeExtensionNode

Interface. A scalar type extension.

ObjectTypeExtensionNode

Interface. An object type extension.

InterfaceTypeExtensionNode

Interface. An interface type extension.

UnionTypeExtensionNode

Interface. A union type extension.

EnumTypeExtensionNode

Interface. An enum type extension.

InputObjectTypeExtensionNode

Interface. An input object type extension.

DirectiveExtensionNode

Interface. A directive extension.

SchemaCoordinateNode

Type alias. Any AST node representing a GraphQL schema coordinate.

type SchemaCoordinateNode =
  | TypeCoordinateNode
  | MemberCoordinateNode
  | ArgumentCoordinateNode
  | DirectiveCoordinateNode
  | DirectiveArgumentCoordinateNode;

TypeCoordinateNode

Interface. A schema coordinate that refers to a named type.

MemberCoordinateNode

Interface. A schema coordinate that refers to a member of a named type.

ArgumentCoordinateNode

Interface. A schema coordinate that refers to a field or directive argument.

DirectiveCoordinateNode

Interface. A schema coordinate that refers to a directive.

DirectiveArgumentCoordinateNode

Interface. A schema coordinate that refers to a directive argument.

Category: Kinds

Enumerations

OperationTypeNode

Enumeration. The operation types supported by GraphQL executable definitions.

This is not a TypeScript enum. GraphQL.js exports OperationTypeNode as both a runtime const object of literal values and a TypeScript type alias for those values.

DirectiveLocation

Enumeration. The set of allowed directive location values.

This is not a TypeScript enum. GraphQL.js exports DirectiveLocation as both a runtime const object of literal values and a TypeScript type alias for those values.

Kind

Enumeration.

This is not a TypeScript enum. GraphQL.js exports Kind as both a runtime namespace object of literal values and a TypeScript type alias for those values.

Category: Lexing

Classes

Lexer

Given a Source object, creates a Lexer for that source. A Lexer is a stateful stream generator in that every time it is advanced, it returns the next token in the Source. Assuming the source lexes, the final Token emitted by the lexer will be of kind EOF, after which the lexer will repeatedly return the same EOF token whenever called.

Constructor

Creates a Lexer instance.

Signature:

new Lexer(source: Source);

Members

advance()

Advances the token stream to the next non-ignored token.

Signature:

advance(): Token;

import { Lexer, Source } from 'graphql/language';
 
const lexer = new Lexer(new Source('{ hello }'));
const token = lexer.advance();
 
token.kind; // => '{'
lexer.token; // => token

lookahead()

Looks ahead and returns the next non-ignored token, but does not change the state of Lexer.

Signature:

lookahead(): Token;

import { Lexer, Source } from 'graphql/language';
 
const lexer = new Lexer(new Source('{ hello }'));
const token = lexer.lookahead();
 
token.kind; // => '{'
lexer.token.kind; // => '<SOF>'

Enumerations

TokenKind

Enumeration. An exported enum describing the different kinds of tokens that the lexer emits.

This is not a TypeScript enum. GraphQL.js exports TokenKind as both a runtime const object of literal values and a TypeScript type alias for those values.

Category: Source

Classes

Source

A representation of source input to GraphQL. The name and locationOffset parameters are optional, but they are useful for clients who store GraphQL documents in source files. For example, if the GraphQL input starts at line 40 in a file named Foo.graphql, it might be useful for name to be "Foo.graphql" and location to be { line: 40, column: 1 }. The line and column properties in locationOffset are 1-indexed.

Constructor

Creates a Source instance.

Signature:

new Source(
  body: string,
  name: string = 'GraphQL request',
  locationOffset: {
    line: number;
    column: number;
  } = { line: 1, column: 1 },
);

Members

Functions

getLocation()

Takes a Source and a UTF-8 character offset, and returns the corresponding line and column as a SourceLocation.

Signature:

getLocation(
  source: Source,
  position: number,
): SourceLocation;

import { Source, getLocation } from 'graphql/language';
 
const source = new Source('type Query { hello: String }');
const location = getLocation(source, 13);
 
location; // => { line: 1, column: 14 }

printLocation()

Render a helpful description of the location in the GraphQL Source document.

Signature:

printLocation(location: Location): string;

import { parse, printLocation } from 'graphql/language';
 
const document = parse('type Query { hello: String }');
const location = document.definitions[0].loc;
 
if (location) {
  const printed = printLocation(location);
 
  printed; // => 'GraphQL request:1:1\n1 | type Query { hello: String }\n  | ^'
}

printSourceLocation()

Render a helpful description of the location in the GraphQL Source document.

Signature:

printSourceLocation(
  source: Source,
  sourceLocation: SourceLocation,
): string;

import { Source, printSourceLocation } from 'graphql/language';
 
const source = new Source('type Query { hello: String }');
const printed = printSourceLocation(source, { line: 1, column: 14 });
 
printed; // => 'GraphQL request:1:14\n1 | type Query { hello: String }\n  |              ^'

Types

SourceLocation

Interface. Represents a location in a Source.

Category: Parsing

Functions

parse()

Given a GraphQL source, parses it into a Document. Throws GraphQLError if a syntax error is encountered.

Signature:

parse(
  source: string | Source,
  options?: ParseOptions,
): DocumentNode;

// Parse a GraphQL document with the default parser options.
import { parse } from 'graphql/language';
 
const document = parse('{ hero { name } }');
 
document.kind; // => 'Document'

// This variant enables parser options and provides an explicit lexer.
import { Lexer, Source, parse } from 'graphql/language';
 
const document = parse(`
  {
    t { ...A(var: true) }
  }
  fragment A($var: Boolean = false) on T {
    name
  }
`, {
  experimentalFragmentArguments: true,
  maxTokens: 80,
  noLocation: true,
});
const directiveDocument = parse('directive @foo @bar on FIELD', {
  experimentalDirectivesOnDirectiveDefinitions: true,
});
const source = new Source('{ hero }');
const lexerDocument = parse(source, { lexer: new Lexer(source) });
 
document.definitions[0].kind; // => 'OperationDefinition'
document.definitions[1].kind; // => 'FragmentDefinition'
document.loc; // => undefined
directiveDocument.definitions[0].kind; // => 'DirectiveDefinition'
lexerDocument.definitions[0].kind; // => 'OperationDefinition'

parseValue()

Given a string containing a GraphQL value (ex. [42]), parse the AST for that value. Throws GraphQLError if a syntax error is encountered.

This is useful within tools that operate upon GraphQL Values directly and in isolation of complete GraphQL documents.

Consider providing the results to the utility function: valueFromAST().

Signature:

parseValue(
  source: string | Source,
  options?: ParseOptions,
): ValueNode;

import { parseValue } from 'graphql/language';
 
const value = parseValue('[42]');
 
value.kind; // => 'ListValue'

parseConstValue()

Similar to parseValue(), but raises a parse error if it encounters a variable. The return type will be a constant value.

Signature:

parseConstValue(
  source: string | Source,
  options?: ParseOptions,
): ConstValueNode;

import { parseConstValue } from 'graphql/language';
 
const value = parseConstValue('{ enabled: true }');
 
value.kind; // => 'ObjectValue'
parseConstValue('$variable'); // throws an error

parseType()

Given a string containing a GraphQL Type (ex. [Int!]), parse the AST for that type. Throws GraphQLError if a syntax error is encountered.

This is useful within tools that operate upon GraphQL Types directly and in isolation of complete GraphQL documents.

Consider providing the results to the utility function: typeFromAST().

Signature:

parseType(
  source: string | Source,
  options?: ParseOptions,
): TypeNode;

import { parseType } from 'graphql/language';
 
const type = parseType('[String!]');
 
type.kind; // => 'ListType'

parseSchemaCoordinate()

Given a string containing a GraphQL Schema Coordinate (ex. Type.field), parse the AST for that schema coordinate. Throws GraphQLError if a syntax error is encountered.

Consider providing the results to the utility function: resolveASTSchemaCoordinate(). Or calling resolveSchemaCoordinate() directly with an unparsed source.

Signature:

parseSchemaCoordinate(
  source: string | Source,
): SchemaCoordinateNode;

import { parseSchemaCoordinate } from 'graphql/language';
 
const coordinate = parseSchemaCoordinate('Query.hero');
 
coordinate.kind; // => 'MemberCoordinate'

Types

ParseOptions

Interface. Configuration options to control parser behavior

{
  t { ...A(var: true) }
}
fragment A($var: Boolean = false) on T {
  ...B(x: $var)
}

directive @foo @bar on FIELD

Category: AST Predicates

Functions

isDefinitionNode()

Returns true when the AST node is a definition node.

Signature:

isDefinitionNode(
  node: ASTNode,
): node is DefinitionNode;

import { parse, isDefinitionNode } from 'graphql/language';
 
const document = parse('{ hello }');
 
isDefinitionNode(document.definitions[0]); // => true
isDefinitionNode(document); // => false

isExecutableDefinitionNode()

Returns true when the AST node is an executable definition node.

Signature:

isExecutableDefinitionNode(
  node: ASTNode,
): node is ExecutableDefinitionNode;

import { parse, isExecutableDefinitionNode } from 'graphql/language';
 
const query = parse('{ hello }');
const schema = parse('type Query { hello: String }');
 
isExecutableDefinitionNode(query.definitions[0]); // => true
isExecutableDefinitionNode(schema.definitions[0]); // => false

isSubscriptionOperationDefinitionNode()

A type predicate for SubscriptionOperationDefinitionNode. Useful anywhere that must distinguish subscription operations from queries and mutations, such as the subscription execution pipeline which routes events through a different code path.

Signature:

isSubscriptionOperationDefinitionNode(
  node: OperationDefinitionNode,
): node is SubscriptionOperationDefinitionNode;

import { parse, isSubscriptionOperationDefinitionNode } from 'graphql/language';
 
const subscription = parse('subscription { greeting }').definitions[0];
const query = parse('{ greeting }').definitions[0];
 
isSubscriptionOperationDefinitionNode(subscription); // => true
isSubscriptionOperationDefinitionNode(query); // => false

isSelectionNode()

Returns true when the AST node is a selection node.

Signature:

isSelectionNode(
  node: ASTNode,
): node is SelectionNode;

import { Kind, isSelectionNode } from 'graphql/language';
 
const field = { kind: Kind.FIELD, name: { kind: Kind.NAME, value: 'hello' } };
const document = { kind: Kind.DOCUMENT, definitions: [] };
 
isSelectionNode(field); // => true
isSelectionNode(document); // => false

isValueNode()

Returns true when the AST node is a value node.

Signature:

isValueNode(
  node: ASTNode,
): node is ValueNode;

import { parseType, parseValue, isValueNode } from 'graphql/language';
 
const value = parseValue('[42]');
const type = parseType('[String!]');
 
isValueNode(value); // => true
isValueNode(type); // => false

isConstValueNode()

Returns true when the AST node is a constant value node.

Signature:

isConstValueNode(
  node: ASTNode,
): node is ConstValueNode;

import { parseConstValue, parseValue, isConstValueNode } from 'graphql/language';
 
const value = parseConstValue('[42]');
const variable = parseValue('$id');
 
isConstValueNode(value); // => true
isConstValueNode(variable); // => false

isTypeNode()

Returns true when the AST node is a type node.

Signature:

isTypeNode(
  node: ASTNode,
): node is TypeNode;

import { parseType, parseValue, isTypeNode } from 'graphql/language';
 
const type = parseType('[String!]');
const value = parseValue('[42]');
 
isTypeNode(type); // => true
isTypeNode(value); // => false

isTypeSystemDefinitionNode()

Returns true when the AST node is a type system definition node.

Signature:

isTypeSystemDefinitionNode(
  node: ASTNode,
): node is TypeSystemDefinitionNode;

import { parse, isTypeSystemDefinitionNode } from 'graphql/language';
 
const schema = parse('type Query { hello: String }');
const query = parse('{ hello }');
 
isTypeSystemDefinitionNode(schema.definitions[0]); // => true
isTypeSystemDefinitionNode(query.definitions[0]); // => false

isTypeDefinitionNode()

Returns true when the AST node is a type definition node.

Signature:

isTypeDefinitionNode(
  node: ASTNode,
): node is TypeDefinitionNode;

import { parse, isTypeDefinitionNode } from 'graphql/language';
 
const typeDefinition = parse('type Query { hello: String }');
const directiveDefinition = parse('directive @cache on FIELD');
 
isTypeDefinitionNode(typeDefinition.definitions[0]); // => true
isTypeDefinitionNode(directiveDefinition.definitions[0]); // => false

isTypeSystemExtensionNode()

Returns true when the AST node is a type system extension node.

Signature:

isTypeSystemExtensionNode(
  node: ASTNode,
): node is TypeSystemExtensionNode;

import { parse, isTypeSystemExtensionNode } from 'graphql/language';
 
const extension = parse('extend type Query { hello: String }');
const definition = parse('type Query { hello: String }');
 
isTypeSystemExtensionNode(extension.definitions[0]); // => true
isTypeSystemExtensionNode(definition.definitions[0]); // => false

isTypeExtensionNode()

Returns true when the AST node is a type extension node.

Signature:

isTypeExtensionNode(
  node: ASTNode,
): node is TypeExtensionNode;

import { parse, isTypeExtensionNode } from 'graphql/language';
 
const extension = parse('extend type Query { hello: String }');
const schemaExtension = parse('extend schema { query: Query }');
 
isTypeExtensionNode(extension.definitions[0]); // => true
isTypeExtensionNode(schemaExtension.definitions[0]); // => false

isSchemaCoordinateNode()

Returns true when the AST node is a schema coordinate node.

Signature:

isSchemaCoordinateNode(
  node: ASTNode,
): node is SchemaCoordinateNode;

import {
  parse,
  parseSchemaCoordinate,
  isSchemaCoordinateNode,
} from 'graphql/language';
 
const coordinate = parseSchemaCoordinate('Query.hero');
const document = parse('{ hero }');
 
isSchemaCoordinateNode(coordinate); // => true
isSchemaCoordinateNode(document); // => false

Category: Printing

Functions

print()

Converts an AST into a string, using one set of reasonable formatting rules.

Signature:

print(ast: ASTNode): string;

import { parse, print } from 'graphql';
 
const ast = parse('{ hero { name } }');
const text = print(ast);
 
text; // => '{\n  hero {\n    name\n  }\n}'

Category: Visiting

Functions

visitInParallel()

Creates a new visitor instance which delegates to many visitors to run in parallel. Each visitor will be visited for each node before moving on.

If a prior visitor edits a node, no following visitors will see that node.

Signature:

visitInParallel(
  visitors: readonly ASTVisitor[],
): ASTVisitor;

import { parse, visit, visitInParallel } from 'graphql/language';
 
const document = parse('{ hero { name } }');
const events = [];
 
visit(
  document,
  visitInParallel([
    { Field: (node) => { events.push(`field:${node.name.value}`); } },
    { Name: (node) => { events.push(`name:${node.value}`); } },
  ]),
);
 
events; // => ['field:hero', 'name:hero', 'field:name', 'name:name']

getEnterLeaveForKind()

Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.

Signature:

getEnterLeaveForKind(
  visitor: ASTVisitor,
  kind: Kind,
): {
  enter?: ASTVisitFn<ASTNode> | undefined;
  leave?: ASTVisitFn<ASTNode> | undefined;
};

import { Kind, getEnterLeaveForKind } from 'graphql/language';
 
const handlers = getEnterLeaveForKind({ Field: () => {} }, Kind.FIELD);
 
typeof handlers.enter; // => 'function'
handlers.leave; // => undefined

Constants

BREAK

A value that can be returned from a visitor function to stop traversal.

Types

ASTVisitor

Type alias. A visitor defines the callbacks called during AST traversal.

type ASTVisitor =
  | {
      enter?:
        | ASTVisitFn<ASTNode>
        | undefined;
      leave?:
        | ASTVisitFn<ASTNode>
        | undefined;
    }
  | {
      readonly [NodeT in ASTNode as NodeT['kind']]?:
        | ASTVisitFn<NodeT>
        | EnterLeaveVisitor<NodeT>;
    };

ASTVisitFn

Type alias. A visitor is composed of visit functions called for each node during traversal.

type ASTVisitFn<TVisitedNode extends ASTNode> = (
  node: TVisitedNode,
  key: string | number | undefined,
  parent:
    | ASTNode
    | ReadonlyArray<ASTNode>
    | undefined,
  path: ReadonlyArray<string | number>,
  ancestors: ReadonlyArray<
    ASTNode | ReadonlyArray<ASTNode>
  >,
) => any;

ASTVisitorKeyMap

Type alias. A visitor key map describes the traversable child properties for each node kind.

type ASTVisitorKeyMap = mapped object;