Aller au contenu principal

@babel/types

Traduction Bêta Non Officielle

Cette page a été traduite par PageTurner AI (bêta). Non approuvée officiellement par le projet. Vous avez trouvé une erreur ? Signaler un problème →

Ce module contient des méthodes pour construire manuellement des AST et pour vérifier les types de nœuds AST.

Installation​

npm install --save-dev @babel/types

API​

Constructeurs de nœuds​

anyTypeAnnotation​

JavaScript
t.anyTypeAnnotation();

Voir aussi t.isAnyTypeAnnotation(node, opts) et t.assertAnyTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

argumentPlaceholder​

JavaScript
t.argumentPlaceholder();

Voir aussi t.isArgumentPlaceholder(node, opts) et t.assertArgumentPlaceholder(node, opts).

arrayExpression​

JavaScript
t.arrayExpression(elements);

Voir aussi t.isArrayExpression(node, opts) et t.assertArrayExpression(node, opts).

Structure du nœud AST ArrayExpression :

  • elements: (null | Expression | SpreadElement)[] (par défaut : [])

Alias : Standardized, Expression

arrayPattern​

JavaScript
t.arrayPattern(elements);

Voir aussi t.isArrayPattern(node, opts) et t.assertArrayPattern(node, opts).

Structure du nœud AST ArrayPattern :

  • elements: (null | PatternLike)[] (requis)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

Alias : Standardized, FunctionParameter, Pattern, PatternLike, LVal

arrayTypeAnnotation​

JavaScript
t.arrayTypeAnnotation(elementType);

Voir aussi t.isArrayTypeAnnotation(node, opts) et t.assertArrayTypeAnnotation(node, opts).

Structure du nœud AST ArrayTypeAnnotation :

  • elementType: FlowType (requis)

Alias : Flow, FlowType

arrowFunctionExpression​

JavaScript
t.arrowFunctionExpression(params, body, async);

Voir aussi t.isArrowFunctionExpression(node, opts) et t.assertArrowFunctionExpression(node, opts).

Structure du nœud AST ArrowFunctionExpression :

  • params: FunctionParameter[] (requis)

  • body: BlockStatement | Expression (requis)

  • async : boolean (par défaut : false)

  • expression: boolean (requis)

  • generator : boolean (par défaut : false, exclu de la fonction de construction)

  • predicate: DeclaredPredicate | InferredPredicate (par défaut : null, exclu de la fonction de construction)

  • returnType : TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Aliases: Standardized, Scopable, Function, BlockParent, FunctionParent, Expression, Pureish

assignmentExpression​

JavaScript
t.assignmentExpression(operator, left, right);

Voir aussi t.isAssignmentExpression(node, opts) et t.assertAssignmentExpression(node, opts).

Structure du nœud AST AssignmentExpression :

  • operator: string (requis)

  • left: LVal | OptionalMemberExpression (requis)

  • right : Expression (requis)

Alias : Standardized, Expression

assignmentPattern​

JavaScript
t.assignmentPattern(left, right);

Voir aussi t.isAssignmentPattern(node, opts) et t.assertAssignmentPattern(node, opts).

Structure du nœud AST AssignmentPattern :

  • left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression (requis)

  • right : Expression (requis)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

Alias : Standardized, FunctionParameter, Pattern, PatternLike, LVal

awaitExpression​

JavaScript
t.awaitExpression(argument);

Voir aussi t.isAwaitExpression(node, opts) et t.assertAwaitExpression(node, opts).

Structure du nœud AST AwaitExpression :

  • argument : Expression (obligatoire)

Alias : Standardized, Expression, Terminatorless

bigIntLiteral​

JavaScript
t.bigIntLiteral(value);

Voir aussi t.isBigIntLiteral(node, opts) et t.assertBigIntLiteral(node, opts).

Structure du nœud AST BigIntLiteral :

  • value : string (requis)

Alias : Standardized, Expression, Pureish, Literal, Immutable

binaryExpression​

JavaScript
t.binaryExpression(operator, left, right);

Voir aussi t.isBinaryExpression(node, opts) et t.assertBinaryExpression(node, opts).

Structure du nœud AST BinaryExpression :

  • operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>" (requis)

  • left: Expression | PrivateName (requis)

  • right : Expression (requis)

Alias : Standardized, Binary, Expression

bindExpression​

JavaScript
t.bindExpression(object, callee);

Voir aussi t.isBindExpression(node, opts) et t.assertBindExpression(node, opts).

Forme du nœud AST BindExpression :

  • object: Expression (requis)

  • callee: Expression (requis)

Alias : Expression

blockStatement​

JavaScript
t.blockStatement(body, directives);

Voir aussi t.isBlockStatement(node, opts) et t.assertBlockStatement(node, opts).

Forme du nœud AST BlockStatement :

  • body: Statement[] (requis)

  • directives: Directive[] (par défaut : [])

Alias : Standardized, Scopable, BlockParent, Block, Statement

booleanLiteral​

JavaScript
t.booleanLiteral(value);

Voir aussi t.isBooleanLiteral(node, opts) et t.assertBooleanLiteral(node, opts).

Forme du nœud AST BooleanLiteral :

  • value : boolean (requis)

Alias : Standardized, Expression, Pureish, Literal, Immutable

booleanLiteralTypeAnnotation​

JavaScript
t.booleanLiteralTypeAnnotation(value);

Voir aussi t.isBooleanLiteralTypeAnnotation(node, opts) et t.assertBooleanLiteralTypeAnnotation(node, opts).

Forme du nœud AST BooleanLiteralTypeAnnotation :

  • value : boolean (requis)

Alias : Flow, FlowType

booleanTypeAnnotation​

JavaScript
t.booleanTypeAnnotation();

Voir aussi t.isBooleanTypeAnnotation(node, opts) et t.assertBooleanTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

breakStatement​

JavaScript
t.breakStatement(label);

Voir aussi t.isBreakStatement(node, opts) et t.assertBreakStatement(node, opts).

Forme du nœud AST BreakStatement :

  • label: Identifier (par défaut : null)

Alias : Standardized, Statement, Terminatorless, CompletionStatement

callExpression​

JavaScript
t.callExpression(callee, arguments);

Voir aussi t.isCallExpression(node, opts) et t.assertCallExpression(node, opts).

Forme du nœud AST CallExpression :

  • callee : Expression | Super | V8IntrinsicIdentifier (requis)

  • arguments: (Expression | SpreadElement | ArgumentPlaceholder)[] (requis)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeArguments: TypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

  • typeParameters: TSTypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

Alias : Standardized, Expression

catchClause​

JavaScript
t.catchClause(param, body);

Voir aussi t.isCatchClause(node, opts) et t.assertCatchClause(node, opts).

Structure du nœud AST CatchClause :

  • param : Identifier | ArrayPattern | ObjectPattern (par défaut : null)

  • body : BlockStatement (requis)

Alias : Standardized, Scopable, BlockParent

classAccessorProperty​

JavaScript
t.classAccessorProperty(key, value, typeAnnotation, decorators, computed, static);

Voir aussi t.isClassAccessorProperty(node, opts) et t.assertClassAccessorProperty(node, opts).

Structure du nœud AST ClassAccessorProperty :

  • key : Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName (obligatoire)

  • value: Expression (par défaut : null)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null)

  • decorators: Decorator[] (vaut null par défaut)

  • computed: boolean (défaut : false)

  • static: boolean (par défaut : false)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

  • accessibility: "public" | "private" | "protected" (par défaut: null, exclu de la fonction builder)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • definite: boolean (par défaut : null, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • override : boolean (par défaut : false, exclu de la fonction de construction)

  • readonly: boolean (par défaut: null, exclu de la fonction builder)

  • variance: Variance (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Property, Accessor

classBody​

JavaScript
t.classBody(body);

Voir aussi t.isClassBody(node, opts) et t.assertClassBody(node, opts).

Structure du nœud AST ClassBody :

  • body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[] (requis)

Alias : Standardized

classDeclaration​

JavaScript
t.classDeclaration(id, superClass, body, decorators);

Voir aussi t.isClassDeclaration(node, opts) et t.assertClassDeclaration(node, opts).

Structure du nœud AST ClassDeclaration :

  • id: Identifier (par défaut : null)

  • superClass : Expression (par défaut : null)

  • body : ClassBody (requis)

  • decorators: Decorator[] (vaut null par défaut)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • implements: (TSExpressionWithTypeArguments | ClassImplements)[] (par défaut : null, exclu de la fonction de construction)

  • mixins : InterfaceExtends (par défaut : null, exclu de la fonction de construction)

  • superTypeParameters : TypeParameterInstantiation | TSTypeParameterInstantiation (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Scopable, Class, Statement, Declaration

classExpression​

JavaScript
t.classExpression(id, superClass, body, decorators);

Voir aussi t.isClassExpression(node, opts) et t.assertClassExpression(node, opts).

Structure du nœud AST ClassExpression :

  • id: Identifier (par défaut : null)

  • superClass : Expression (par défaut : null)

  • body : ClassBody (requis)

  • decorators: Decorator[] (vaut null par défaut)

  • implements: (TSExpressionWithTypeArguments | ClassImplements)[] (par défaut : null, exclu de la fonction de construction)

  • mixins : InterfaceExtends (par défaut : null, exclu de la fonction de construction)

  • superTypeParameters : TypeParameterInstantiation | TSTypeParameterInstantiation (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Scopable, Class, Expression

classImplements​

JavaScript
t.classImplements(id, typeParameters);

Voir aussi t.isClassImplements(node, opts) et t.assertClassImplements(node, opts).

Structure du nœud AST ClassImplements :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterInstantiation (par défaut : null)

Alias : Flow

classMethod​

JavaScript
t.classMethod(kind, key, params, body, computed, static, generator, async);

Voir aussi t.isClassMethod(node, opts) et t.assertClassMethod(node, opts).

Structure du nœud AST ClassMethod :

  • kind : "get" | "set" | "method" | "constructor" (par défaut : 'method')

  • key : si calculé alors Expression sinon Identifier | Literal (requis)

  • params: (FunctionParameter | TSParameterProperty)[] (requis)

  • body : BlockStatement (requis)

  • computed: boolean (défaut : false)

  • static: boolean (par défaut : false)

  • generator : boolean (par défaut : false)

  • async : boolean (par défaut : false)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

  • access : "public" | "private" | "protected" (par défaut : null, exclu de la fonction de construction)

  • accessibility: "public" | "private" | "protected" (par défaut: null, exclu de la fonction builder)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • override : boolean (par défaut : false, exclu de la fonction de construction)

  • returnType : TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Function, Scopable, BlockParent, FunctionParent, Method

classPrivateMethod​

JavaScript
t.classPrivateMethod(kind, key, params, body, static);

Voir aussi t.isClassPrivateMethod(node, opts) et t.assertClassPrivateMethod(node, opts).

Structure du nœud AST ClassPrivateMethod :

  • kind: "get" | "set" | "method" (par défaut : 'method')

  • key: PrivateName (requis)

  • params: (FunctionParameter | TSParameterProperty)[] (requis)

  • body : BlockStatement (requis)

  • static: boolean (par défaut : false)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

  • access : "public" | "private" | "protected" (par défaut : null, exclu de la fonction de construction)

  • accessibility: "public" | "private" | "protected" (par défaut: null, exclu de la fonction builder)

  • async : boolean (par défaut : false, exclu de la fonction de construction)

  • computed: 'false' (par défaut : false, exclu de la fonction de construction)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • generator : boolean (par défaut : false, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • override : boolean (par défaut : false, exclu de la fonction de construction)

  • returnType : TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Function, Scopable, BlockParent, FunctionParent, Method, Private

classPrivateProperty​

JavaScript
t.classPrivateProperty(key, value, decorators, static);

Voir aussi t.isClassPrivateProperty(node, opts) et t.assertClassPrivateProperty(node, opts).

Structure du nœud AST ClassPrivateProperty :

  • key: PrivateName (requis)

  • value: Expression (par défaut : null)

  • decorators: Decorator[] (vaut null par défaut)

  • static: boolean (par défaut : false)

  • definite: boolean (par défaut : null, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • readonly: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

  • variance: Variance (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Property, Private

classProperty​

JavaScript
t.classProperty(key, value, typeAnnotation, decorators, computed, static);
History
VersionChanges
v7.6.0Supports static

Voir aussi t.isClassProperty(node, opts) et t.assertClassProperty(node, opts).

Structure du nœud AST ClassProperty :

  • key : Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression (requis)

  • value: Expression (par défaut : null)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null)

  • decorators: Decorator[] (vaut null par défaut)

  • computed: boolean (défaut : false)

  • static: boolean (par défaut : false)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

  • accessibility: "public" | "private" | "protected" (par défaut: null, exclu de la fonction builder)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • definite: boolean (par défaut : null, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • override : boolean (par défaut : false, exclu de la fonction de construction)

  • readonly: boolean (par défaut: null, exclu de la fonction builder)

  • variance: Variance (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Property

conditionalExpression​

JavaScript
t.conditionalExpression(test, consequent, alternate);

Voir aussi t.isConditionalExpression(node, opts) et t.assertConditionalExpression(node, opts).

Structure du nœud AST ConditionalExpression :

  • test: Expression (requis)

  • consequent: Expression (requis)

  • alternate: Expression (requis)

Alias : Standardized, Expression, Conditional

continueStatement​

JavaScript
t.continueStatement(label);

Voir aussi t.isContinueStatement(node, opts) et t.assertContinueStatement(node, opts).

Structure du nœud AST ContinueStatement :

  • label: Identifier (par défaut : null)

Alias : Standardized, Statement, Terminatorless, CompletionStatement

debuggerStatement​

JavaScript
t.debuggerStatement();

Voir aussi t.isDebuggerStatement(node, opts) et t.assertDebuggerStatement(node, opts).

Alias : Standardized, Statement

decimalLiteral​

JavaScript
t.decimalLiteral(value);

Voir aussi t.isDecimalLiteral(node, opts) et t.assertDecimalLiteral(node, opts).

Structure du nœud AST DecimalLiteral :

  • value : string (requis)

Alias : Expression, Pureish, Literal, Immutable

declareClass​

JavaScript
t.declareClass(id, typeParameters, extends, body);

Voir aussi t.isDeclareClass(node, opts) et t.assertDeclareClass(node, opts).

Structure du nœud AST DeclareClass :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • extends: InterfaceExtends[] (par défaut : null)

  • body: ObjectTypeAnnotation (requis)

  • implements: ClassImplements[] (par défaut : null, exclu de la fonction de construction)

  • mixins: InterfaceExtends[] (par défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareExportAllDeclaration​

JavaScript
t.declareExportAllDeclaration(source, attributes);

Voir aussi t.isDeclareExportAllDeclaration(node, opts) et t.assertDeclareExportAllDeclaration(node, opts).

Structure du nœud AST DeclareExportAllDeclaration :

  • source: StringLiteral (required)

  • attributes: ImportAttribute[] (par défaut : null)

  • assertions: ImportAttribute[] (par défaut : null, exclu de la fonction de construction)

  • exportKind : "type" | "value" (par défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareExportDeclaration​

JavaScript
t.declareExportDeclaration(declaration, specifiers, source, attributes);

Voir aussi t.isDeclareExportDeclaration(node, opts) et t.assertDeclareExportDeclaration(node, opts).

Structure du nœud AST DeclareExportDeclaration :

  • declaration : Flow (défaut : null)

  • specifiers: (ExportSpecifier | ExportNamespaceSpecifier)[] (par défaut : null)

  • source: StringLiteral (défaut: null)

  • attributes: ImportAttribute[] (par défaut : null)

  • assertions: ImportAttribute[] (par défaut : null, exclu de la fonction de construction)

  • default : boolean (défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareFunction​

JavaScript
t.declareFunction(id);

Voir aussi t.isDeclareFunction(node, opts) et t.assertDeclareFunction(node, opts).

Structure du nœud AST DeclareFunction :

  • id: Identifier (obligatoire)

  • predicate : DeclaredPredicate (défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareInterface​

JavaScript
t.declareInterface(id, typeParameters, extends, body);

Voir aussi t.isDeclareInterface(node, opts) et t.assertDeclareInterface(node, opts).

Forme du nœud AST DeclareInterface :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • extends: InterfaceExtends[] (par défaut : null)

  • body: ObjectTypeAnnotation (requis)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareModule​

JavaScript
t.declareModule(id, body, kind);

Voir aussi t.isDeclareModule(node, opts) et t.assertDeclareModule(node, opts).

Forme du nœud AST DeclareModule :

  • id: Identifier | StringLiteral (requis)

  • body : BlockStatement (requis)

  • kind: "CommonJS" | "ES" (par défaut : null)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareModuleExports​

JavaScript
t.declareModuleExports(typeAnnotation);

Voir aussi t.isDeclareModuleExports(node, opts) et t.assertDeclareModuleExports(node, opts).

Forme du nœud AST DeclareModuleExports :

  • typeAnnotation: TypeAnnotation (obligatoire)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareOpaqueType​

JavaScript
t.declareOpaqueType(id, typeParameters, supertype);

Voir aussi t.isDeclareOpaqueType(node, opts) et t.assertDeclareOpaqueType(node, opts).

Forme du nœud AST DeclareOpaqueType :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • supertype : FlowType (par défaut : null)

  • impltype: FlowType (par défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareTypeAlias​

JavaScript
t.declareTypeAlias(id, typeParameters, right);

Voir aussi t.isDeclareTypeAlias(node, opts) et t.assertDeclareTypeAlias(node, opts).

Forme du nœud AST DeclareTypeAlias :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • right: FlowType (obligatoire)

Alias : Flow, FlowDeclaration, Statement, Declaration

declareVariable​

JavaScript
t.declareVariable(id);

Voir aussi t.isDeclareVariable(node, opts) et t.assertDeclareVariable(node, opts).

Forme du nœud AST DeclareVariable :

  • id: Identifier (obligatoire)

Alias : Flow, FlowDeclaration, Statement, Declaration

declaredPredicate​

JavaScript
t.declaredPredicate(value);

Voir aussi t.isDeclaredPredicate(node, opts) et t.assertDeclaredPredicate(node, opts).

Structure du nœud AST DeclaredPredicate :

  • value: Flow (requis)

Alias : Flow, FlowPredicate

decorator​

JavaScript
t.decorator(expression);

Voir aussi t.isDecorator(node, opts) et t.assertDecorator(node, opts).

Structure du nœud AST Decorator :

  • expression: Expression (obligatoire)

directive​

JavaScript
t.directive(value);

Voir aussi t.isDirective(node, opts) et t.assertDirective(node, opts).

Structure du nœud AST Directive :

  • value: DirectiveLiteral (requis)

Alias : Standardized

directiveLiteral​

JavaScript
t.directiveLiteral(value);

Voir aussi t.isDirectiveLiteral(node, opts) et t.assertDirectiveLiteral(node, opts).

Structure du nœud AST DirectiveLiteral :

  • value : string (requis)

Alias : Standardized

doExpression​

JavaScript
t.doExpression(body, async);

Voir aussi t.isDoExpression(node, opts) et t.assertDoExpression(node, opts).

Structure du nœud AST DoExpression :

  • body : BlockStatement (requis)

  • async : boolean (par défaut : false)

Alias : Expression

doWhileStatement​

JavaScript
t.doWhileStatement(test, body);

Voir aussi t.isDoWhileStatement(node, opts) et t.assertDoWhileStatement(node, opts).

Structure du nœud AST DoWhileStatement :

  • test: Expression (requis)

  • body: Statement (requis)

Alias : Standardized, Statement, BlockParent, Loop, While, Scopable

emptyStatement​

JavaScript
t.emptyStatement();

Voir aussi t.isEmptyStatement(node, opts) et t.assertEmptyStatement(node, opts).

Alias : Standardized, Statement

emptyTypeAnnotation​

JavaScript
t.emptyTypeAnnotation();

Voir aussi t.isEmptyTypeAnnotation(node, opts) et t.assertEmptyTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

enumBooleanBody​

JavaScript
t.enumBooleanBody(members);

Voir aussi t.isEnumBooleanBody(node, opts) et t.assertEnumBooleanBody(node, opts).

Structure du nœud AST EnumBooleanBody :

  • members: EnumBooleanMember[] (requis)

  • explicitType: boolean (obligatoire)

  • hasUnknownMembers: boolean (requis)

Alias: Flow, EnumBody

enumBooleanMember​

JavaScript
t.enumBooleanMember(id);

Voir aussi t.isEnumBooleanMember(node, opts) et t.assertEnumBooleanMember(node, opts).

Structure du nœud AST EnumBooleanMember :

  • id: Identifier (obligatoire)

  • init: BooleanLiteral (obligatoire)

Alias : Flow, EnumMember

enumDeclaration​

JavaScript
t.enumDeclaration(id, body);

Voir aussi t.isEnumDeclaration(node, opts) et t.assertEnumDeclaration(node, opts).

Structure du nœud AST EnumDeclaration :

  • id: Identifier (obligatoire)

  • body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody (obligatoire)

Alias : Flow, Statement, Declaration

enumDefaultedMember​

JavaScript
t.enumDefaultedMember(id);

Voir aussi t.isEnumDefaultedMember(node, opts) et t.assertEnumDefaultedMember(node, opts).

Structure du nœud AST EnumDefaultedMember :

  • id: Identifier (obligatoire)

Alias : Flow, EnumMember

enumNumberBody​

JavaScript
t.enumNumberBody(members);

Voir aussi t.isEnumNumberBody(node, opts) et t.assertEnumNumberBody(node, opts).

Structure du nœud AST EnumNumberBody :

  • members: EnumNumberMember[] (requis)

  • explicitType: boolean (obligatoire)

  • hasUnknownMembers: boolean (requis)

Alias: Flow, EnumBody

enumNumberMember​

JavaScript
t.enumNumberMember(id, init);

Voir aussi t.isEnumNumberMember(node, opts) et t.assertEnumNumberMember(node, opts).

Structure du nœud AST EnumNumberMember :

  • id: Identifier (obligatoire)

  • init: NumericLiteral (obligatoire)

Alias : Flow, EnumMember

enumStringBody​

JavaScript
t.enumStringBody(members);

Voir aussi t.isEnumStringBody(node, opts) et t.assertEnumStringBody(node, opts).

Structure du nœud AST EnumStringBody :

  • members: (EnumStringMember | EnumDefaultedMember)[] (requis)

  • explicitType: boolean (obligatoire)

  • hasUnknownMembers: boolean (requis)

Alias: Flow, EnumBody

enumStringMember​

JavaScript
t.enumStringMember(id, init);

Voir aussi t.isEnumStringMember(node, opts) et t.assertEnumStringMember(node, opts).

Structure du nœud AST EnumStringMember :

  • id: Identifier (obligatoire)

  • init: StringLiteral (obligatoire)

Alias : Flow, EnumMember

enumSymbolBody​

JavaScript
t.enumSymbolBody(members);

Voir aussi t.isEnumSymbolBody(node, opts) et t.assertEnumSymbolBody(node, opts).

Forme du nœud AST EnumSymbolBody :

  • members: EnumDefaultedMember[] (requis)

  • hasUnknownMembers: boolean (requis)

Alias: Flow, EnumBody

existsTypeAnnotation​

JavaScript
t.existsTypeAnnotation();

Voir aussi t.isExistsTypeAnnotation(node, opts) et t.assertExistsTypeAnnotation(node, opts).

Alias : Flow, FlowType

exportAllDeclaration​

JavaScript
t.exportAllDeclaration(source, attributes);
History
VersionChanges
v7.29.0Supports attributes

Voir aussi t.isExportAllDeclaration(node, opts) et t.assertExportAllDeclaration(node, opts).

Forme du nœud AST ExportAllDeclaration :

  • source: StringLiteral (required)

  • attributes: ImportAttribute[] (par défaut : null)

  • assertions: ImportAttribute[] (par défaut : null, exclu de la fonction de construction)

  • exportKind : "type" | "value" (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration

exportDefaultDeclaration​

JavaScript
t.exportDefaultDeclaration(declaration);

Voir aussi t.isExportDefaultDeclaration(node, opts) et t.assertExportDefaultDeclaration(node, opts).

Forme du nœud AST ExportDefaultDeclaration :

  • declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression (requis)

  • exportKind: "value" (défaut: null, exclu de la fonction de construction)

Alias : Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration

exportDefaultSpecifier​

JavaScript
t.exportDefaultSpecifier(exported);

Voir aussi t.isExportDefaultSpecifier(node, opts) et t.assertExportDefaultSpecifier(node, opts).

Forme du nœud AST ExportDefaultSpecifier :

  • exported : Identifier (requis)

Alias: ModuleSpecifier

exportNamedDeclaration​

JavaScript
t.exportNamedDeclaration(declaration, specifiers, source, attributes);
History
VersionChanges
v7.29.0Supports attributes

Voir aussi t.isExportNamedDeclaration(node, opts) et t.assertExportNamedDeclaration(node, opts).

Forme du nœud AST ExportNamedDeclaration :

  • declaration: Declaration (défaut: null)

  • specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[] (par défaut : [])

  • source: StringLiteral (défaut: null)

  • attributes: ImportAttribute[] (par défaut : null)

  • assertions: ImportAttribute[] (par défaut : null, exclu de la fonction de construction)

  • exportKind : "type" | "value" (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration

exportNamespaceSpecifier​

JavaScript
t.exportNamespaceSpecifier(exported);

Voir aussi t.isExportNamespaceSpecifier(node, opts) et t.assertExportNamespaceSpecifier(node, opts).

Structure du nœud AST ExportNamespaceSpecifier :

  • exported : Identifier (requis)

Alias : Standardized, ModuleSpecifier

exportSpecifier​

JavaScript
t.exportSpecifier(local, exported);

Voir aussi t.isExportSpecifier(node, opts) et t.assertExportSpecifier(node, opts).

Structure du nœud AST ExportSpecifier :

  • local: Identifier (required)

  • exported : Identifier | StringLiteral (requis)

  • exportKind : "type" | "value" (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, ModuleSpecifier

expressionStatement​

JavaScript
t.expressionStatement(expression);

Voir aussi t.isExpressionStatement(node, opts) et t.assertExpressionStatement(node, opts).

Structure du nœud AST ExpressionStatement :

  • expression: Expression (obligatoire)

Alias : Standardized, Statement, ExpressionWrapper

file​

JavaScript
t.file(program, comments, tokens);

Voir aussi t.isFile(node, opts) et t.assertFile(node, opts).

Structure du nœud AST File :

  • program : Program (requis)

  • comments: (CommentBlock | CommentLine)[] (par défaut : null)

  • tokens: any[] (par défaut : null)

Alias : Standardized

forInStatement​

JavaScript
t.forInStatement(left, right, body);

Voir aussi t.isForInStatement(node, opts) et t.assertForInStatement(node, opts).

Structure du nœud AST ForInStatement :

  • left : VariableDeclaration | LVal (requis)

  • right : Expression (requis)

  • body: Statement (requis)

Aliases: Standardized, Scopable, Statement, For, BlockParent, Loop, ForXStatement

forOfStatement​

JavaScript
t.forOfStatement(left, right, body, await);

Voir aussi t.isForOfStatement(node, opts) et t.assertForOfStatement(node, opts).

Structure du nœud AST ForOfStatement :

  • left : VariableDeclaration | LVal (requis)

  • right : Expression (requis)

  • body: Statement (requis)

  • await : boolean (par défaut : false)

Aliases: Standardized, Scopable, Statement, For, BlockParent, Loop, ForXStatement

forStatement​

JavaScript
t.forStatement(init, test, update, body);

Voir aussi t.isForStatement(node, opts) et t.assertForStatement(node, opts).

Structure du nœud AST ForStatement :

  • init: VariableDeclaration | Expression (par défaut : null)

  • test : Expression (défaut : null)

  • update: Expression (par défaut : null)

  • body: Statement (requis)

Aliases: Standardized, Scopable, Statement, For, BlockParent, Loop

functionDeclaration​

JavaScript
t.functionDeclaration(id, params, body, generator, async);

Voir aussi t.isFunctionDeclaration(node, opts) et t.assertFunctionDeclaration(node, opts).

Structure du nœud AST FunctionDeclaration :

  • id: Identifier (par défaut : null)

  • params: FunctionParameter[] (requis)

  • body : BlockStatement (requis)

  • generator : boolean (par défaut : false)

  • async : boolean (par défaut : false)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • predicate: DeclaredPredicate | InferredPredicate (par défaut : null, exclu de la fonction de construction)

  • returnType : TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Aliases: Standardized, Scopable, Function, BlockParent, FunctionParent, Statement, Pureish, Declaration

functionExpression​

JavaScript
t.functionExpression(id, params, body, generator, async);

Voir aussi t.isFunctionExpression(node, opts) et t.assertFunctionExpression(node, opts).

Structure du nœud AST FunctionExpression :

  • id: Identifier (par défaut : null)

  • params: FunctionParameter[] (requis)

  • body : BlockStatement (requis)

  • generator : boolean (par défaut : false)

  • async : boolean (par défaut : false)

  • predicate: DeclaredPredicate | InferredPredicate (par défaut : null, exclu de la fonction de construction)

  • returnType : TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Aliases: Standardized, Scopable, Function, BlockParent, FunctionParent, Expression, Pureish

functionTypeAnnotation​

JavaScript
t.functionTypeAnnotation(typeParameters, params, rest, returnType);

Voir aussi t.isFunctionTypeAnnotation(node, opts) et t.assertFunctionTypeAnnotation(node, opts).

Forme du nœud AST FunctionTypeAnnotation :

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • params: FunctionTypeParam[] (requis)

  • rest : FunctionTypeParam (par défaut : null)

  • returnType : FlowType (obligatoire)

  • this : FunctionTypeParam (par défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowType

functionTypeParam​

JavaScript
t.functionTypeParam(name, typeAnnotation);

Voir aussi t.isFunctionTypeParam(node, opts) et t.assertFunctionTypeParam(node, opts).

Forme du nœud AST FunctionTypeParam :

  • name : Identifier (par défaut : null)

  • typeAnnotation: FlowType (obligatoire)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

Alias : Flow

genericTypeAnnotation​

JavaScript
t.genericTypeAnnotation(id, typeParameters);

Voir aussi t.isGenericTypeAnnotation(node, opts) et t.assertGenericTypeAnnotation(node, opts).

Forme du nœud AST GenericTypeAnnotation :

  • id: Identifier | QualifiedTypeIdentifier (requis)

  • typeParameters: TypeParameterInstantiation (par défaut : null)

Alias : Flow, FlowType

identifier​

JavaScript
t.identifier(name);

Voir aussi t.isIdentifier(node, opts) et t.assertIdentifier(node, opts).

Forme du nœud AST Identifier :

  • name : string (obligatoire)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

Alias : Standardized, Expression, FunctionParameter, PatternLike, LVal, TSEntityName

ifStatement​

JavaScript
t.ifStatement(test, consequent, alternate);

Voir aussi t.isIfStatement(node, opts) et t.assertIfStatement(node, opts).

Forme du nœud AST IfStatement :

  • test: Expression (requis)

  • consequent : Statement (obligatoire)

  • alternate : Statement (par défaut : null)

Alias : Standardized, Statement, Conditional

import​

JavaScript
t.import();

Voir aussi t.isImport(node, opts) et t.assertImport(node, opts).

Alias : Standardized, Expression

importAttribute​

JavaScript
t.importAttribute(key, value);

Voir aussi t.isImportAttribute(node, opts) et t.assertImportAttribute(node, opts).

Structure du nœud AST ImportAttribute :

  • key : Identifier | StringLiteral (requis)

  • value: StringLiteral (required)

Alias : Standardized

importDeclaration​

JavaScript
t.importDeclaration(specifiers, source, attributes);
History
VersionChanges
v7.20.0Supports module
v7.29.0Supports attributes

Voir aussi t.isImportDeclaration(node, opts) et t.assertImportDeclaration(node, opts).

Structure du nœud AST ImportDeclaration :

  • specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[] (requis)

  • source: StringLiteral (required)

  • attributes: ImportAttribute[] (par défaut : null)

  • assertions: ImportAttribute[] (par défaut : null, exclu de la fonction de construction)

  • importKind: "type" | "typeof" | "value" (default: null, excluded from builder function)

  • module: boolean (default: null, excluded from builder function)

  • phase: "source" | "defer" (default: null, excluded from builder function)

Alias : Standardized, Statement, Declaration, ImportOrExportDeclaration

importDefaultSpecifier​

JavaScript
t.importDefaultSpecifier(local);

Voir aussi t.isImportDefaultSpecifier(node, opts) et t.assertImportDefaultSpecifier(node, opts).

Structure du nœud AST ImportDefaultSpecifier :

  • local: Identifier (required)

Alias : Standardized, ModuleSpecifier

importExpression​

JavaScript
t.importExpression(source, options);

Voir aussi t.isImportExpression(node, opts) et t.assertImportExpression(node, opts).

Structure du nœud AST ImportExpression :

  • source: Expression (required)

  • options: Expression (default: null)

  • phase: "source" | "defer" (default: null, excluded from builder function)

Alias : Standardized, Expression

importNamespaceSpecifier​

JavaScript
t.importNamespaceSpecifier(local);

Voir aussi t.isImportNamespaceSpecifier(node, opts) et t.assertImportNamespaceSpecifier(node, opts).

Structure du nœud AST ImportNamespaceSpecifier :

  • local: Identifier (required)

Alias : Standardized, ModuleSpecifier

importSpecifier​

JavaScript
t.importSpecifier(local, imported);

Voir aussi t.isImportSpecifier(node, opts) et t.assertImportSpecifier(node, opts).

Structure du nœud AST ImportSpecifier :

  • local: Identifier (required)

  • imported: Identifier | StringLiteral (required)

  • importKind: "type" | "typeof" | "value" (default: null, excluded from builder function)

Alias : Standardized, ModuleSpecifier

indexedAccessType​

JavaScript
t.indexedAccessType(objectType, indexType);

Voir aussi t.isIndexedAccessType(node, opts) et t.assertIndexedAccessType(node, opts).

Forme du nœud AST IndexedAccessType :

  • objectType: FlowType (requis)

  • indexType: FlowType (requis)

Alias : Flow, FlowType

inferredPredicate​

JavaScript
t.inferredPredicate();

Voir aussi t.isInferredPredicate(node, opts) et t.assertInferredPredicate(node, opts).

Alias : Flow, FlowPredicate

interfaceDeclaration​

JavaScript
t.interfaceDeclaration(id, typeParameters, extends, body);

Voir aussi t.isInterfaceDeclaration(node, opts) et t.assertInterfaceDeclaration(node, opts).

Forme du nœud AST InterfaceDeclaration :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • extends: InterfaceExtends[] (par défaut : null)

  • body: ObjectTypeAnnotation (requis)

Alias : Flow, FlowDeclaration, Statement, Declaration

interfaceExtends​

JavaScript
t.interfaceExtends(id, typeParameters);

Voir aussi t.isInterfaceExtends(node, opts) et t.assertInterfaceExtends(node, opts).

Forme du nœud AST InterfaceExtends :

  • id: Identifier | QualifiedTypeIdentifier (requis)

  • typeParameters: TypeParameterInstantiation (par défaut : null)

Alias : Flow

interfaceTypeAnnotation​

JavaScript
t.interfaceTypeAnnotation(extends, body);

Voir aussi t.isInterfaceTypeAnnotation(node, opts) et t.assertInterfaceTypeAnnotation(node, opts).

Forme du nœud AST InterfaceTypeAnnotation :

  • extends: InterfaceExtends[] (par défaut : null)

  • body: ObjectTypeAnnotation (requis)

Alias : Flow, FlowType

interpreterDirective​

JavaScript
t.interpreterDirective(value);

Voir aussi t.isInterpreterDirective(node, opts) et t.assertInterpreterDirective(node, opts).

Forme du nœud AST InterpreterDirective :

  • value : string (requis)

Alias : Standardized

intersectionTypeAnnotation​

JavaScript
t.intersectionTypeAnnotation(types);

Voir aussi t.isIntersectionTypeAnnotation(node, opts) et t.assertIntersectionTypeAnnotation(node, opts).

Forme du nœud AST IntersectionTypeAnnotation :

  • types: FlowType[] (requis)

Alias : Flow, FlowType

jsxAttribute​

JavaScript
t.jsxAttribute(name, value);

Voir aussi t.isJSXAttribute(node, opts) et t.assertJSXAttribute(node, opts).

Forme du nœud AST JSXAttribute :

  • name: JSXIdentifier | JSXNamespacedName (requis)

  • value : JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer (par défaut : null)

Alias : JSX, Immutable

jsxClosingElement​

JavaScript
t.jsxClosingElement(name);

Voir aussi t.isJSXClosingElement(node, opts) et t.assertJSXClosingElement(node, opts).

Forme du nœud AST JSXClosingElement :

  • name : JSXIdentifier | JSXMemberExpression | JSXNamespacedName (requis)

Alias : JSX, Immutable

jsxClosingFragment​

JavaScript
t.jsxClosingFragment();

Voir aussi t.isJSXClosingFragment(node, opts) et t.assertJSXClosingFragment(node, opts).

Alias : JSX, Immutable

jsxElement​

JavaScript
t.jsxElement(openingElement, closingElement, children, selfClosing);

Voir aussi t.isJSXElement(node, opts) et t.assertJSXElement(node, opts).

Forme du nœud AST JSXElement :

  • openingElement : JSXOpeningElement (requis)

  • closingElement : JSXClosingElement (par défaut : null)

  • children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[] (requis)

  • selfClosing : boolean (par défaut : null)

Alias : JSX, Immutable, Expression

jsxEmptyExpression​

JavaScript
t.jsxEmptyExpression();

Voir aussi t.isJSXEmptyExpression(node, opts) et t.assertJSXEmptyExpression(node, opts).

Alias : JSX

jsxExpressionContainer​

JavaScript
t.jsxExpressionContainer(expression);

Voir aussi t.isJSXExpressionContainer(node, opts) et t.assertJSXExpressionContainer(node, opts).

Forme du nœud AST JSXExpressionContainer :

  • expression : Expression | JSXEmptyExpression (requis)

Alias : JSX, Immutable

jsxFragment​

JavaScript
t.jsxFragment(openingFragment, closingFragment, children);

Voir aussi t.isJSXFragment(node, opts) et t.assertJSXFragment(node, opts).

Forme du nœud AST JSXFragment :

  • openingFragment : JSXOpeningFragment (requis)

  • closingFragment : JSXClosingFragment (requis)

  • children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[] (requis)

Alias : JSX, Immutable, Expression

jsxIdentifier​

JavaScript
t.jsxIdentifier(name);

Voir aussi t.isJSXIdentifier(node, opts) et t.assertJSXIdentifier(node, opts).

Forme du nœud AST JSXIdentifier :

  • name : string (obligatoire)

Alias : JSX

jsxMemberExpression​

JavaScript
t.jsxMemberExpression(object, property);

Voir aussi t.isJSXMemberExpression(node, opts) et t.assertJSXMemberExpression(node, opts).

Structure du nœud AST JSXMemberExpression :

  • object : JSXMemberExpression | JSXIdentifier (requis)

  • property : JSXIdentifier (requis)

Alias : JSX

jsxNamespacedName​

JavaScript
t.jsxNamespacedName(namespace, name);

Voir aussi t.isJSXNamespacedName(node, opts) et t.assertJSXNamespacedName(node, opts).

Structure du nœud AST JSXNamespacedName :

  • namespace : JSXIdentifier (requis)

  • name : JSXIdentifier (requis)

Alias : JSX

jsxOpeningElement​

JavaScript
t.jsxOpeningElement(name, attributes, selfClosing);

Voir aussi t.isJSXOpeningElement(node, opts) et t.assertJSXOpeningElement(node, opts).

Structure du nœud AST JSXOpeningElement :

  • name : JSXIdentifier | JSXMemberExpression | JSXNamespacedName (requis)

  • attributes: (JSXAttribute | JSXSpreadAttribute)[] (requis)

  • selfClosing : boolean (défaut : false)

  • typeArguments: TypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

  • typeParameters: TSTypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

Alias : JSX, Immutable

jsxOpeningFragment​

JavaScript
t.jsxOpeningFragment();

Voir aussi t.isJSXOpeningFragment(node, opts) et t.assertJSXOpeningFragment(node, opts).

Alias : JSX, Immutable

jsxSpreadAttribute​

JavaScript
t.jsxSpreadAttribute(argument);

Voir aussi t.isJSXSpreadAttribute(node, opts) et t.assertJSXSpreadAttribute(node, opts).

Structure du nœud AST JSXSpreadAttribute :

  • argument : Expression (obligatoire)

Alias : JSX

jsxSpreadChild​

JavaScript
t.jsxSpreadChild(expression);

Voir aussi t.isJSXSpreadChild(node, opts) et t.assertJSXSpreadChild(node, opts).

Structure du nœud AST JSXSpreadChild :

  • expression: Expression (obligatoire)

Alias : JSX, Immutable

jsxText​

JavaScript
t.jsxText(value);

Voir aussi t.isJSXText(node, opts) et t.assertJSXText(node, opts).

Structure du nœud AST JSXText :

  • value : string (requis)

Alias : JSX, Immutable

labeledStatement​

JavaScript
t.labeledStatement(label, body);

Voir aussi t.isLabeledStatement(node, opts) et t.assertLabeledStatement(node, opts).

Structure du nœud AST LabeledStatement :

  • label: Identifier (requis)

  • body: Statement (requis)

Alias : Standardized, Statement

logicalExpression​

JavaScript
t.logicalExpression(operator, left, right);

Voir aussi t.isLogicalExpression(node, opts) et t.assertLogicalExpression(node, opts).

Forme du nœud AST LogicalExpression :

  • operator : "||" | "&&" | "??" (requis)

  • left : Expression (requis)

  • right : Expression (requis)

Alias : Standardized, Binary, Expression

memberExpression​

JavaScript
t.memberExpression(object, property, computed, optional);

Voir aussi t.isMemberExpression(node, opts) et t.assertMemberExpression(node, opts).

Forme du nœud AST MemberExpression :

  • object : Expression | Super (requis)

  • property : si calculé alors Expression sinon Identifier (requis)

  • computed: boolean (défaut : false)

  • optional : boolean (par défaut : null)

Alias : Standardized, Expression, LVal, PatternLike

metaProperty​

JavaScript
t.metaProperty(meta, property);

Voir aussi t.isMetaProperty(node, opts) et t.assertMetaProperty(node, opts).

Forme du nœud AST MetaProperty :

  • meta : Identifier (requis)

  • property : Identifier (requis)

Alias : Standardized, Expression

mixedTypeAnnotation​

JavaScript
t.mixedTypeAnnotation();

Voir aussi t.isMixedTypeAnnotation(node, opts) et t.assertMixedTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

moduleExpression​

JavaScript
t.moduleExpression(body);

Voir aussi t.isModuleExpression(node, opts) et t.assertModuleExpression(node, opts).

Forme du nœud AST ModuleExpression :

  • body : Program (requis)

Alias : Expression

newExpression​

JavaScript
t.newExpression(callee, arguments);

Voir aussi t.isNewExpression(node, opts) et t.assertNewExpression(node, opts).

Forme du nœud AST NewExpression :

  • callee : Expression | Super | V8IntrinsicIdentifier (requis)

  • arguments: (Expression | SpreadElement | ArgumentPlaceholder)[] (requis)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeArguments: TypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

  • typeParameters: TSTypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

Alias : Standardized, Expression

noop​

JavaScript
t.noop();

Voir aussi t.isNoop(node, opts) et t.assertNoop(node, opts).

Alias : Miscellaneous

nullLiteral​

JavaScript
t.nullLiteral();

Voir aussi t.isNullLiteral(node, opts) et t.assertNullLiteral(node, opts).

Alias : Standardized, Expression, Pureish, Literal, Immutable

nullLiteralTypeAnnotation​

JavaScript
t.nullLiteralTypeAnnotation();

Voir aussi t.isNullLiteralTypeAnnotation(node, opts) et t.assertNullLiteralTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

nullableTypeAnnotation​

JavaScript
t.nullableTypeAnnotation(typeAnnotation);

Voir aussi t.isNullableTypeAnnotation(node, opts) et t.assertNullableTypeAnnotation(node, opts).

Structure du nœud AST NullableTypeAnnotation :

  • typeAnnotation: FlowType (obligatoire)

Alias : Flow, FlowType

numberLiteralTypeAnnotation​

JavaScript
t.numberLiteralTypeAnnotation(value);

Voir aussi t.isNumberLiteralTypeAnnotation(node, opts) et t.assertNumberLiteralTypeAnnotation(node, opts).

Structure du nœud AST NumberLiteralTypeAnnotation :

  • value : number (requis)

Alias : Flow, FlowType

numberTypeAnnotation​

JavaScript
t.numberTypeAnnotation();

Voir aussi t.isNumberTypeAnnotation(node, opts) et t.assertNumberTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

numericLiteral​

JavaScript
t.numericLiteral(value);

Voir aussi t.isNumericLiteral(node, opts) et t.assertNumericLiteral(node, opts).

Structure du nœud AST NumericLiteral :

  • value : un number fini non-négatif (requis)

Alias : Standardized, Expression, Pureish, Literal, Immutable

objectExpression​

JavaScript
t.objectExpression(properties);

Voir aussi t.isObjectExpression(node, opts) et t.assertObjectExpression(node, opts).

Structure du nœud AST ObjectExpression :

  • properties: (ObjectMethod | ObjectProperty | SpreadElement)[] (requis)

Alias : Standardized, Expression

objectMethod​

JavaScript
t.objectMethod(kind, key, params, body, computed, generator, async);

Voir aussi t.isObjectMethod(node, opts) et t.assertObjectMethod(node, opts).

Structure du nœud AST ObjectMethod :

  • kind : "method" | "get" | "set" (par défaut : 'method')

  • key : si calculé alors Expression sinon Identifier | Literal (requis)

  • params: FunctionParameter[] (requis)

  • body : BlockStatement (requis)

  • computed: boolean (défaut : false)

  • generator : boolean (par défaut : false)

  • async : boolean (par défaut : false)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • returnType : TypeAnnotation | TSTypeAnnotation | Noop (par défaut : null, exclu de la fonction de construction)

  • typeParameters : TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, UserWhitespacable, Function, Scopable, BlockParent, FunctionParent, Method, ObjectMember

objectPattern​

JavaScript
t.objectPattern(properties);

Voir aussi t.isObjectPattern(node, opts) et t.assertObjectPattern(node, opts).

Structure du nœud AST ObjectPattern :

  • properties: (RestElement | ObjectProperty)[] (requis)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

Alias : Standardized, FunctionParameter, Pattern, PatternLike, LVal

objectProperty​

JavaScript
t.objectProperty(key, value, computed, shorthand, decorators);

Voir aussi t.isObjectProperty(node, opts) et t.assertObjectProperty(node, opts).

Structure du nœud AST ObjectProperty :

  • key : si calculé alors Expression sinon Identifier | Literal (requis)

  • value : Expression | PatternLike (requis)

  • computed: boolean (défaut : false)

  • shorthand : boolean (par défaut : false)

  • decorators: Decorator[] (vaut null par défaut)

Alias : Standardized, UserWhitespacable, Property, ObjectMember

objectTypeAnnotation​

JavaScript
t.objectTypeAnnotation(properties, indexers, callProperties, internalSlots, exact);

Voir aussi t.isObjectTypeAnnotation(node, opts) et t.assertObjectTypeAnnotation(node, opts).

Structure du nœud AST ObjectTypeAnnotation :

  • properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[] (requis)

  • indexers: ObjectTypeIndexer[] (par défaut : [])

  • callProperties: ObjectTypeCallProperty[] (par défaut : [])

  • internalSlots: ObjectTypeInternalSlot[] (par défaut : [])

  • exact : boolean (par défaut : false)

  • inexact : boolean (par défaut : null, exclu de la fonction de construction)

Alias : Flow, FlowType

objectTypeCallProperty​

JavaScript
t.objectTypeCallProperty(value);

Voir aussi t.isObjectTypeCallProperty(node, opts) et t.assertObjectTypeCallProperty(node, opts).

Structure du nœud AST ObjectTypeCallProperty :

  • value : FlowType (requis)

  • static : boolean (requis)

Alias : Flow, UserWhitespacable

objectTypeIndexer​

JavaScript
t.objectTypeIndexer(id, key, value, variance);

Voir aussi t.isObjectTypeIndexer(node, opts) et t.assertObjectTypeIndexer(node, opts).

Structure du nœud AST ObjectTypeIndexer :

  • id: Identifier (par défaut : null)

  • key : FlowType (requis)

  • value : FlowType (requis)

  • variance: Variance (par défaut : null)

  • static : boolean (requis)

Alias : Flow, UserWhitespacable

objectTypeInternalSlot​

JavaScript
t.objectTypeInternalSlot(id, value, optional, static, method);

Voir aussi t.isObjectTypeInternalSlot(node, opts) et t.assertObjectTypeInternalSlot(node, opts).

Structure du nœud AST ObjectTypeInternalSlot :

  • id: Identifier (obligatoire)

  • value : FlowType (requis)

  • optional: boolean (requis)

  • static : boolean (requis)

  • method : boolean (requis)

Alias : Flow, UserWhitespacable

objectTypeProperty​

JavaScript
t.objectTypeProperty(key, value, variance);

Voir aussi t.isObjectTypeProperty(node, opts) et t.assertObjectTypeProperty(node, opts).

Structure du nœud AST ObjectTypeProperty :

  • key : Identifier | StringLiteral (requis)

  • value : FlowType (requis)

  • variance: Variance (par défaut : null)

  • kind : "init" | "get" | "set" (requis)

  • method : boolean (requis)

  • optional: boolean (requis)

  • proto : boolean (requis)

  • static : boolean (requis)

Alias : Flow, UserWhitespacable

objectTypeSpreadProperty​

JavaScript
t.objectTypeSpreadProperty(argument);

Voir aussi t.isObjectTypeSpreadProperty(node, opts) et t.assertObjectTypeSpreadProperty(node, opts).

Structure du nœud AST ObjectTypeSpreadProperty :

  • argument : FlowType (obligatoire)

Alias : Flow, UserWhitespacable

opaqueType​

JavaScript
t.opaqueType(id, typeParameters, supertype, impltype);

Voir aussi t.isOpaqueType(node, opts) et t.assertOpaqueType(node, opts).

Structure du nœud AST OpaqueType :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • supertype : FlowType (par défaut : null)

  • impltype: FlowType (requis)

Alias : Flow, FlowDeclaration, Statement, Declaration

optionalCallExpression​

JavaScript
t.optionalCallExpression(callee, arguments, optional);

Voir aussi t.isOptionalCallExpression(node, opts) et t.assertOptionalCallExpression(node, opts).

Structure du nœud AST OptionalCallExpression :

  • callee: Expression (requis)

  • arguments: (Expression | SpreadElement | ArgumentPlaceholder)[] (requis)

  • optional: boolean (requis)

  • typeArguments: TypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

  • typeParameters: TSTypeParameterInstantiation (défaut : null, exclu de la fonction de construction)

Alias : Standardized, Expression

optionalIndexedAccessType​

JavaScript
t.optionalIndexedAccessType(objectType, indexType);

Voir aussi t.isOptionalIndexedAccessType(node, opts) et t.assertOptionalIndexedAccessType(node, opts).

Structure du nœud AST OptionalIndexedAccessType :

  • objectType: FlowType (requis)

  • indexType: FlowType (requis)

  • optional: boolean (requis)

Alias : Flow, FlowType

optionalMemberExpression​

JavaScript
t.optionalMemberExpression(object, property, computed, optional);

Voir aussi t.isOptionalMemberExpression(node, opts) et t.assertOptionalMemberExpression(node, opts).

Structure du nœud AST OptionalMemberExpression :

  • object: Expression (requis)

  • property: Expression | Identifier (requis)

  • computed: boolean (défaut : false)

  • optional: boolean (requis)

Alias : Standardized, Expression

parenthesizedExpression​

JavaScript
t.parenthesizedExpression(expression);

Voir aussi t.isParenthesizedExpression(node, opts) et t.assertParenthesizedExpression(node, opts).

Structure du nœud AST ParenthesizedExpression :

  • expression: Expression (obligatoire)

Alias : Standardized, Expression, ExpressionWrapper

pipelineBareFunction​

JavaScript
t.pipelineBareFunction(callee);

Voir aussi t.isPipelineBareFunction(node, opts) et t.assertPipelineBareFunction(node, opts).

Structure du nœud AST PipelineBareFunction :

  • callee: Expression (requis)

Alias : Expression

pipelinePrimaryTopicReference​

JavaScript
t.pipelinePrimaryTopicReference();

Voir aussi t.isPipelinePrimaryTopicReference(node, opts) et t.assertPipelinePrimaryTopicReference(node, opts).

Alias : Expression

pipelineTopicExpression​

JavaScript
t.pipelineTopicExpression(expression);

Voir aussi t.isPipelineTopicExpression(node, opts) et t.assertPipelineTopicExpression(node, opts).

Structure du nœud AST PipelineTopicExpression :

  • expression: Expression (obligatoire)

Alias : Expression

placeholder​

JavaScript
t.placeholder(expectedNode, name);

Voir aussi t.isPlaceholder(node, opts) et t.assertPlaceholder(node, opts).

Structure du nœud AST Placeholder :

  • expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern" (requis)

  • name: Identifier (requis)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

Alias : Miscellaneous

privateName​

JavaScript
t.privateName(id);

Voir aussi t.isPrivateName(node, opts) et t.assertPrivateName(node, opts).

Structure du nœud AST PrivateName :

  • id: Identifier (obligatoire)

Alias : Standardized, Private

program​

JavaScript
t.program(body, directives, sourceType, interpreter);

Voir aussi t.isProgram(node, opts) et t.assertProgram(node, opts).

Structure du nœud AST Program :

  • body: Statement[] (requis)

  • directives: Directive[] (par défaut : [])

  • sourceType: "script" | "module" (par défaut : 'script')

  • interpreter: InterpreterDirective (par défaut : null)

Alias : Standardized, Scopable, BlockParent, Block

qualifiedTypeIdentifier​

JavaScript
t.qualifiedTypeIdentifier(id, qualification);

Voir aussi t.isQualifiedTypeIdentifier(node, opts) et t.assertQualifiedTypeIdentifier(node, opts).

Structure du nœud AST QualifiedTypeIdentifier :

  • id: Identifier (obligatoire)

  • qualification: Identifier | QualifiedTypeIdentifier (requis)

Alias : Flow

recordExpression​

JavaScript
t.recordExpression(properties);

Voir aussi t.isRecordExpression(node, opts) et t.assertRecordExpression(node, opts).

Structure du nœud AST RecordExpression :

  • properties: (ObjectProperty | SpreadElement)[] (requis)

Alias : Expression

regExpLiteral​

JavaScript
t.regExpLiteral(pattern, flags);

Voir aussi t.isRegExpLiteral(node, opts) et t.assertRegExpLiteral(node, opts).

Structure du nœud AST RegExpLiteral :

  • pattern: string (requis)

  • flags: string (par défaut : '')

Alias : Standardized, Expression, Pureish, Literal

restElement​

JavaScript
t.restElement(argument);

Voir aussi t.isRestElement(node, opts) et t.assertRestElement(node, opts).

Forme du nœud AST RestElement :

  • argument : Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern (requis)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • typeAnnotation : TypeAnnotation | TSTypeAnnotation | Noop (défaut : null, exclu de la fonction builder)

Alias : Standardized, FunctionParameter, PatternLike, LVal

returnStatement​

JavaScript
t.returnStatement(argument);

Voir aussi t.isReturnStatement(node, opts) et t.assertReturnStatement(node, opts).

Forme du nœud AST ReturnStatement :

  • argument: Expression (par défaut : null)

Alias : Standardized, Statement, Terminatorless, CompletionStatement

sequenceExpression​

JavaScript
t.sequenceExpression(expressions);

Voir aussi t.isSequenceExpression(node, opts) et t.assertSequenceExpression(node, opts).

Forme du nœud AST SequenceExpression :

  • expressions: Expression[] (requis)

Alias : Standardized, Expression

spreadElement​

JavaScript
t.spreadElement(argument);

Voir aussi t.isSpreadElement(node, opts) et t.assertSpreadElement(node, opts).

Forme du nœud AST SpreadElement :

  • argument : Expression (obligatoire)

Alias : Standardized, UnaryLike

staticBlock​

JavaScript
t.staticBlock(body);

Voir aussi t.isStaticBlock(node, opts) et t.assertStaticBlock(node, opts).

Forme du nœud AST StaticBlock :

  • body: Statement[] (requis)

Alias : Standardized, Scopable, BlockParent, FunctionParent

stringLiteral​

JavaScript
t.stringLiteral(value);

Voir aussi t.isStringLiteral(node, opts) et t.assertStringLiteral(node, opts).

Forme du nœud AST StringLiteral :

  • value : string (requis)

Alias : Standardized, Expression, Pureish, Literal, Immutable

stringLiteralTypeAnnotation​

JavaScript
t.stringLiteralTypeAnnotation(value);

Voir aussi t.isStringLiteralTypeAnnotation(node, opts) et t.assertStringLiteralTypeAnnotation(node, opts).

Forme du nœud AST StringLiteralTypeAnnotation :

  • value : string (requis)

Alias : Flow, FlowType

stringTypeAnnotation​

JavaScript
t.stringTypeAnnotation();

Voir aussi t.isStringTypeAnnotation(node, opts) et t.assertStringTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

super​

JavaScript
t.super();

Voir aussi t.isSuper(node, opts) et t.assertSuper(node, opts).

Alias : Standardized, Expression

switchCase​

JavaScript
t.switchCase(test, consequent);

Voir aussi t.isSwitchCase(node, opts) et t.assertSwitchCase(node, opts).

Structure du nœud AST SwitchCase :

  • test : Expression (défaut : null)

  • consequent: Statement[] (requis)

Alias : Standardized

switchStatement​

JavaScript
t.switchStatement(discriminant, cases);

Voir aussi t.isSwitchStatement(node, opts) et t.assertSwitchStatement(node, opts).

Structure du nœud AST SwitchStatement :

  • discriminant : Expression (requis)

  • cases: SwitchCase[] (requis)

Alias : Standardized, Statement, BlockParent, Scopable

symbolTypeAnnotation​

JavaScript
t.symbolTypeAnnotation();

Voir aussi t.isSymbolTypeAnnotation(node, opts) et t.assertSymbolTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

tsAnyKeyword​

JavaScript
t.tsAnyKeyword();

Voir aussi t.isTSAnyKeyword(node, opts) et t.assertTSAnyKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsArrayType​

JavaScript
t.tsArrayType(elementType);

Voir aussi t.isTSArrayType(node, opts) et t.assertTSArrayType(node, opts).

Structure du nœud AST TSArrayType :

  • elementType: TSType (requis)

Alias : TypeScript, TSType

tsAsExpression​

JavaScript
t.tsAsExpression(expression, typeAnnotation);

Voir aussi t.isTSAsExpression(node, opts) et t.assertTSAsExpression(node, opts).

Structure du nœud AST TSAsExpression :

  • expression: Expression (obligatoire)

  • typeAnnotation: TSType (requis)

Alias : TypeScript, Expression, LVal, PatternLike

tsBigIntKeyword​

JavaScript
t.tsBigIntKeyword();

Voir aussi t.isTSBigIntKeyword(node, opts) et t.assertTSBigIntKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsBooleanKeyword​

JavaScript
t.tsBooleanKeyword();

Voir aussi t.isTSBooleanKeyword(node, opts) et t.assertTSBooleanKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsCallSignatureDeclaration​

JavaScript
t.tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation);

Voir aussi t.isTSCallSignatureDeclaration(node, opts) et t.assertTSCallSignatureDeclaration(node, opts).

Forme du nœud AST TSCallSignatureDeclaration :

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[] (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

Aliases: TypeScript, TSTypeElement

tsConditionalType​

JavaScript
t.tsConditionalType(checkType, extendsType, trueType, falseType);

Voir aussi t.isTSConditionalType(node, opts) et t.assertTSConditionalType(node, opts).

Forme du nœud AST TSConditionalType :

  • checkType: TSType (requis)

  • extendsType: TSType (requis)

  • trueType: TSType (requis)

  • falseType: TSType (requis)

Alias : TypeScript, TSType

tsConstructSignatureDeclaration​

JavaScript
t.tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation);

Voir aussi t.isTSConstructSignatureDeclaration(node, opts) et t.assertTSConstructSignatureDeclaration(node, opts).

Forme du nœud AST TSConstructSignatureDeclaration :

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[] (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

Aliases: TypeScript, TSTypeElement

tsConstructorType​

JavaScript
t.tsConstructorType(typeParameters, parameters, typeAnnotation);

Voir aussi t.isTSConstructorType(node, opts) et t.assertTSConstructorType(node, opts).

Forme du nœud AST TSConstructorType :

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[] (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

Alias : TypeScript, TSType

tsDeclareFunction​

JavaScript
t.tsDeclareFunction(id, typeParameters, params, returnType);

Voir aussi t.isTSDeclareFunction(node, opts) et t.assertTSDeclareFunction(node, opts).

Forme du nœud AST TSDeclareFunction :

  • id: Identifier (par défaut : null)

  • typeParameters : TSTypeParameterDeclaration | Noop (par défaut : null)

  • params: FunctionParameter[] (requis)

  • returnType : TSTypeAnnotation | Noop (par défaut : null)

  • async : boolean (par défaut : false, exclu de la fonction de construction)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • generator : boolean (par défaut : false, exclu de la fonction de construction)

Alias : TypeScript, Statement, Declaration

tsDeclareMethod​

JavaScript
t.tsDeclareMethod(decorators, key, typeParameters, params, returnType);

Voir aussi t.isTSDeclareMethod(node, opts) et t.assertTSDeclareMethod(node, opts).

Structure du nœud AST TSDeclareMethod :

  • decorators: Decorator[] (vaut null par défaut)

  • key : Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression (requis)

  • typeParameters : TSTypeParameterDeclaration | Noop (par défaut : null)

  • params: (FunctionParameter | TSParameterProperty)[] (requis)

  • returnType : TSTypeAnnotation | Noop (par défaut : null)

  • abstract : boolean (par défaut : null, exclu de la fonction de construction)

  • access : "public" | "private" | "protected" (par défaut : null, exclu de la fonction de construction)

  • accessibility: "public" | "private" | "protected" (par défaut: null, exclu de la fonction builder)

  • async : boolean (par défaut : false, exclu de la fonction de construction)

  • computed: boolean (par défaut: false, exclu de la fonction builder)

  • generator : boolean (par défaut : false, exclu de la fonction de construction)

  • kind : "get" | "set" | "method" | "constructor" (par défaut : 'method', exclu de la fonction de construction)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • override : boolean (par défaut : false, exclu de la fonction de construction)

  • static : boolean (par défaut : false, exclu de la fonction de construction)

Alias : TypeScript

tsEnumBody​

JavaScript
t.tsEnumBody(members);

Voir aussi t.isTSEnumBody(node, opts) et t.assertTSEnumBody(node, opts).

Structure du nœud AST TSEnumBody :

  • members: TSEnumMember[] (requis)

Alias : TypeScript

tsEnumDeclaration​

JavaScript
t.tsEnumDeclaration(id, members);

Voir aussi t.isTSEnumDeclaration(node, opts) et t.assertTSEnumDeclaration(node, opts).

Structure du nœud AST TSEnumDeclaration :

  • id: Identifier (obligatoire)

  • members: TSEnumMember[] (requis)

  • body : TSEnumBody (par défaut : null, exclu de la fonction de construction)

  • const: boolean (par défaut : null, exclu de la fonction builder)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • initializer : Expression (par défaut : null, exclu de la fonction de construction)

Alias : TypeScript, Statement, Declaration

tsEnumMember​

JavaScript
t.tsEnumMember(id, initializer);

Voir aussi t.isTSEnumMember(node, opts) et t.assertTSEnumMember(node, opts).

Structure du nœud AST TSEnumMember :

  • id: Identifier | StringLiteral (requis)

  • initializer : Expression (par défaut : null)

Alias : TypeScript

tsExportAssignment​

JavaScript
t.tsExportAssignment(expression);

Voir aussi t.isTSExportAssignment(node, opts) et t.assertTSExportAssignment(node, opts).

Structure du nœud AST TSExportAssignment :

  • expression: Expression (obligatoire)

Alias: TypeScript, Statement

tsExpressionWithTypeArguments​

JavaScript
t.tsExpressionWithTypeArguments(expression, typeParameters);

Voir aussi t.isTSExpressionWithTypeArguments(node, opts) et t.assertTSExpressionWithTypeArguments(node, opts).

Structure du nœud AST TSExpressionWithTypeArguments :

  • expression : TSEntityName (requis)

  • typeParameters: TSTypeParameterInstantiation (par défaut : null)

Alias : TypeScript, TSType

tsExternalModuleReference​

JavaScript
t.tsExternalModuleReference(expression);

Voir aussi t.isTSExternalModuleReference(node, opts) et t.assertTSExternalModuleReference(node, opts).

Structure du nœud AST TSExternalModuleReference :

  • expression : StringLiteral (requis)

Alias : TypeScript

tsFunctionType​

JavaScript
t.tsFunctionType(typeParameters, parameters, typeAnnotation);

Voir aussi t.isTSFunctionType(node, opts) et t.assertTSFunctionType(node, opts).

Structure du nœud AST TSFunctionType :

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[] (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

Alias : TypeScript, TSType

tsImportEqualsDeclaration​

JavaScript
t.tsImportEqualsDeclaration(id, moduleReference);

Voir aussi t.isTSImportEqualsDeclaration(node, opts) et t.assertTSImportEqualsDeclaration(node, opts).

Structure du nœud AST TSImportEqualsDeclaration :

  • id: Identifier (obligatoire)

  • moduleReference : TSEntityName | TSExternalModuleReference (requis)

  • importKind : "type" | "value" (par défaut : null, exclu de la fonction de construction)

  • isExport : boolean (requis)

Alias : TypeScript, Statement, Declaration

tsImportType​

JavaScript
t.tsImportType(argument, qualifier, typeParameters);

Voir aussi t.isTSImportType(node, opts) et t.assertTSImportType(node, opts).

Structure du nœud AST TSImportType :

  • argument: StringLiteral (requis)

  • qualifier: TSEntityName (par défaut: null)

  • typeParameters: TSTypeParameterInstantiation (par défaut : null)

  • options: ObjectExpression (par défaut: null, exclu de la fonction de construction)

Alias : TypeScript, TSType

tsIndexSignature​

JavaScript
t.tsIndexSignature(parameters, typeAnnotation);

Voir aussi t.isTSIndexSignature(node, opts) et t.assertTSIndexSignature(node, opts).

Forme du nœud AST TSIndexSignature :

  • parameters: Identifier[] (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

  • readonly: boolean (par défaut: null, exclu de la fonction builder)

  • static: boolean (par défaut: null, exclu de la fonction de construction)

Aliases: TypeScript, TSTypeElement

tsIndexedAccessType​

JavaScript
t.tsIndexedAccessType(objectType, indexType);

Voir aussi t.isTSIndexedAccessType(node, opts) et t.assertTSIndexedAccessType(node, opts).

Forme du nœud AST TSIndexedAccessType :

  • objectType: TSType (requis)

  • indexType: TSType (requis)

Alias : TypeScript, TSType

tsInferType​

JavaScript
t.tsInferType(typeParameter);

Voir aussi t.isTSInferType(node, opts) et t.assertTSInferType(node, opts).

Forme du nœud AST TSInferType :

  • typeParameter: TSTypeParameter (requis)

Alias : TypeScript, TSType

tsInstantiationExpression​

JavaScript
t.tsInstantiationExpression(expression, typeParameters);

Voir aussi t.isTSInstantiationExpression(node, opts) et t.assertTSInstantiationExpression(node, opts).

Forme du nœud AST TSInstantiationExpression :

  • expression: Expression (obligatoire)

  • typeParameters: TSTypeParameterInstantiation (par défaut : null)

Alias: TypeScript, Expression

tsInterfaceBody​

JavaScript
t.tsInterfaceBody(body);

Voir aussi t.isTSInterfaceBody(node, opts) et t.assertTSInterfaceBody(node, opts).

Forme du nœud AST TSInterfaceBody :

  • body: TSTypeElement[] (requis)

Alias : TypeScript

tsInterfaceDeclaration​

JavaScript
t.tsInterfaceDeclaration(id, typeParameters, extends, body);

Voir aussi t.isTSInterfaceDeclaration(node, opts) et t.assertTSInterfaceDeclaration(node, opts).

Forme du nœud AST TSInterfaceDeclaration :

  • id: Identifier (obligatoire)

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • extends: TSExpressionWithTypeArguments[] (vaut null par défaut)

  • body: TSInterfaceBody (requis)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

Alias : TypeScript, Statement, Declaration

tsIntersectionType​

JavaScript
t.tsIntersectionType(types);

Voir aussi t.isTSIntersectionType(node, opts) et t.assertTSIntersectionType(node, opts).

Structure du nœud AST TSIntersectionType :

  • types: TSType[] (requis)

Alias : TypeScript, TSType

tsIntrinsicKeyword​

JavaScript
t.tsIntrinsicKeyword();

Voir aussi t.isTSIntrinsicKeyword(node, opts) et t.assertTSIntrinsicKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsLiteralType​

JavaScript
t.tsLiteralType(literal);

Voir aussi t.isTSLiteralType(node, opts) et t.assertTSLiteralType(node, opts).

Structure du nœud AST TSLiteralType :

  • literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression (requis)

Alias : TypeScript, TSType, TSBaseType

tsMappedType​

JavaScript
t.tsMappedType(typeParameter, typeAnnotation, nameType);

Voir aussi t.isTSMappedType(node, opts) et t.assertTSMappedType(node, opts).

Structure du nœud AST TSMappedType :

  • typeParameter: TSTypeParameter (requis)

  • typeAnnotation: TSType (par défaut : null)

  • nameType: TSType (par défaut : null)

  • optional: true | false | "+" | "-" (par défaut : null, exclu de la fonction de construction)

  • readonly: true | false | "+" | "-" (par défaut : null, exclu de la fonction de construction)

Alias : TypeScript, TSType

tsMethodSignature​

JavaScript
t.tsMethodSignature(key, typeParameters, parameters, typeAnnotation);

Voir aussi t.isTSMethodSignature(node, opts) et t.assertTSMethodSignature(node, opts).

Structure du nœud AST TSMethodSignature :

  • key: Expression (requis)

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[] (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

  • computed: boolean (par défaut: false, exclu de la fonction builder)

  • kind: "method" | "get" | "set" (requis)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

Aliases: TypeScript, TSTypeElement

tsModuleBlock​

JavaScript
t.tsModuleBlock(body);

Voir aussi t.isTSModuleBlock(node, opts) et t.assertTSModuleBlock(node, opts).

Structure du nœud AST TSModuleBlock :

  • body: Statement[] (requis)

Alias: TypeScript, Scopable, Block, BlockParent, FunctionParent

tsModuleDeclaration​

JavaScript
t.tsModuleDeclaration(id, body);

Voir aussi t.isTSModuleDeclaration(node, opts) et t.assertTSModuleDeclaration(node, opts).

Structure du nœud AST TSModuleDeclaration :

  • id: Identifier | StringLiteral (requis)

  • body: TSModuleBlock | TSModuleDeclaration (requis)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

  • global: boolean (par défaut: null, exclu de la fonction de construction)

  • kind: "global" | "module" | "namespace" (requis)

Alias : TypeScript, Statement, Declaration

tsNamedTupleMember​

JavaScript
t.tsNamedTupleMember(label, elementType, optional);

Voir aussi t.isTSNamedTupleMember(node, opts) et t.assertTSNamedTupleMember(node, opts).

Structure du nœud AST TSNamedTupleMember :

  • label: Identifier (requis)

  • elementType: TSType (requis)

  • optional: boolean (par défaut: false)

Alias : TypeScript

tsNamespaceExportDeclaration​

JavaScript
t.tsNamespaceExportDeclaration(id);

Voir aussi t.isTSNamespaceExportDeclaration(node, opts) et t.assertTSNamespaceExportDeclaration(node, opts).

Structure du nœud AST TSNamespaceExportDeclaration :

  • id: Identifier (obligatoire)

Alias: TypeScript, Statement

tsNeverKeyword​

JavaScript
t.tsNeverKeyword();

Voir aussi t.isTSNeverKeyword(node, opts) et t.assertTSNeverKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsNonNullExpression​

JavaScript
t.tsNonNullExpression(expression);

Voir aussi t.isTSNonNullExpression(node, opts) et t.assertTSNonNullExpression(node, opts).

Structure du nœud AST TSNonNullExpression :

  • expression: Expression (obligatoire)

Alias : TypeScript, Expression, LVal, PatternLike

tsNullKeyword​

JavaScript
t.tsNullKeyword();

Voir aussi t.isTSNullKeyword(node, opts) et t.assertTSNullKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsNumberKeyword​

JavaScript
t.tsNumberKeyword();

Voir aussi t.isTSNumberKeyword(node, opts) et t.assertTSNumberKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsObjectKeyword​

JavaScript
t.tsObjectKeyword();

Voir aussi t.isTSObjectKeyword(node, opts) et t.assertTSObjectKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsOptionalType​

JavaScript
t.tsOptionalType(typeAnnotation);

Voir aussi t.isTSOptionalType(node, opts) et t.assertTSOptionalType(node, opts).

Structure du nœud AST TSOptionalType :

  • typeAnnotation: TSType (requis)

Alias : TypeScript, TSType

tsParameterProperty​

JavaScript
t.tsParameterProperty(parameter);

Voir aussi t.isTSParameterProperty(node, opts) et t.assertTSParameterProperty(node, opts).

Structure du nœud AST TSParameterProperty :

  • parameter: Identifier | AssignmentPattern (requis)

  • accessibility: "public" | "private" | "protected" (par défaut: null, exclu de la fonction builder)

  • decorators: Decorator[] (vaut null par défaut, exclu de la fonction de construction)

  • override: boolean (par défaut: null, exclu de la fonction builder)

  • readonly: boolean (par défaut: null, exclu de la fonction builder)

Aliases: TypeScript, LVal

tsParenthesizedType​

JavaScript
t.tsParenthesizedType(typeAnnotation);

Voir aussi t.isTSParenthesizedType(node, opts) et t.assertTSParenthesizedType(node, opts).

Structure du nœud AST TSParenthesizedType :

  • typeAnnotation: TSType (requis)

Alias : TypeScript, TSType

tsPropertySignature​

JavaScript
t.tsPropertySignature(key, typeAnnotation);

Voir aussi t.isTSPropertySignature(node, opts) et t.assertTSPropertySignature(node, opts).

Structure du nœud AST TSPropertySignature :

  • key: Expression (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

  • computed: boolean (par défaut: false, exclu de la fonction builder)

  • kind: "get" | "set" (par défaut: null, exclu de la fonction builder)

  • optional: boolean (par défaut: null, exclu de la fonction builder)

  • readonly: boolean (par défaut: null, exclu de la fonction builder)

Aliases: TypeScript, TSTypeElement

tsQualifiedName​

JavaScript
t.tsQualifiedName(left, right);

Voir aussi t.isTSQualifiedName(node, opts) et t.assertTSQualifiedName(node, opts).

Structure du nœud AST TSQualifiedName :

  • left: TSEntityName (requis)

  • right: Identifier (requis)

Aliases: TypeScript, TSEntityName

tsRestType​

JavaScript
t.tsRestType(typeAnnotation);

Voir aussi t.isTSRestType(node, opts) et t.assertTSRestType(node, opts).

Forme du nœud AST TSRestType :

  • typeAnnotation: TSType (requis)

Alias : TypeScript, TSType

tsSatisfiesExpression​

JavaScript
t.tsSatisfiesExpression(expression, typeAnnotation);
History
VersionChanges
v7.20.0Introduced

Voir aussi t.isTSSatisfiesExpression(node, opts) et t.assertTSSatisfiesExpression(node, opts).

Forme du nœud AST TSSatisfiesExpression :

  • expression: Expression (obligatoire)

  • typeAnnotation: TSType (requis)

Alias : TypeScript, Expression, LVal, PatternLike

tsStringKeyword​

JavaScript
t.tsStringKeyword();

Voir aussi t.isTSStringKeyword(node, opts) et t.assertTSStringKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsSymbolKeyword​

JavaScript
t.tsSymbolKeyword();

Voir aussi t.isTSSymbolKeyword(node, opts) et t.assertTSSymbolKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsTemplateLiteralType​

JavaScript
t.tsTemplateLiteralType(quasis, types);

Voir aussi t.isTSTemplateLiteralType(node, opts) et t.assertTSTemplateLiteralType(node, opts).

Forme du nœud AST TSTemplateLiteralType :

  • quasis: TemplateElement[] (requis)

  • types: TSType[] (requis)

Alias : TypeScript, TSType, TSBaseType

tsThisType​

JavaScript
t.tsThisType();

Voir aussi t.isTSThisType(node, opts) et t.assertTSThisType(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsTupleType​

JavaScript
t.tsTupleType(elementTypes);

Voir aussi t.isTSTupleType(node, opts) et t.assertTSTupleType(node, opts).

Forme du nœud AST TSTupleType :

  • elementTypes: (TSType | TSNamedTupleMember)[] (requis)

Alias : TypeScript, TSType

tsTypeAliasDeclaration​

JavaScript
t.tsTypeAliasDeclaration(id, typeParameters, typeAnnotation);

Voir aussi t.isTSTypeAliasDeclaration(node, opts) et t.assertTSTypeAliasDeclaration(node, opts).

Forme du nœud AST TSTypeAliasDeclaration :

  • id: Identifier (obligatoire)

  • typeParameters: TSTypeParameterDeclaration (par défaut : null)

  • typeAnnotation: TSType (requis)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

Alias : TypeScript, Statement, Declaration

tsTypeAnnotation​

JavaScript
t.tsTypeAnnotation(typeAnnotation);

Voir aussi t.isTSTypeAnnotation(node, opts) et t.assertTSTypeAnnotation(node, opts).

Forme du nœud AST TSTypeAnnotation :

  • typeAnnotation: TSType (requis)

Alias : TypeScript

tsTypeAssertion​

JavaScript
t.tsTypeAssertion(typeAnnotation, expression);

Voir aussi t.isTSTypeAssertion(node, opts) et t.assertTSTypeAssertion(node, opts).

Forme du nœud AST TSTypeAssertion :

  • typeAnnotation: TSType (requis)

  • expression: Expression (obligatoire)

Alias : TypeScript, Expression, LVal, PatternLike

tsTypeLiteral​

JavaScript
t.tsTypeLiteral(members);

Voir aussi t.isTSTypeLiteral(node, opts) et t.assertTSTypeLiteral(node, opts).

Forme du nœud AST TSTypeLiteral :

  • members: TSTypeElement[] (requis)

Alias : TypeScript, TSType

tsTypeOperator​

JavaScript
t.tsTypeOperator(typeAnnotation, operator);

Voir aussi t.isTSTypeOperator(node, opts) et t.assertTSTypeOperator(node, opts).

Forme du nœud AST TSTypeOperator :

  • typeAnnotation: TSType (requis)

  • operator: string (par défaut : 'keyof')

Alias : TypeScript, TSType

tsTypeParameter​

JavaScript
t.tsTypeParameter(constraint, default, name);
History
VersionChanges
v7.21.0Supports const

Voir aussi t.isTSTypeParameter(node, opts) et t.assertTSTypeParameter(node, opts).

Forme du nœud AST TSTypeParameter :

  • constraint: TSType (par défaut : null)

  • default: TSType (par défaut : null)

  • name : string (obligatoire)

  • const: boolean (par défaut : null, exclu de la fonction builder)

  • in: boolean (par défaut : null, exclu de la fonction builder)

  • out: boolean (par défaut : null, exclu de la fonction builder)

Alias : TypeScript

tsTypeParameterDeclaration​

JavaScript
t.tsTypeParameterDeclaration(params);

Voir aussi t.isTSTypeParameterDeclaration(node, opts) et t.assertTSTypeParameterDeclaration(node, opts).

Forme du nœud AST TSTypeParameterDeclaration :

  • params: TSTypeParameter[] (requis)

Alias : TypeScript

tsTypeParameterInstantiation​

JavaScript
t.tsTypeParameterInstantiation(params);

Voir aussi t.isTSTypeParameterInstantiation(node, opts) et t.assertTSTypeParameterInstantiation(node, opts).

Structure du nœud AST TSTypeParameterInstantiation :

  • params: TSType[] (requis)

Alias : TypeScript

tsTypePredicate​

JavaScript
t.tsTypePredicate(parameterName, typeAnnotation, asserts);

Voir aussi t.isTSTypePredicate(node, opts) et t.assertTSTypePredicate(node, opts).

Structure du nœud AST TSTypePredicate :

  • parameterName: Identifier | TSThisType (requis)

  • typeAnnotation: TSTypeAnnotation (par défaut : null)

  • asserts: boolean (par défaut : null)

Alias : TypeScript, TSType

tsTypeQuery​

JavaScript
t.tsTypeQuery(exprName, typeParameters);

Voir aussi t.isTSTypeQuery(node, opts) et t.assertTSTypeQuery(node, opts).

Structure du nœud AST TSTypeQuery :

  • exprName: TSEntityName | TSImportType (requis)

  • typeParameters: TSTypeParameterInstantiation (par défaut : null)

Alias : TypeScript, TSType

tsTypeReference​

JavaScript
t.tsTypeReference(typeName, typeParameters);

Voir aussi t.isTSTypeReference(node, opts) et t.assertTSTypeReference(node, opts).

Structure du nœud AST TSTypeReference :

  • typeName: TSEntityName (requis)

  • typeParameters: TSTypeParameterInstantiation (par défaut : null)

Alias : TypeScript, TSType

tsUndefinedKeyword​

JavaScript
t.tsUndefinedKeyword();

Voir aussi t.isTSUndefinedKeyword(node, opts) et t.assertTSUndefinedKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsUnionType​

JavaScript
t.tsUnionType(types);

Voir aussi t.isTSUnionType(node, opts) et t.assertTSUnionType(node, opts).

Structure du nœud AST TSUnionType :

  • types: TSType[] (requis)

Alias : TypeScript, TSType

tsUnknownKeyword​

JavaScript
t.tsUnknownKeyword();

Voir aussi t.isTSUnknownKeyword(node, opts) et t.assertTSUnknownKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

tsVoidKeyword​

JavaScript
t.tsVoidKeyword();

Voir aussi t.isTSVoidKeyword(node, opts) et t.assertTSVoidKeyword(node, opts).

Alias : TypeScript, TSType, TSBaseType

taggedTemplateExpression​

JavaScript
t.taggedTemplateExpression(tag, quasi);

Voir aussi t.isTaggedTemplateExpression(node, opts) et t.assertTaggedTemplateExpression(node, opts).

Structure du nœud AST TaggedTemplateExpression :

  • tag: Expression (obligatoire)

  • quasi: TemplateLiteral (obligatoire)

  • typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (par défaut : null, exclu de la fonction de construction)

Alias : Standardized, Expression

templateElement​

JavaScript
t.templateElement(value, tail);

Voir aussi t.isTemplateElement(node, opts) et t.assertTemplateElement(node, opts).

Structure du nœud AST TemplateElement :

  • value: { raw: string, cooked?: string } (obligatoire)

  • tail: boolean (par défaut : false)

Alias : Standardized

templateLiteral​

JavaScript
t.templateLiteral(quasis, expressions);

Voir aussi t.isTemplateLiteral(node, opts) et t.assertTemplateLiteral(node, opts).

Structure du nœud AST TemplateLiteral :

  • quasis: TemplateElement[] (requis)

  • expressions: (Expression | TSType)[] (requis)

Alias : Standardized, Expression, Literal

thisExpression​

JavaScript
t.thisExpression();

Voir aussi t.isThisExpression(node, opts) et t.assertThisExpression(node, opts).

Alias : Standardized, Expression

thisTypeAnnotation​

JavaScript
t.thisTypeAnnotation();

Voir aussi t.isThisTypeAnnotation(node, opts) et t.assertThisTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

throwStatement​

JavaScript
t.throwStatement(argument);

Voir aussi t.isThrowStatement(node, opts) et t.assertThrowStatement(node, opts).

Structure du nœud AST ThrowStatement :

  • argument : Expression (obligatoire)

Alias : Standardized, Statement, Terminatorless, CompletionStatement

topicReference​

JavaScript
t.topicReference();

Voir aussi t.isTopicReference(node, opts) et t.assertTopicReference(node, opts).

Alias : Expression

tryStatement​

JavaScript
t.tryStatement(block, handler, finalizer);

Voir aussi t.isTryStatement(node, opts) et t.assertTryStatement(node, opts).

Structure du nœud AST TryStatement :

  • block: BlockStatement (obligatoire)

  • handler: CatchClause (par défaut : null)

  • finalizer: BlockStatement (par défaut : null)

Alias : Standardized, Statement

tupleExpression​

JavaScript
t.tupleExpression(elements);

Voir aussi t.isTupleExpression(node, opts) et t.assertTupleExpression(node, opts).

Structure du nœud AST TupleExpression :

  • elements: (Expression | SpreadElement)[] (vaut [] par défaut)

Alias : Expression

tupleTypeAnnotation​

JavaScript
t.tupleTypeAnnotation(types);

Voir aussi t.isTupleTypeAnnotation(node, opts) et t.assertTupleTypeAnnotation(node, opts).

Structure du nœud AST TupleTypeAnnotation :

  • types: FlowType[] (requis)

Alias : Flow, FlowType

typeAlias​

JavaScript
t.typeAlias(id, typeParameters, right);

Voir aussi t.isTypeAlias(node, opts) et t.assertTypeAlias(node, opts).

Structure du nœud AST TypeAlias :

  • id: Identifier (obligatoire)

  • typeParameters: TypeParameterDeclaration (par défaut : null)

  • right: FlowType (obligatoire)

Alias : Flow, FlowDeclaration, Statement, Declaration

typeAnnotation​

JavaScript
t.typeAnnotation(typeAnnotation);

Voir aussi t.isTypeAnnotation(node, opts) et t.assertTypeAnnotation(node, opts).

Structure du nœud AST TypeAnnotation :

  • typeAnnotation: FlowType (obligatoire)

Alias : Flow

typeCastExpression​

JavaScript
t.typeCastExpression(expression, typeAnnotation);

Voir aussi t.isTypeCastExpression(node, opts) et t.assertTypeCastExpression(node, opts).

Structure du nœud AST TypeCastExpression :

  • expression: Expression (obligatoire)

  • typeAnnotation: TypeAnnotation (obligatoire)

Alias : Flow, ExpressionWrapper, Expression

typeParameter​

JavaScript
t.typeParameter(bound, default, variance);

Voir aussi t.isTypeParameter(node, opts) et t.assertTypeParameter(node, opts).

Structure du nœud AST TypeParameter :

  • bound: TypeAnnotation (par défaut : null)

  • default: FlowType (par défaut : null)

  • variance: Variance (par défaut : null)

  • name : string (obligatoire)

Alias : Flow

typeParameterDeclaration​

JavaScript
t.typeParameterDeclaration(params);

Voir aussi t.isTypeParameterDeclaration(node, opts) et t.assertTypeParameterDeclaration(node, opts).

Structure du nœud AST TypeParameterDeclaration :

  • params: TypeParameter[] (requis)

Alias : Flow

typeParameterInstantiation​

JavaScript
t.typeParameterInstantiation(params);

Voir aussi t.isTypeParameterInstantiation(node, opts) et t.assertTypeParameterInstantiation(node, opts).

Structure du nœud AST TypeParameterInstantiation :

  • params: FlowType[] (requis)

Alias : Flow

typeofTypeAnnotation​

JavaScript
t.typeofTypeAnnotation(argument);

Voir aussi t.isTypeofTypeAnnotation(node, opts) et t.assertTypeofTypeAnnotation(node, opts).

Structure du nœud AST TypeofTypeAnnotation :

  • argument : FlowType (obligatoire)

Alias : Flow, FlowType

unaryExpression​

JavaScript
t.unaryExpression(operator, argument, prefix);

Voir aussi t.isUnaryExpression(node, opts) et t.assertUnaryExpression(node, opts).

Structure du nœud AST UnaryExpression :

  • operator : "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof" (obligatoire)

  • argument : Expression (obligatoire)

  • prefix : boolean (par défaut : true)

Alias : Standardized, UnaryLike, Expression

unionTypeAnnotation​

JavaScript
t.unionTypeAnnotation(types);

Voir aussi t.isUnionTypeAnnotation(node, opts) et t.assertUnionTypeAnnotation(node, opts).

Structure du nœud AST UnionTypeAnnotation :

  • types: FlowType[] (requis)

Alias : Flow, FlowType

updateExpression​

JavaScript
t.updateExpression(operator, argument, prefix);

Voir aussi t.isUpdateExpression(node, opts) et t.assertUpdateExpression(node, opts).

Structure du nœud AST UpdateExpression :

  • operator : "++" | "--" (obligatoire)

  • argument : Expression (obligatoire)

  • prefix : boolean (par défaut : false)

Alias : Standardized, Expression

v8IntrinsicIdentifier​

JavaScript
t.v8IntrinsicIdentifier(name);

Voir aussi t.isV8IntrinsicIdentifier(node, opts) et t.assertV8IntrinsicIdentifier(node, opts).

Structure du nœud AST V8IntrinsicIdentifier :

  • name : string (obligatoire)

Alias : Miscellaneous

variableDeclaration​

JavaScript
t.variableDeclaration(kind, declarations);
History
VersionChanges
v7.20.0kind can be "using".
v7.22.0kind can be "await using".

Voir aussi t.isVariableDeclaration(node, opts) et t.assertVariableDeclaration(node, opts).

Structure du nœud AST VariableDeclaration :

  • kind : "var" | "let" | "const" | "using" | "await using" (obligatoire)

  • declarations: VariableDeclarator[] (requis)

  • declare : boolean (par défaut : null, exclu de la fonction builder)

Alias : Standardized, Statement, Declaration

variableDeclarator​

JavaScript
t.variableDeclarator(id, init);

Voir aussi t.isVariableDeclarator(node, opts) et t.assertVariableDeclarator(node, opts).

Structure du nœud AST VariableDeclarator :

  • id : LVal | VoidPattern (obligatoire)

  • init: Expression (par défaut : null)

  • definite: boolean (par défaut : null, exclu de la fonction de construction)

Alias : Standardized

variance​

JavaScript
t.variance(kind);

Voir aussi t.isVariance(node, opts) et t.assertVariance(node, opts).

Forme du nœud AST Variance :

  • kind: "minus" | "plus" (requis)

Alias : Flow

voidPattern​

JavaScript
t.voidPattern();
History
VersionChanges
v7.28.0Introduced

Voir aussi t.isVoidPattern(node, opts) et t.assertVoidPattern(node, opts).

Alias : Pattern, PatternLike, FunctionParameter

voidTypeAnnotation​

JavaScript
t.voidTypeAnnotation();

Voir aussi t.isVoidTypeAnnotation(node, opts) et t.assertVoidTypeAnnotation(node, opts).

Alias : Flow, FlowType, FlowBaseAnnotation

whileStatement​

JavaScript
t.whileStatement(test, body);

Voir aussi t.isWhileStatement(node, opts) et t.assertWhileStatement(node, opts).

Forme du nœud AST WhileStatement :

  • test: Expression (requis)

  • body: Statement (requis)

Alias : Standardized, Statement, BlockParent, Loop, While, Scopable

withStatement​

JavaScript
t.withStatement(object, body);

Voir aussi t.isWithStatement(node, opts) et t.assertWithStatement(node, opts).

Forme du nœud AST WithStatement :

  • object: Expression (requis)

  • body: Statement (requis)

Alias : Standardized, Statement

yieldExpression​

JavaScript
t.yieldExpression(argument, delegate);

Voir aussi t.isYieldExpression(node, opts) et t.assertYieldExpression(node, opts).

Forme du nœud AST YieldExpression :

  • argument: Expression (par défaut : null)

  • delegate: boolean (par défaut : false)

Alias : Standardized, Expression, Terminatorless

Alias​

Accessor​

Déprécié. Sera supprimé dans Babel 8.

JavaScript
t.isAccessor(node);

Nœuds couverts :

Binary​

Regroupe BinaryExpression et LogicalExpression, qui partagent la même structure AST.

JavaScript
t.isBinary(node);

Nœuds couverts :

Block​

Déprécié. Sera supprimé dans Babel 8.

JavaScript
t.isBlock(node);

Nœuds couverts :

BlockParent​

Regroupe les nœuds AST qui initient un contexte d'exécution avec une nouvelle LexicalEnvironment. Autrement dit, ils définissent la portée des déclarations let et const.

JavaScript
t.isBlockParent(node);

Nœuds couverts :

Class​

Regroupe ClassExpression et ClassDeclaration, qui partagent la même structure AST.

JavaScript
t.isClass(node);

Nœuds couverts :

CompletionStatement​

Instruction qui indique les completion records. Autrement dit, elles définissent le flux de contrôle du programme, par exemple quand une boucle doit s'interrompre ou quand une action génère des erreurs critiques.

JavaScript
t.isCompletionStatement(node);

Nœuds couverts :

Conditional​

Regroupe ConditionalExpression et IfStatement, qui partagent la même structure AST.

JavaScript
t.isConditional(node);

Nœuds couverts :

Declaration​

Regroupe toutes les Declaration.

JavaScript
t.isDeclaration(node);

Nœuds couverts :

EnumBody​

Regroupement des corps d'énumérations Flow.

JavaScript
t.isEnumBody(node);

Nœuds couverts :

EnumMember​

Regroupement des membres d'énumération Flow.

JavaScript
t.isEnumMember(node);

Nœuds couverts :

ExportDeclaration​

Regroupement de toutes les ExportDeclaration.

JavaScript
t.isExportDeclaration(node);

Nœuds couverts :

Expression​

Regroupement de toutes les Expression.

JavaScript
t.isExpression(node);

Nœuds couverts :

ExpressionWrapper​

Un wrapper d'expression sans sémantique d'exécution.

JavaScript
t.isExpressionWrapper(node);

Nœuds couverts :

Flow​

Couverture des nœuds AST définis pour Flow.

JavaScript
t.isFlow(node);

Nœuds couverts :

FlowBaseAnnotation​

Regroupement des annotations de type primaires dans Flow.

JavaScript
t.isFlowBaseAnnotation(node);

Nœuds couverts :

FlowDeclaration​

Regroupement des déclarations Flow.

JavaScript
t.isFlowDeclaration(node);

Nœuds couverts :

FlowPredicate​

Regroupement des prédicats Flow.

JavaScript
t.isFlowPredicate(node);

Nœuds couverts :

FlowType​

Regroupement des annotations de type Flow.

JavaScript
t.isFlowType(node);

Nœuds couverts :

Boucle​

Une catégorie regroupant les ForStatements et les ForXStatements.

JavaScript
t.isFor(node);

Nœuds couverts :

ForXStatement​

Une catégorie regroupant les instructions ForIn et ForOf.

JavaScript
t.isForXStatement(node);

Nœuds couverts :

Function​

Une catégorie regroupant les fonctions et les méthodess, qui doivent obligatoirement comporter body et params. Remarque : Function est différent de FunctionParent. Par exemple, un StaticBlock est un FunctionParent mais pas une Function.

JavaScript
t.isFunction(node);

Nœuds couverts :

FunctionParameter​

Une catégorie regroupant les paramètres de fonction. Ils constituent les éléments de la FormalParameterList.

JavaScript
t.isFunctionParameter(node);

Nœuds couverts :

FunctionParent​

Un ensemble de nœuds AST qui initient un contexte d'exécution avec une nouvelle VariableEnvironment. Autrement dit, ils définissent la portée des déclarations var. FunctionParent n'incluait pas Program depuis Babel 7.

JavaScript
t.isFunctionParent(node);

Nœuds couverts :

Immuable​

Ensemble d'objets immuables et d'éléments JSX. Un objet est immuable si aucune autre propriété ne peut être définie après sa création.

JavaScript
t.isImmutable(node);

Nœuds couverts :

Déclaration d'import/export​

History
VersionChanges
v7.21.0Introduced

Ensemble de ImportDeclaration et ExportDeclaration.

JavaScript
t.isImportOrExportDeclaration(node);

Nœuds couverts :

JSX​

Ensemble de nœuds AST définis pour JSX.

JavaScript
t.isJSX(node);

Nœuds couverts :

LVal​

Une couverture des expressions côté gauche utilisées dans la partie left des expressions d'assignation et des ForXStatement.

JavaScript
t.isLVal(node);

Nœuds couverts :

Literal​

Une couverture des littéraux, littéraux d'expression régulière et littéraux de gabarit.

JavaScript
t.isLiteral(node);

Nœuds couverts :

Loop​

Une couverture des instructions de boucle.

JavaScript
t.isLoop(node);

Nœuds couverts :

Method​

Une couverture des méthodes d'objet et de classe.

JavaScript
t.isMethod(node);

Nœuds couverts :

Divers​

Une couverture des types AST non standard parfois utiles pour le développement.

JavaScript
t.isMiscellaneous(node);

Nœuds couverts :

ModuleDeclaration​

History
VersionChanges
v7.21.0Deprecated
attention

Obsolète, utilisez plutôt ImportOrExportDeclaration. Consultez la PR #15266 pour les notes de migration.

JavaScript
t.isModuleDeclaration(node);

Nœuds couverts :

ModuleSpecifier​

Regroupement des spécificateurs d'import et d'export. Note : ce n'est pas le ModuleSpecifier défini dans la spécification.

JavaScript
t.isModuleSpecifier(node);

Nœuds couverts :

ObjectMember​

Regroupement des membres dans un littéral objet.

JavaScript
t.isObjectMember(node);

Nœuds couverts :

Pattern​

Regroupement des BindingPattern à l'exclusion des Identifiers.

JavaScript
t.isPattern(node);

Nœuds couverts :

PatternLike​

Regroupement des BindingPatterns.

JavaScript
t.isPatternLike(node);

Nœuds couverts :

Private​

Regroupement des éléments privés de classe et des identifiants privés.

JavaScript
t.isPrivate(node);

Nœuds couverts :

Property​

Regroupement des propriétés d'objet et de classe.

JavaScript
t.isProperty(node);

Nœuds couverts :

Pureish​

Catégorie regroupant les nœuds AST qui ne produisent pas d'effets de bord. Autrement dit, leur évaluation multiple n'entraîne aucun changement de comportement observable.

JavaScript
t.isPureish(node);

Nœuds couverts :

Scopable​

Catégorie englobant FunctionParent et BlockParent.

JavaScript
t.isScopable(node);

Nœuds couverts :

Standardized​

Catégorie regroupant les nœuds AST faisant partie d'une spécification ECMAScript officielle.

JavaScript
t.isStandardized(node);

Nœuds couverts :

Instruction​

Couverture de tous les types de Statement.

JavaScript
t.isStatement(node);

Nœuds couverts :

TSBaseType​

Ensemble des annotations de type primaires de TypeScript.

JavaScript
t.isTSBaseType(node);

Nœuds couverts :

TSEntityName​

Ensemble des entités TypeScript.

JavaScript
t.isTSEntityName(node);

Nœuds couverts :

TSType​

Ensemble des annotations de type TypeScript.

JavaScript
t.isTSType(node);

Nœuds couverts :

TSTypeElement​

Regroupe les déclarations de types TypeScript.

JavaScript
t.isTSTypeElement(node);

Nœuds couverts :

Terminatorless​

Regroupe les nœuds AST dont la sémantique change lorsqu'un terminateur de ligne est inséré entre l'opérateur et l'opérande.

JavaScript
t.isTerminatorless(node);

Nœuds couverts :

TypeScript​

Regroupe les nœuds AST spécifiques à TypeScript.

JavaScript
t.isTypeScript(node);

Nœuds couverts :

Expressions unaires et étalement (UnaryLike)​

Regroupe UnaryExpression et SpreadElement.

JavaScript
t.isUnaryLike(node);

Nœuds couverts :

UserWhitespacable​

Déprécié. Sera supprimé dans Babel 8.

JavaScript
t.isUserWhitespacable(node);

Nœuds couverts :

Boucles While​

Regroupe DoWhileStatement et WhileStatement, qui partagent la même structure AST.

JavaScript
t.isWhile(node);

Nœuds couverts :