Saltar al contenido principal

@babel/types

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Este módulo contiene métodos para construir ASTs manualmente y para verificar los tipos de nodos AST.

Instalación​

npm install --save-dev @babel/types

API​

Constructores de nodos​

anyTypeAnnotation​

JavaScript
t.anyTypeAnnotation();

Véase también t.isAnyTypeAnnotation(node, opts) y t.assertAnyTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

argumentPlaceholder​

JavaScript
t.argumentPlaceholder();

Véase también t.isArgumentPlaceholder(node, opts) y t.assertArgumentPlaceholder(node, opts).

arrayExpression​

JavaScript
t.arrayExpression(elements);

Véase también t.isArrayExpression(node, opts) y t.assertArrayExpression(node, opts).

Estructura del nodo AST ArrayExpression:

  • elements: (null | Expression | SpreadElement)[] (por defecto: [])

Alias: Standardized, Expression

arrayPattern​

JavaScript
t.arrayPattern(elements);

Véase también t.isArrayPattern(node, opts) y t.assertArrayPattern(node, opts).

Estructura del nodo AST ArrayPattern:

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

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, FunctionParameter, Pattern, PatternLike, LVal

arrayTypeAnnotation​

JavaScript
t.arrayTypeAnnotation(elementType);

Véase también t.isArrayTypeAnnotation(node, opts) y t.assertArrayTypeAnnotation(node, opts).

Estructura del nodo AST ArrayTypeAnnotation:

  • elementType: FlowType (requerido)

Alias: Flow, FlowType

arrowFunctionExpression​

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

Véase también t.isArrowFunctionExpression(node, opts) y t.assertArrowFunctionExpression(node, opts).

Estructura del nodo AST ArrowFunctionExpression:

  • params: FunctionParameter[] (requerido)

  • body: BlockStatement | Expression (requerido)

  • async: boolean (por defecto: false)

  • expression: boolean (requerido)

  • generator: boolean (valor predeterminado: false, excluido de la función de construcción)

  • predicate: DeclaredPredicate | InferredPredicate (predeterminado: null, excluido de la función builder)

  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (por defecto: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

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

assignmentExpression​

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

Ver también t.isAssignmentExpression(node, opts) y t.assertAssignmentExpression(node, opts).

Estructura del nodo AST AssignmentExpression:

  • operator: string (requerido)

  • left: LVal | OptionalMemberExpression (requerido)

  • right: Expression (requerido)

Alias: Standardized, Expression

assignmentPattern​

JavaScript
t.assignmentPattern(left, right);

Ver también t.isAssignmentPattern(node, opts) y t.assertAssignmentPattern(node, opts).

Estructura del nodo AST AssignmentPattern:

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

  • right: Expression (requerido)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, FunctionParameter, Pattern, PatternLike, LVal

awaitExpression​

JavaScript
t.awaitExpression(argument);

Ver también t.isAwaitExpression(node, opts) y t.assertAwaitExpression(node, opts).

Estructura del nodo AST AwaitExpression:

  • argument: Expression (requerido)

Alias: Standardized, Expression, Terminatorless

bigIntLiteral​

JavaScript
t.bigIntLiteral(value);

Ver también t.isBigIntLiteral(node, opts) y t.assertBigIntLiteral(node, opts).

Estructura del nodo AST BigIntLiteral:

  • value: string (requerido)

Alias: Standardized, Expression, Pureish, Literal, Immutable

binaryExpression​

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

Ver también t.isBinaryExpression(node, opts) y t.assertBinaryExpression(node, opts).

Estructura del nodo AST BinaryExpression:

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

  • left: Expression | PrivateName (requerido)

  • right: Expression (requerido)

Alias: Standardized, Binary, Expression

bindExpression​

JavaScript
t.bindExpression(object, callee);

Consulta también t.isBindExpression(node, opts) y t.assertBindExpression(node, opts).

Estructura del nodo AST BindExpression:

  • object: Expression (requerido)

  • callee: Expression (requerido)

Alias: Expression

blockStatement​

JavaScript
t.blockStatement(body, directives);

Consulta también t.isBlockStatement(node, opts) y t.assertBlockStatement(node, opts).

Estructura del nodo AST BlockStatement:

  • body: Statement[] (requerido)

  • directives: Directive[] (por defecto: [])

Alias: Standardized, Scopable, BlockParent, Block, Statement

booleanLiteral​

JavaScript
t.booleanLiteral(value);

Consulta también t.isBooleanLiteral(node, opts) y t.assertBooleanLiteral(node, opts).

Estructura del nodo AST BooleanLiteral:

  • value: boolean (requerido)

Alias: Standardized, Expression, Pureish, Literal, Immutable

booleanLiteralTypeAnnotation​

JavaScript
t.booleanLiteralTypeAnnotation(value);

Consulta también t.isBooleanLiteralTypeAnnotation(node, opts) y t.assertBooleanLiteralTypeAnnotation(node, opts).

Estructura del nodo AST BooleanLiteralTypeAnnotation:

  • value: boolean (requerido)

Alias: Flow, FlowType

booleanTypeAnnotation​

JavaScript
t.booleanTypeAnnotation();

Consulta también t.isBooleanTypeAnnotation(node, opts) y t.assertBooleanTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

breakStatement​

JavaScript
t.breakStatement(label);

Consulta también t.isBreakStatement(node, opts) y t.assertBreakStatement(node, opts).

Estructura del nodo AST BreakStatement:

  • label: Identifier (valor predeterminado: null)

Alias: Standardized, Statement, Terminatorless, CompletionStatement

callExpression​

JavaScript
t.callExpression(callee, arguments);

Consulta también t.isCallExpression(node, opts) y t.assertCallExpression(node, opts).

Estructura del nodo AST CallExpression:

  • callee: Expression | Super | V8IntrinsicIdentifier (requerido)

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

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeArguments: TypeParameterInstantiation (por defecto: null, excluido de la función constructora)

  • typeParameters: TSTypeParameterInstantiation (por defecto: null, excluido de la función constructora)

Alias: Standardized, Expression

catchClause​

JavaScript
t.catchClause(param, body);

Ver también t.isCatchClause(node, opts) y t.assertCatchClause(node, opts).

Estructura del nodo AST CatchClause:

  • param: Identifier | ArrayPattern | ObjectPattern (por defecto: null)

  • body: BlockStatement (requerido)

Alias: Standardized, Scopable, BlockParent

classAccessorProperty​

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

Ver también t.isClassAccessorProperty(node, opts) y t.assertClassAccessorProperty(node, opts).

Estructura del nodo AST ClassAccessorProperty:

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

  • value: Expression (valor predeterminado: null)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null)

  • decorators: Decorator[] (por defecto: null)

  • computed: boolean (por defecto: false)

  • static: boolean (valor predeterminado: false)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

  • accessibility: "public" | "private" | "protected" (por defecto: null, excluido de la función constructora)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • definite: boolean (valor por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • override: boolean (valor predeterminado: false, excluido de la función de construcción)

  • readonly: boolean (por defecto: null, excluido de la función constructora)

  • variance: Variance (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, Property, Accessor

classBody​

JavaScript
t.classBody(body);

Ver también t.isClassBody(node, opts) y t.assertClassBody(node, opts).

Estructura del nodo AST ClassBody:

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

Alias: Standardized

classDeclaration​

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

Ver también t.isClassDeclaration(node, opts) y t.assertClassDeclaration(node, opts).

Estructura del nodo AST ClassDeclaration:

  • id: Identifier (por defecto: null)

  • superClass: Expression (valor predeterminado: null)

  • body: ClassBody (requerido)

  • decorators: Decorator[] (por defecto: null)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • implements: (TSExpressionWithTypeArguments | ClassImplements)[] (por defecto: null, excluido de la función de construcción)

  • mixins: InterfaceExtends (valor predeterminado: null, excluido de la función de construcción)

  • superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (valor predeterminado: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

Alias: Standardized, Scopable, Class, Statement, Declaration

classExpression​

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

Ver también t.isClassExpression(node, opts) y t.assertClassExpression(node, opts).

Estructura del nodo AST ClassExpression:

  • id: Identifier (por defecto: null)

  • superClass: Expression (valor predeterminado: null)

  • body: ClassBody (requerido)

  • decorators: Decorator[] (por defecto: null)

  • implements: (TSExpressionWithTypeArguments | ClassImplements)[] (por defecto: null, excluido de la función de construcción)

  • mixins: InterfaceExtends (valor predeterminado: null, excluido de la función de construcción)

  • superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (valor predeterminado: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

Alias: Standardized, Scopable, Class, Expression

classImplements​

JavaScript
t.classImplements(id, typeParameters);

Ver también t.isClassImplements(node, opts) y t.assertClassImplements(node, opts).

Estructura del nodo AST ClassImplements:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterInstantiation (por defecto: null)

Alias: Flow

classMethod​

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

Ver también t.isClassMethod(node, opts) y t.assertClassMethod(node, opts).

Estructura del nodo AST ClassMethod:

  • kind: "get" | "set" | "method" | "constructor" (valor predeterminado: 'method')

  • key: si es computada entonces Expression si no Identifier | Literal (requerido)

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

  • body: BlockStatement (requerido)

  • computed: boolean (por defecto: false)

  • static: boolean (valor predeterminado: false)

  • generator: boolean (por defecto: false)

  • async: boolean (por defecto: false)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

  • access: "public" | "private" | "protected" (valor predeterminado: null, excluido de la función de construcción)

  • accessibility: "public" | "private" | "protected" (por defecto: null, excluido de la función constructora)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • override: boolean (valor predeterminado: false, excluido de la función de construcción)

  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (por defecto: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

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

classPrivateMethod​

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

Ver también t.isClassPrivateMethod(node, opts) y t.assertClassPrivateMethod(node, opts).

Estructura del nodo AST ClassPrivateMethod:

  • kind: "get" | "set" | "method" (por defecto: 'method')

  • key: PrivateName (requerido)

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

  • body: BlockStatement (requerido)

  • static: boolean (valor predeterminado: false)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

  • access: "public" | "private" | "protected" (valor predeterminado: null, excluido de la función de construcción)

  • accessibility: "public" | "private" | "protected" (por defecto: null, excluido de la función constructora)

  • async: boolean (valor predeterminado: false, excluido de la función de construcción)

  • computed: 'false' (por defecto: false, excluido de la función constructora)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • generator: boolean (valor predeterminado: false, excluido de la función de construcción)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • override: boolean (valor predeterminado: false, excluido de la función de construcción)

  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (por defecto: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

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

classPrivateProperty​

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

Ver también t.isClassPrivateProperty(node, opts) y t.assertClassPrivateProperty(node, opts).

Estructura del nodo AST ClassPrivateProperty:

  • key: PrivateName (requerido)

  • value: Expression (valor predeterminado: null)

  • decorators: Decorator[] (por defecto: null)

  • static: boolean (valor predeterminado: false)

  • definite: boolean (valor por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • readonly: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

  • variance: Variance (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, Property, Private

classProperty​

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

Consulta también t.isClassProperty(node, opts) y t.assertClassProperty(node, opts).

Forma del nodo AST ClassProperty:

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

  • value: Expression (valor predeterminado: null)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null)

  • decorators: Decorator[] (por defecto: null)

  • computed: boolean (por defecto: false)

  • static: boolean (valor predeterminado: false)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

  • accessibility: "public" | "private" | "protected" (por defecto: null, excluido de la función constructora)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • definite: boolean (valor por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • override: boolean (valor predeterminado: false, excluido de la función de construcción)

  • readonly: boolean (por defecto: null, excluido de la función constructora)

  • variance: Variance (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, Property

conditionalExpression​

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

Consulta también t.isConditionalExpression(node, opts) y t.assertConditionalExpression(node, opts).

Forma del nodo AST ConditionalExpression:

  • test: Expression (requerido)

  • consequent: Expression (requerido)

  • alternate: Expression (requerido)

Alias: Standardized, Expression, Conditional

continueStatement​

JavaScript
t.continueStatement(label);

Consulta también t.isContinueStatement(node, opts) y t.assertContinueStatement(node, opts).

Forma del nodo AST ContinueStatement:

  • label: Identifier (valor predeterminado: null)

Alias: Standardized, Statement, Terminatorless, CompletionStatement

debuggerStatement​

JavaScript
t.debuggerStatement();

Consulta también t.isDebuggerStatement(node, opts) y t.assertDebuggerStatement(node, opts).

Alias: Standardized, Statement

decimalLiteral​

JavaScript
t.decimalLiteral(value);

Ver también t.isDecimalLiteral(node, opts) y t.assertDecimalLiteral(node, opts).

Forma del nodo AST DecimalLiteral:

  • value: string (requerido)

Alias: Expression, Pureish, Literal, Immutable

declareClass​

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

Ver también t.isDeclareClass(node, opts) y t.assertDeclareClass(node, opts).

Forma del nodo AST DeclareClass:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • extends: InterfaceExtends[] (por defecto: null)

  • body: ObjectTypeAnnotation (requerido)

  • implements: ClassImplements[] (por defecto: null, excluido de la función de construcción)

  • mixins: InterfaceExtends[] (por defecto: null, excluido de la función de construcción)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareExportAllDeclaration​

JavaScript
t.declareExportAllDeclaration(source, attributes);

Ver también t.isDeclareExportAllDeclaration(node, opts) y t.assertDeclareExportAllDeclaration(node, opts).

Forma del nodo AST DeclareExportAllDeclaration:

  • source: StringLiteral (requerido)

  • attributes: ImportAttribute[] (por defecto: null)

  • assertions: ImportAttribute[] (por defecto: null, excluido de la función constructora)

  • exportKind: "type" | "value" (por defecto: null, excluido de la función builder)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareExportDeclaration​

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

Ver también t.isDeclareExportDeclaration(node, opts) y t.assertDeclareExportDeclaration(node, opts).

Forma del nodo AST DeclareExportDeclaration:

  • declaration: Flow (valor por defecto: null)

  • specifiers: (ExportSpecifier | ExportNamespaceSpecifier)[] (por defecto: null)

  • source: StringLiteral (valor por defecto: null)

  • attributes: ImportAttribute[] (por defecto: null)

  • assertions: ImportAttribute[] (por defecto: null, excluido de la función constructora)

  • default: boolean (valor por defecto: null, excluido de la función de construcción)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareFunction​

JavaScript
t.declareFunction(id);

Ver también t.isDeclareFunction(node, opts) y t.assertDeclareFunction(node, opts).

Forma del nodo AST DeclareFunction:

  • id: Identifier (requerido)

  • predicate: DeclaredPredicate (valor por defecto: null, excluido de la función de construcción)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareInterface​

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

Ver también t.isDeclareInterface(node, opts) y t.assertDeclareInterface(node, opts).

Forma del nodo AST DeclareInterface:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • extends: InterfaceExtends[] (por defecto: null)

  • body: ObjectTypeAnnotation (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareModule​

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

Ver también t.isDeclareModule(node, opts) y t.assertDeclareModule(node, opts).

Forma del nodo AST DeclareModule:

  • id: Identifier | StringLiteral (requerido)

  • body: BlockStatement (requerido)

  • kind: "CommonJS" | "ES" (valor por defecto: null)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareModuleExports​

JavaScript
t.declareModuleExports(typeAnnotation);

Ver también t.isDeclareModuleExports(node, opts) y t.assertDeclareModuleExports(node, opts).

Forma del nodo AST DeclareModuleExports:

  • typeAnnotation: TypeAnnotation (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareOpaqueType​

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

Ver también t.isDeclareOpaqueType(node, opts) y t.assertDeclareOpaqueType(node, opts).

Forma del nodo AST DeclareOpaqueType:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • supertype: FlowType (valor predeterminado: null)

  • impltype: FlowType (valor por defecto: null, excluido de la función constructora)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareTypeAlias​

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

Ver también t.isDeclareTypeAlias(node, opts) y t.assertDeclareTypeAlias(node, opts).

Forma del nodo AST DeclareTypeAlias:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • right: FlowType (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

declareVariable​

JavaScript
t.declareVariable(id);

Ver también t.isDeclareVariable(node, opts) y t.assertDeclareVariable(node, opts).

Forma del nodo AST DeclareVariable:

  • id: Identifier (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

declaredPredicate​

JavaScript
t.declaredPredicate(value);

Ver también t.isDeclaredPredicate(node, opts) y t.assertDeclaredPredicate(node, opts).

Estructura del nodo AST DeclaredPredicate:

  • value: Flow (requerido)

Alias: Flow, FlowPredicate

decorator​

JavaScript
t.decorator(expression);

Ver también t.isDecorator(node, opts) y t.assertDecorator(node, opts).

Estructura del nodo AST Decorator:

  • expression: Expression (requerido)

directive​

JavaScript
t.directive(value);

Ver también t.isDirective(node, opts) y t.assertDirective(node, opts).

Estructura del nodo AST Directive:

  • value: DirectiveLiteral (requerido)

Alias: Standardized

directiveLiteral​

JavaScript
t.directiveLiteral(value);

Ver también t.isDirectiveLiteral(node, opts) y t.assertDirectiveLiteral(node, opts).

Estructura del nodo AST DirectiveLiteral:

  • value: string (requerido)

Alias: Standardized

doExpression​

JavaScript
t.doExpression(body, async);

Ver también t.isDoExpression(node, opts) y t.assertDoExpression(node, opts).

Estructura del nodo AST DoExpression:

  • body: BlockStatement (requerido)

  • async: boolean (por defecto: false)

Alias: Expression

doWhileStatement​

JavaScript
t.doWhileStatement(test, body);

Ver también t.isDoWhileStatement(node, opts) y t.assertDoWhileStatement(node, opts).

Estructura del nodo AST DoWhileStatement:

  • test: Expression (requerido)

  • body: Statement (requerido)

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

emptyStatement​

JavaScript
t.emptyStatement();

Ver también t.isEmptyStatement(node, opts) y t.assertEmptyStatement(node, opts).

Alias: Standardized, Statement

emptyTypeAnnotation​

JavaScript
t.emptyTypeAnnotation();

Ver también t.isEmptyTypeAnnotation(node, opts) y t.assertEmptyTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

enumBooleanBody​

JavaScript
t.enumBooleanBody(members);

Ver también t.isEnumBooleanBody(node, opts) y t.assertEnumBooleanBody(node, opts).

Estructura del nodo AST EnumBooleanBody:

  • members: EnumBooleanMember[] (requerido)

  • explicitType: boolean (requerido)

  • hasUnknownMembers: boolean (requerido)

Alias: Flow, EnumBody

enumBooleanMember​

JavaScript
t.enumBooleanMember(id);

Ver también t.isEnumBooleanMember(node, opts) y t.assertEnumBooleanMember(node, opts).

Forma del nodo AST EnumBooleanMember:

  • id: Identifier (requerido)

  • init: BooleanLiteral (requerido)

Alias: Flow, EnumMember

enumDeclaration​

JavaScript
t.enumDeclaration(id, body);

Ver también t.isEnumDeclaration(node, opts) y t.assertEnumDeclaration(node, opts).

Forma del nodo AST EnumDeclaration:

  • id: Identifier (requerido)

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

Alias: Flow, Statement, Declaration

enumDefaultedMember​

JavaScript
t.enumDefaultedMember(id);

Ver también t.isEnumDefaultedMember(node, opts) y t.assertEnumDefaultedMember(node, opts).

Forma del nodo AST EnumDefaultedMember:

  • id: Identifier (requerido)

Alias: Flow, EnumMember

enumNumberBody​

JavaScript
t.enumNumberBody(members);

Ver también t.isEnumNumberBody(node, opts) y t.assertEnumNumberBody(node, opts).

Forma del nodo AST EnumNumberBody:

  • members: EnumNumberMember[] (requerido)

  • explicitType: boolean (requerido)

  • hasUnknownMembers: boolean (requerido)

Alias: Flow, EnumBody

enumNumberMember​

JavaScript
t.enumNumberMember(id, init);

Ver también t.isEnumNumberMember(node, opts) y t.assertEnumNumberMember(node, opts).

Forma del nodo AST EnumNumberMember:

  • id: Identifier (requerido)

  • init: NumericLiteral (requerido)

Alias: Flow, EnumMember

enumStringBody​

JavaScript
t.enumStringBody(members);

Ver también t.isEnumStringBody(node, opts) y t.assertEnumStringBody(node, opts).

Forma del nodo AST EnumStringBody:

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

  • explicitType: boolean (requerido)

  • hasUnknownMembers: boolean (requerido)

Alias: Flow, EnumBody

enumStringMember​

JavaScript
t.enumStringMember(id, init);

Ver también t.isEnumStringMember(node, opts) y t.assertEnumStringMember(node, opts).

Forma del nodo AST EnumStringMember:

  • id: Identifier (requerido)

  • init: StringLiteral (requerido)

Alias: Flow, EnumMember

enumSymbolBody​

JavaScript
t.enumSymbolBody(members);

Ver también t.isEnumSymbolBody(node, opts) y t.assertEnumSymbolBody(node, opts).

Forma del nodo AST EnumSymbolBody:

  • members: EnumDefaultedMember[] (requerido)

  • hasUnknownMembers: boolean (requerido)

Alias: Flow, EnumBody

existsTypeAnnotation​

JavaScript
t.existsTypeAnnotation();

Ver también t.isExistsTypeAnnotation(node, opts) y t.assertExistsTypeAnnotation(node, opts).

Alias: Flow, FlowType

exportAllDeclaration​

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

Ver también t.isExportAllDeclaration(node, opts) y t.assertExportAllDeclaration(node, opts).

Forma del nodo AST ExportAllDeclaration:

  • source: StringLiteral (requerido)

  • attributes: ImportAttribute[] (por defecto: null)

  • assertions: ImportAttribute[] (por defecto: null, excluido de la función constructora)

  • exportKind: "type" | "value" (por defecto: null, excluido de la función builder)

Alias: Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration

exportDefaultDeclaration​

JavaScript
t.exportDefaultDeclaration(declaration);

Ver también t.isExportDefaultDeclaration(node, opts) y t.assertExportDefaultDeclaration(node, opts).

Forma del nodo AST ExportDefaultDeclaration:

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

  • exportKind: "value" (valor por defecto: null, excluido de la función de construcción)

Alias: Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration

exportDefaultSpecifier​

JavaScript
t.exportDefaultSpecifier(exported);

Ver también t.isExportDefaultSpecifier(node, opts) y t.assertExportDefaultSpecifier(node, opts).

Forma del nodo AST ExportDefaultSpecifier:

  • exported: Identifier (requerido)

Alias: ModuleSpecifier

exportNamedDeclaration​

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

Ver también t.isExportNamedDeclaration(node, opts) y t.assertExportNamedDeclaration(node, opts).

Forma del nodo AST ExportNamedDeclaration:

  • declaration: Declaration (valor por defecto: null)

  • specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[] (por defecto: [])

  • source: StringLiteral (valor por defecto: null)

  • attributes: ImportAttribute[] (por defecto: null)

  • assertions: ImportAttribute[] (por defecto: null, excluido de la función constructora)

  • exportKind: "type" | "value" (por defecto: null, excluido de la función builder)

Alias: Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration

exportNamespaceSpecifier​

JavaScript
t.exportNamespaceSpecifier(exported);

Ver también t.isExportNamespaceSpecifier(node, opts) y t.assertExportNamespaceSpecifier(node, opts).

Forma del nodo AST ExportNamespaceSpecifier:

  • exported: Identifier (requerido)

Alias: Standardized, ModuleSpecifier

exportSpecifier​

JavaScript
t.exportSpecifier(local, exported);

Ver también t.isExportSpecifier(node, opts) y t.assertExportSpecifier(node, opts).

Forma del nodo AST ExportSpecifier:

  • local: Identifier (requerido)

  • exported: Identifier | StringLiteral (requerido)

  • exportKind: "type" | "value" (por defecto: null, excluido de la función builder)

Alias: Standardized, ModuleSpecifier

expressionStatement​

JavaScript
t.expressionStatement(expression);

Ver también t.isExpressionStatement(node, opts) y t.assertExpressionStatement(node, opts).

Forma del nodo AST ExpressionStatement:

  • expression: Expression (requerido)

Alias: Standardized, Statement, ExpressionWrapper

file​

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

Ver también t.isFile(node, opts) y t.assertFile(node, opts).

Forma del nodo AST File:

  • program: Program (requerido)

  • comments: (CommentBlock | CommentLine)[] (por defecto: null)

  • tokens: any[] (por defecto: null)

Alias: Standardized

forInStatement​

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

Ver también t.isForInStatement(node, opts) y t.assertForInStatement(node, opts).

Forma del nodo AST ForInStatement:

  • left: VariableDeclaration | LVal (requerido)

  • right: Expression (requerido)

  • body: Statement (requerido)

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

forOfStatement​

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

Ver también t.isForOfStatement(node, opts) y t.assertForOfStatement(node, opts).

Forma del nodo AST ForOfStatement:

  • left: VariableDeclaration | LVal (requerido)

  • right: Expression (requerido)

  • body: Statement (requerido)

  • await: boolean (por defecto: false)

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

forStatement​

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

Ver también t.isForStatement(node, opts) y t.assertForStatement(node, opts).

Estructura del nodo AST ForStatement:

  • init: VariableDeclaration | Expression (predeterminado: null)

  • test: Expression (por defecto: null)

  • update: Expression (predeterminado: null)

  • body: Statement (requerido)

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

functionDeclaration​

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

Ver también t.isFunctionDeclaration(node, opts) y t.assertFunctionDeclaration(node, opts).

Estructura del nodo AST FunctionDeclaration:

  • id: Identifier (por defecto: null)

  • params: FunctionParameter[] (requerido)

  • body: BlockStatement (requerido)

  • generator: boolean (por defecto: false)

  • async: boolean (por defecto: false)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • predicate: DeclaredPredicate | InferredPredicate (predeterminado: null, excluido de la función builder)

  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (por defecto: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

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

functionExpression​

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

Ver también t.isFunctionExpression(node, opts) y t.assertFunctionExpression(node, opts).

Estructura del nodo AST FunctionExpression:

  • id: Identifier (por defecto: null)

  • params: FunctionParameter[] (requerido)

  • body: BlockStatement (requerido)

  • generator: boolean (por defecto: false)

  • async: boolean (por defecto: false)

  • predicate: DeclaredPredicate | InferredPredicate (predeterminado: null, excluido de la función builder)

  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (por defecto: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

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

functionTypeAnnotation​

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

Ver también t.isFunctionTypeAnnotation(node, opts) y t.assertFunctionTypeAnnotation(node, opts).

Estructura del nodo AST FunctionTypeAnnotation:

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • params: FunctionTypeParam[] (requerido)

  • rest: FunctionTypeParam (por defecto: null)

  • returnType: FlowType (requerido)

  • this: FunctionTypeParam (por defecto: null, excluido de la función constructora)

Alias: Flow, FlowType

functionTypeParam​

JavaScript
t.functionTypeParam(name, typeAnnotation);

Ver también t.isFunctionTypeParam(node, opts) y t.assertFunctionTypeParam(node, opts).

Estructura del nodo AST FunctionTypeParam:

  • name: Identifier (por defecto: null)

  • typeAnnotation: FlowType (requerido)

  • optional: boolean (por defecto: null, excluido de la función constructora)

Alias: Flow

genericTypeAnnotation​

JavaScript
t.genericTypeAnnotation(id, typeParameters);

Ver también t.isGenericTypeAnnotation(node, opts) y t.assertGenericTypeAnnotation(node, opts).

Estructura del nodo AST GenericTypeAnnotation:

  • id: Identifier | QualifiedTypeIdentifier (requerido)

  • typeParameters: TypeParameterInstantiation (por defecto: null)

Alias: Flow, FlowType

identifier​

JavaScript
t.identifier(name);

Ver también t.isIdentifier(node, opts) y t.assertIdentifier(node, opts).

Estructura del nodo AST Identifier:

  • name: string (requerido)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

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

ifStatement​

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

Ver también t.isIfStatement(node, opts) y t.assertIfStatement(node, opts).

Estructura del nodo AST IfStatement:

  • test: Expression (requerido)

  • consequent: Statement (requerido)

  • alternate: Statement (por defecto: null)

Alias: Standardized, Statement, Conditional

import​

JavaScript
t.import();

Ver también t.isImport(node, opts) y t.assertImport(node, opts).

Alias: Standardized, Expression

importAttribute​

JavaScript
t.importAttribute(key, value);

Consulte también t.isImportAttribute(node, opts) y t.assertImportAttribute(node, opts).

Estructura del nodo AST ImportAttribute:

  • key: Identifier | StringLiteral (obligatorio)

  • value: StringLiteral (requerido)

Alias: Standardized

importDeclaration​

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

Consulte también t.isImportDeclaration(node, opts) y t.assertImportDeclaration(node, opts).

Estructura del nodo AST ImportDeclaration:

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

  • source: StringLiteral (requerido)

  • attributes: ImportAttribute[] (por defecto: null)

  • assertions: ImportAttribute[] (por defecto: null, excluido de la función constructora)

  • importKind: "type" | "typeof" | "value" (por defecto: null, excluido de la función builder)

  • module: boolean (por defecto: null, excluido de la función builder)

  • phase: "source" | "defer" (por defecto: null, excluido de la función builder)

Alias: Standardized, Statement, Declaration, ImportOrExportDeclaration

importDefaultSpecifier​

JavaScript
t.importDefaultSpecifier(local);

Consulte también t.isImportDefaultSpecifier(node, opts) y t.assertImportDefaultSpecifier(node, opts).

Estructura del nodo AST ImportDefaultSpecifier:

  • local: Identifier (requerido)

Alias: Standardized, ModuleSpecifier

importExpression​

JavaScript
t.importExpression(source, options);

Consulte también t.isImportExpression(node, opts) y t.assertImportExpression(node, opts).

Estructura del nodo AST ImportExpression:

  • source: Expression (requerido)

  • options: Expression (por defecto: null)

  • phase: "source" | "defer" (por defecto: null, excluido de la función builder)

Alias: Standardized, Expression

importNamespaceSpecifier​

JavaScript
t.importNamespaceSpecifier(local);

Consulte también t.isImportNamespaceSpecifier(node, opts) y t.assertImportNamespaceSpecifier(node, opts).

Estructura del nodo AST ImportNamespaceSpecifier:

  • local: Identifier (requerido)

Alias: Standardized, ModuleSpecifier

importSpecifier​

JavaScript
t.importSpecifier(local, imported);

Consulte también t.isImportSpecifier(node, opts) y t.assertImportSpecifier(node, opts).

Estructura del nodo AST ImportSpecifier:

  • local: Identifier (requerido)

  • imported: Identifier | StringLiteral (requerido)

  • importKind: "type" | "typeof" | "value" (por defecto: null, excluido de la función builder)

Alias: Standardized, ModuleSpecifier

indexedAccessType​

JavaScript
t.indexedAccessType(objectType, indexType);

Consulta también t.isIndexedAccessType(node, opts) y t.assertIndexedAccessType(node, opts).

Forma del nodo AST IndexedAccessType:

  • objectType: FlowType (requerido)

  • indexType: FlowType (requerido)

Alias: Flow, FlowType

inferredPredicate​

JavaScript
t.inferredPredicate();

Consulta también t.isInferredPredicate(node, opts) y t.assertInferredPredicate(node, opts).

Alias: Flow, FlowPredicate

interfaceDeclaration​

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

Consulta también t.isInterfaceDeclaration(node, opts) y t.assertInterfaceDeclaration(node, opts).

Forma del nodo AST InterfaceDeclaration:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • extends: InterfaceExtends[] (por defecto: null)

  • body: ObjectTypeAnnotation (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

interfaceExtends​

JavaScript
t.interfaceExtends(id, typeParameters);

Consulta también t.isInterfaceExtends(node, opts) y t.assertInterfaceExtends(node, opts).

Forma del nodo AST InterfaceExtends:

  • id: Identifier | QualifiedTypeIdentifier (requerido)

  • typeParameters: TypeParameterInstantiation (por defecto: null)

Alias: Flow

interfaceTypeAnnotation​

JavaScript
t.interfaceTypeAnnotation(extends, body);

Consulta también t.isInterfaceTypeAnnotation(node, opts) y t.assertInterfaceTypeAnnotation(node, opts).

Forma del nodo AST InterfaceTypeAnnotation:

  • extends: InterfaceExtends[] (por defecto: null)

  • body: ObjectTypeAnnotation (requerido)

Alias: Flow, FlowType

interpreterDirective​

JavaScript
t.interpreterDirective(value);

Consulta también t.isInterpreterDirective(node, opts) y t.assertInterpreterDirective(node, opts).

Forma del nodo AST InterpreterDirective:

  • value: string (requerido)

Alias: Standardized

intersectionTypeAnnotation​

JavaScript
t.intersectionTypeAnnotation(types);

Consulta también t.isIntersectionTypeAnnotation(node, opts) y t.assertIntersectionTypeAnnotation(node, opts).

Forma del nodo AST IntersectionTypeAnnotation:

  • types: FlowType[] (requerido)

Alias: Flow, FlowType

jsxAttribute​

JavaScript
t.jsxAttribute(name, value);

Consulta también t.isJSXAttribute(node, opts) y t.assertJSXAttribute(node, opts).

Forma del nodo AST JSXAttribute:

  • name: JSXIdentifier | JSXNamespacedName (requerido)

  • value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer (valor predeterminado: null)

Alias: JSX, Immutable

jsxClosingElement​

JavaScript
t.jsxClosingElement(name);

Véase también t.isJSXClosingElement(node, opts) y t.assertJSXClosingElement(node, opts).

Forma del nodo AST JSXClosingElement:

  • name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName (requerido)

Alias: JSX, Immutable

jsxClosingFragment​

JavaScript
t.jsxClosingFragment();

Véase también t.isJSXClosingFragment(node, opts) y t.assertJSXClosingFragment(node, opts).

Alias: JSX, Immutable

jsxElement​

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

Véase también t.isJSXElement(node, opts) y t.assertJSXElement(node, opts).

Forma del nodo AST JSXElement:

  • openingElement: JSXOpeningElement (requerido)

  • closingElement: JSXClosingElement (valor predeterminado: null)

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

  • selfClosing: boolean (valor predeterminado: null)

Alias: JSX, Immutable, Expression

jsxEmptyExpression​

JavaScript
t.jsxEmptyExpression();

Véase también t.isJSXEmptyExpression(node, opts) y t.assertJSXEmptyExpression(node, opts).

Alias: JSX

jsxExpressionContainer​

JavaScript
t.jsxExpressionContainer(expression);

Véase también t.isJSXExpressionContainer(node, opts) y t.assertJSXExpressionContainer(node, opts).

Forma del nodo AST JSXExpressionContainer:

  • expression: Expression | JSXEmptyExpression (requerido)

Alias: JSX, Immutable

jsxFragment​

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

Véase también t.isJSXFragment(node, opts) y t.assertJSXFragment(node, opts).

Forma del nodo AST JSXFragment:

  • openingFragment: JSXOpeningFragment (requerido)

  • closingFragment: JSXClosingFragment (requerido)

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

Alias: JSX, Immutable, Expression

jsxIdentifier​

JavaScript
t.jsxIdentifier(name);

Véase también t.isJSXIdentifier(node, opts) y t.assertJSXIdentifier(node, opts).

Forma del nodo AST JSXIdentifier:

  • name: string (requerido)

Alias: JSX

jsxMemberExpression​

JavaScript
t.jsxMemberExpression(object, property);

Ver también t.isJSXMemberExpression(node, opts) y t.assertJSXMemberExpression(node, opts).

Estructura del nodo AST JSXMemberExpression:

  • object: JSXMemberExpression | JSXIdentifier (requerido)

  • property: JSXIdentifier (requerido)

Alias: JSX

jsxNamespacedName​

JavaScript
t.jsxNamespacedName(namespace, name);

Ver también t.isJSXNamespacedName(node, opts) y t.assertJSXNamespacedName(node, opts).

Estructura del nodo AST JSXNamespacedName:

  • namespace: JSXIdentifier (requerido)

  • name: JSXIdentifier (requerido)

Alias: JSX

jsxOpeningElement​

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

Ver también t.isJSXOpeningElement(node, opts) y t.assertJSXOpeningElement(node, opts).

Estructura del nodo AST JSXOpeningElement:

  • name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName (requerido)

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

  • selfClosing: boolean (por defecto: false)

  • typeArguments: TypeParameterInstantiation (por defecto: null, excluido de la función constructora)

  • typeParameters: TSTypeParameterInstantiation (por defecto: null, excluido de la función constructora)

Alias: JSX, Immutable

jsxOpeningFragment​

JavaScript
t.jsxOpeningFragment();

Ver también t.isJSXOpeningFragment(node, opts) y t.assertJSXOpeningFragment(node, opts).

Alias: JSX, Immutable

jsxSpreadAttribute​

JavaScript
t.jsxSpreadAttribute(argument);

Ver también t.isJSXSpreadAttribute(node, opts) y t.assertJSXSpreadAttribute(node, opts).

Estructura del nodo AST JSXSpreadAttribute:

  • argument: Expression (requerido)

Alias: JSX

jsxSpreadChild​

JavaScript
t.jsxSpreadChild(expression);

Ver también t.isJSXSpreadChild(node, opts) y t.assertJSXSpreadChild(node, opts).

Estructura del nodo AST JSXSpreadChild:

  • expression: Expression (requerido)

Alias: JSX, Immutable

jsxText​

JavaScript
t.jsxText(value);

Ver también t.isJSXText(node, opts) y t.assertJSXText(node, opts).

Estructura del nodo AST JSXText:

  • value: string (requerido)

Alias: JSX, Immutable

labeledStatement​

JavaScript
t.labeledStatement(label, body);

Ver también t.isLabeledStatement(node, opts) y t.assertLabeledStatement(node, opts).

Estructura del nodo AST LabeledStatement:

  • label: Identifier (requerido)

  • body: Statement (requerido)

Alias: Standardized, Statement

logicalExpression​

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

Ver también t.isLogicalExpression(node, opts) y t.assertLogicalExpression(node, opts).

Forma del nodo AST LogicalExpression:

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

  • left: Expression (requerido)

  • right: Expression (requerido)

Alias: Standardized, Binary, Expression

memberExpression​

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

Ver también t.isMemberExpression(node, opts) y t.assertMemberExpression(node, opts).

Forma del nodo AST MemberExpression:

  • object: Expression | Super (requerido)

  • property: si es computada Expression, si no Identifier (required)

  • computed: boolean (por defecto: false)

  • optional: boolean (por defecto: null)

Alias: Standardized, Expression, LVal, PatternLike

metaProperty​

JavaScript
t.metaProperty(meta, property);

Ver también t.isMetaProperty(node, opts) y t.assertMetaProperty(node, opts).

Forma del nodo AST MetaProperty:

  • meta: Identifier (requerido)

  • property: Identifier (requerido)

Alias: Standardized, Expression

mixedTypeAnnotation​

JavaScript
t.mixedTypeAnnotation();

Ver también t.isMixedTypeAnnotation(node, opts) y t.assertMixedTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

moduleExpression​

JavaScript
t.moduleExpression(body);

Ver también t.isModuleExpression(node, opts) y t.assertModuleExpression(node, opts).

Forma del nodo AST ModuleExpression:

  • body: Program (requerido)

Alias: Expression

newExpression​

JavaScript
t.newExpression(callee, arguments);

Ver también t.isNewExpression(node, opts) y t.assertNewExpression(node, opts).

Forma del nodo AST NewExpression:

  • callee: Expression | Super | V8IntrinsicIdentifier (requerido)

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

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeArguments: TypeParameterInstantiation (por defecto: null, excluido de la función constructora)

  • typeParameters: TSTypeParameterInstantiation (por defecto: null, excluido de la función constructora)

Alias: Standardized, Expression

noop​

JavaScript
t.noop();

Ver también t.isNoop(node, opts) y t.assertNoop(node, opts).

Alias: Miscellaneous

nullLiteral​

JavaScript
t.nullLiteral();

Ver también t.isNullLiteral(node, opts) y t.assertNullLiteral(node, opts).

Alias: Standardized, Expression, Pureish, Literal, Immutable

nullLiteralTypeAnnotation​

JavaScript
t.nullLiteralTypeAnnotation();

Ver también t.isNullLiteralTypeAnnotation(node, opts) y t.assertNullLiteralTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

nullableTypeAnnotation​

JavaScript
t.nullableTypeAnnotation(typeAnnotation);

Ver también t.isNullableTypeAnnotation(node, opts) y t.assertNullableTypeAnnotation(node, opts).

Estructura del nodo AST NullableTypeAnnotation:

  • typeAnnotation: FlowType (requerido)

Alias: Flow, FlowType

numberLiteralTypeAnnotation​

JavaScript
t.numberLiteralTypeAnnotation(value);

Ver también t.isNumberLiteralTypeAnnotation(node, opts) y t.assertNumberLiteralTypeAnnotation(node, opts).

Estructura del nodo AST NumberLiteralTypeAnnotation:

  • value: number (requerido)

Alias: Flow, FlowType

numberTypeAnnotation​

JavaScript
t.numberTypeAnnotation();

Ver también t.isNumberTypeAnnotation(node, opts) y t.assertNumberTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

numericLiteral​

JavaScript
t.numericLiteral(value);

Ver también t.isNumericLiteral(node, opts) y t.assertNumericLiteral(node, opts).

Estructura del nodo AST NumericLiteral:

  • value: un number finito no negativo (requerido)

Alias: Standardized, Expression, Pureish, Literal, Immutable

objectExpression​

JavaScript
t.objectExpression(properties);

Ver también t.isObjectExpression(node, opts) y t.assertObjectExpression(node, opts).

Estructura del nodo AST ObjectExpression:

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

Alias: Standardized, Expression

objectMethod​

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

Ver también t.isObjectMethod(node, opts) y t.assertObjectMethod(node, opts).

Estructura del nodo AST ObjectMethod:

  • kind: "method" | "get" | "set" (predeterminado: 'method')

  • key: si es computada entonces Expression si no Identifier | Literal (requerido)

  • params: FunctionParameter[] (requerido)

  • body: BlockStatement (requerido)

  • computed: boolean (por defecto: false)

  • generator: boolean (por defecto: false)

  • async: boolean (por defecto: false)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (por defecto: null, excluido de la función de construcción)

  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (por defecto: null, excluido de la función de construcción)

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

objectPattern​

JavaScript
t.objectPattern(properties);

Ver también t.isObjectPattern(node, opts) y t.assertObjectPattern(node, opts).

Estructura del nodo AST ObjectPattern:

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

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, FunctionParameter, Pattern, PatternLike, LVal

objectProperty​

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

Ver también t.isObjectProperty(node, opts) y t.assertObjectProperty(node, opts).

Estructura del nodo AST ObjectProperty:

  • key: si es computada entonces Expression si no Identifier | Literal (requerido)

  • value: Expression | PatternLike (requerido)

  • computed: boolean (por defecto: false)

  • shorthand: boolean (por defecto: false)

  • decorators: Decorator[] (por defecto: null)

Alias: Standardized, UserWhitespacable, Property, ObjectMember

objectTypeAnnotation​

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

Ver también t.isObjectTypeAnnotation(node, opts) y t.assertObjectTypeAnnotation(node, opts).

Estructura del nodo AST ObjectTypeAnnotation:

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

  • indexers: ObjectTypeIndexer[] (por defecto: [])

  • callProperties: ObjectTypeCallProperty[] (por defecto: [])

  • internalSlots: ObjectTypeInternalSlot[] (por defecto: [])

  • exact: boolean (por defecto: false)

  • inexact: boolean (por defecto: null, excluido de la función de construcción)

Alias: Flow, FlowType

objectTypeCallProperty​

JavaScript
t.objectTypeCallProperty(value);

Ver también t.isObjectTypeCallProperty(node, opts) y t.assertObjectTypeCallProperty(node, opts).

Forma del nodo AST ObjectTypeCallProperty:

  • value: FlowType (obligatorio)

  • static: boolean (obligatorio)

Alias: Flow, UserWhitespacable

objectTypeIndexer​

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

Ver también t.isObjectTypeIndexer(node, opts) y t.assertObjectTypeIndexer(node, opts).

Forma del nodo AST ObjectTypeIndexer:

  • id: Identifier (por defecto: null)

  • key: FlowType (obligatorio)

  • value: FlowType (obligatorio)

  • variance: Variance (valor por defecto: null)

  • static: boolean (obligatorio)

Alias: Flow, UserWhitespacable

objectTypeInternalSlot​

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

Ver también t.isObjectTypeInternalSlot(node, opts) y t.assertObjectTypeInternalSlot(node, opts).

Forma del nodo AST ObjectTypeInternalSlot:

  • id: Identifier (requerido)

  • value: FlowType (obligatorio)

  • optional: boolean (requerido)

  • static: boolean (obligatorio)

  • method: boolean (obligatorio)

Alias: Flow, UserWhitespacable

objectTypeProperty​

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

Ver también t.isObjectTypeProperty(node, opts) y t.assertObjectTypeProperty(node, opts).

Forma del nodo AST ObjectTypeProperty:

  • key: Identifier | StringLiteral (obligatorio)

  • value: FlowType (obligatorio)

  • variance: Variance (valor por defecto: null)

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

  • method: boolean (obligatorio)

  • optional: boolean (requerido)

  • proto: boolean (obligatorio)

  • static: boolean (obligatorio)

Alias: Flow, UserWhitespacable

objectTypeSpreadProperty​

JavaScript
t.objectTypeSpreadProperty(argument);

Ver también t.isObjectTypeSpreadProperty(node, opts) y t.assertObjectTypeSpreadProperty(node, opts).

Forma del nodo AST ObjectTypeSpreadProperty:

  • argument: FlowType (requerido)

Alias: Flow, UserWhitespacable

opaqueType​

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

Ver también t.isOpaqueType(node, opts) y t.assertOpaqueType(node, opts).

Forma del nodo AST OpaqueType:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • supertype: FlowType (valor predeterminado: null)

  • impltype: FlowType (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

optionalCallExpression​

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

Consulta también t.isOptionalCallExpression(node, opts) y t.assertOptionalCallExpression(node, opts).

Forma del nodo AST OptionalCallExpression:

  • callee: Expression (requerido)

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

  • optional: boolean (requerido)

  • typeArguments: TypeParameterInstantiation (por defecto: null, excluido de la función constructora)

  • typeParameters: TSTypeParameterInstantiation (por defecto: null, excluido de la función constructora)

Alias: Standardized, Expression

optionalIndexedAccessType​

JavaScript
t.optionalIndexedAccessType(objectType, indexType);

Consulta también t.isOptionalIndexedAccessType(node, opts) y t.assertOptionalIndexedAccessType(node, opts).

Forma del nodo AST OptionalIndexedAccessType:

  • objectType: FlowType (requerido)

  • indexType: FlowType (requerido)

  • optional: boolean (requerido)

Alias: Flow, FlowType

optionalMemberExpression​

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

Consulta también t.isOptionalMemberExpression(node, opts) y t.assertOptionalMemberExpression(node, opts).

Forma del nodo AST OptionalMemberExpression:

  • object: Expression (requerido)

  • property: Expression | Identifier (requerido)

  • computed: boolean (por defecto: false)

  • optional: boolean (requerido)

Alias: Standardized, Expression

parenthesizedExpression​

JavaScript
t.parenthesizedExpression(expression);

Consulta también t.isParenthesizedExpression(node, opts) y t.assertParenthesizedExpression(node, opts).

Forma del nodo AST ParenthesizedExpression:

  • expression: Expression (requerido)

Alias: Standardized, Expression, ExpressionWrapper

pipelineBareFunction​

JavaScript
t.pipelineBareFunction(callee);

Consulta también t.isPipelineBareFunction(node, opts) y t.assertPipelineBareFunction(node, opts).

Forma del nodo AST PipelineBareFunction:

  • callee: Expression (requerido)

Alias: Expression

pipelinePrimaryTopicReference​

JavaScript
t.pipelinePrimaryTopicReference();

Consulta también t.isPipelinePrimaryTopicReference(node, opts) y t.assertPipelinePrimaryTopicReference(node, opts).

Alias: Expression

pipelineTopicExpression​

JavaScript
t.pipelineTopicExpression(expression);

Consulta también t.isPipelineTopicExpression(node, opts) y t.assertPipelineTopicExpression(node, opts).

Forma del nodo AST PipelineTopicExpression:

  • expression: Expression (requerido)

Alias: Expression

placeholder​

JavaScript
t.placeholder(expectedNode, name);

Véase también t.isPlaceholder(node, opts) y t.assertPlaceholder(node, opts).

Forma del nodo AST Placeholder:

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

  • name: Identifier (requerido)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

Alias: Miscellaneous

privateName​

JavaScript
t.privateName(id);

Véase también t.isPrivateName(node, opts) y t.assertPrivateName(node, opts).

Forma del nodo AST PrivateName:

  • id: Identifier (requerido)

Alias: Standardized, Private

program​

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

Véase también t.isProgram(node, opts) y t.assertProgram(node, opts).

Forma del nodo AST Program:

  • body: Statement[] (requerido)

  • directives: Directive[] (por defecto: [])

  • sourceType: "script" | "module" (por defecto: 'script')

  • interpreter: InterpreterDirective (por defecto: null)

Alias: Standardized, Scopable, BlockParent, Block

qualifiedTypeIdentifier​

JavaScript
t.qualifiedTypeIdentifier(id, qualification);

Véase también t.isQualifiedTypeIdentifier(node, opts) y t.assertQualifiedTypeIdentifier(node, opts).

Forma del nodo AST QualifiedTypeIdentifier:

  • id: Identifier (requerido)

  • qualification: Identifier | QualifiedTypeIdentifier (requerido)

Alias: Flow

recordExpression​

JavaScript
t.recordExpression(properties);

Véase también t.isRecordExpression(node, opts) y t.assertRecordExpression(node, opts).

Forma del nodo AST RecordExpression:

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

Alias: Expression

regExpLiteral​

JavaScript
t.regExpLiteral(pattern, flags);

Véase también t.isRegExpLiteral(node, opts) y t.assertRegExpLiteral(node, opts).

Forma del nodo AST RegExpLiteral:

  • pattern: string (requerido)

  • flags: string (por defecto: '')

Alias: Standardized, Expression, Pureish, Literal

restElement​

JavaScript
t.restElement(argument);

Ver también t.isRestElement(node, opts) y t.assertRestElement(node, opts).

Forma del nodo AST RestElement:

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

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (valor predeterminado: null, excluido de la función de construcción)

Alias: Standardized, FunctionParameter, PatternLike, LVal

returnStatement​

JavaScript
t.returnStatement(argument);

Ver también t.isReturnStatement(node, opts) y t.assertReturnStatement(node, opts).

Forma del nodo AST ReturnStatement:

  • argument: Expression (valor por defecto: null)

Alias: Standardized, Statement, Terminatorless, CompletionStatement

sequenceExpression​

JavaScript
t.sequenceExpression(expressions);

Ver también t.isSequenceExpression(node, opts) y t.assertSequenceExpression(node, opts).

Forma del nodo AST SequenceExpression:

  • expressions: Expression[] (requerido)

Alias: Standardized, Expression

spreadElement​

JavaScript
t.spreadElement(argument);

Ver también t.isSpreadElement(node, opts) y t.assertSpreadElement(node, opts).

Forma del nodo AST SpreadElement:

  • argument: Expression (requerido)

Alias: Standardized, UnaryLike

staticBlock​

JavaScript
t.staticBlock(body);

Ver también t.isStaticBlock(node, opts) y t.assertStaticBlock(node, opts).

Forma del nodo AST StaticBlock:

  • body: Statement[] (requerido)

Alias: Standardized, Scopable, BlockParent, FunctionParent

stringLiteral​

JavaScript
t.stringLiteral(value);

Ver también t.isStringLiteral(node, opts) y t.assertStringLiteral(node, opts).

Forma del nodo AST StringLiteral:

  • value: string (requerido)

Alias: Standardized, Expression, Pureish, Literal, Immutable

stringLiteralTypeAnnotation​

JavaScript
t.stringLiteralTypeAnnotation(value);

Ver también t.isStringLiteralTypeAnnotation(node, opts) y t.assertStringLiteralTypeAnnotation(node, opts).

Forma del nodo AST StringLiteralTypeAnnotation:

  • value: string (requerido)

Alias: Flow, FlowType

stringTypeAnnotation​

JavaScript
t.stringTypeAnnotation();

Consulta también t.isStringTypeAnnotation(node, opts) y t.assertStringTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

super​

JavaScript
t.super();

Consulta también t.isSuper(node, opts) y t.assertSuper(node, opts).

Alias: Standardized, Expression

switchCase​

JavaScript
t.switchCase(test, consequent);

Consulta también t.isSwitchCase(node, opts) y t.assertSwitchCase(node, opts).

Estructura del nodo AST SwitchCase:

  • test: Expression (por defecto: null)

  • consequent: Statement[] (requerido)

Alias: Standardized

switchStatement​

JavaScript
t.switchStatement(discriminant, cases);

Consulta también t.isSwitchStatement(node, opts) y t.assertSwitchStatement(node, opts).

Estructura del nodo AST SwitchStatement:

  • discriminant: Expression (requerido)

  • cases: SwitchCase[] (requerido)

Alias: Standardized, Statement, BlockParent, Scopable

symbolTypeAnnotation​

JavaScript
t.symbolTypeAnnotation();

Consulta también t.isSymbolTypeAnnotation(node, opts) y t.assertSymbolTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

tsAnyKeyword​

JavaScript
t.tsAnyKeyword();

Consulta también t.isTSAnyKeyword(node, opts) y t.assertTSAnyKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsArrayType​

JavaScript
t.tsArrayType(elementType);

Consulta también t.isTSArrayType(node, opts) y t.assertTSArrayType(node, opts).

Estructura del nodo AST TSArrayType:

  • elementType: TSType (requerido)

Alias: TypeScript, TSType

tsAsExpression​

JavaScript
t.tsAsExpression(expression, typeAnnotation);

Consulta también t.isTSAsExpression(node, opts) y t.assertTSAsExpression(node, opts).

Estructura del nodo AST TSAsExpression:

  • expression: Expression (requerido)

  • typeAnnotation: TSType (requerido)

Alias: TypeScript, Expression, LVal, PatternLike

tsBigIntKeyword​

JavaScript
t.tsBigIntKeyword();

Consulta también t.isTSBigIntKeyword(node, opts) y t.assertTSBigIntKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsBooleanKeyword​

JavaScript
t.tsBooleanKeyword();

Ver también t.isTSBooleanKeyword(node, opts) y t.assertTSBooleanKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsCallSignatureDeclaration​

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

Ver también t.isTSCallSignatureDeclaration(node, opts) y t.assertTSCallSignatureDeclaration(node, opts).

Estructura del nodo AST TSCallSignatureDeclaration:

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

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

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

Alias: TypeScript, TSTypeElement

tsConditionalType​

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

Ver también t.isTSConditionalType(node, opts) y t.assertTSConditionalType(node, opts).

Estructura del nodo AST TSConditionalType:

  • checkType: TSType (obligatorio)

  • extendsType: TSType (obligatorio)

  • trueType: TSType (obligatorio)

  • falseType: TSType (obligatorio)

Alias: TypeScript, TSType

tsConstructSignatureDeclaration​

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

Ver también t.isTSConstructSignatureDeclaration(node, opts) y t.assertTSConstructSignatureDeclaration(node, opts).

Estructura del nodo AST TSConstructSignatureDeclaration:

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

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

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

Alias: TypeScript, TSTypeElement

tsConstructorType​

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

Ver también t.isTSConstructorType(node, opts) y t.assertTSConstructorType(node, opts).

Estructura del nodo AST TSConstructorType:

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

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

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

Alias: TypeScript, TSType

tsDeclareFunction​

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

Ver también t.isTSDeclareFunction(node, opts) y t.assertTSDeclareFunction(node, opts).

Estructura del nodo AST TSDeclareFunction:

  • id: Identifier (por defecto: null)

  • typeParameters: TSTypeParameterDeclaration | Noop (valor predeterminado: null)

  • params: FunctionParameter[] (requerido)

  • returnType: TSTypeAnnotation | Noop (valor predeterminado: null)

  • async: boolean (valor predeterminado: false, excluido de la función de construcción)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • generator: boolean (valor predeterminado: false, excluido de la función de construcción)

Alias: TypeScript, Statement, Declaration

tsDeclareMethod​

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

Ver también t.isTSDeclareMethod(node, opts) y t.assertTSDeclareMethod(node, opts).

Estructura del nodo AST TSDeclareMethod:

  • decorators: Decorator[] (por defecto: null)

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

  • typeParameters: TSTypeParameterDeclaration | Noop (valor predeterminado: null)

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

  • returnType: TSTypeAnnotation | Noop (valor predeterminado: null)

  • abstract: boolean (valor predeterminado: null, excluido de la función de construcción)

  • access: "public" | "private" | "protected" (valor predeterminado: null, excluido de la función de construcción)

  • accessibility: "public" | "private" | "protected" (por defecto: null, excluido de la función constructora)

  • async: boolean (valor predeterminado: false, excluido de la función de construcción)

  • computed: boolean (por defecto: false, excluido de la función constructora)

  • generator: boolean (valor predeterminado: false, excluido de la función de construcción)

  • kind: "get" | "set" | "method" | "constructor" (valor predeterminado: 'method', excluido de la función de construcción)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • override: boolean (valor predeterminado: false, excluido de la función de construcción)

  • static: boolean (valor predeterminado: false, excluido de la función de construcción)

Alias: TypeScript

tsEnumBody​

JavaScript
t.tsEnumBody(members);

Ver también t.isTSEnumBody(node, opts) y t.assertTSEnumBody(node, opts).

Estructura del nodo AST TSEnumBody:

  • members: TSEnumMember[] (requerido)

Alias: TypeScript

tsEnumDeclaration​

JavaScript
t.tsEnumDeclaration(id, members);

Ver también t.isTSEnumDeclaration(node, opts) y t.assertTSEnumDeclaration(node, opts).

Estructura del nodo AST TSEnumDeclaration:

  • id: Identifier (requerido)

  • members: TSEnumMember[] (requerido)

  • body: TSEnumBody (valor predeterminado: null, excluido de la función de construcción)

  • const: boolean (valor por defecto: null, excluido de la función constructora)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • initializer: Expression (valor predeterminado: null, excluido de la función de construcción)

Alias: TypeScript, Statement, Declaration

tsEnumMember​

JavaScript
t.tsEnumMember(id, initializer);

Ver también t.isTSEnumMember(node, opts) y t.assertTSEnumMember(node, opts).

Estructura del nodo AST TSEnumMember:

  • id: Identifier | StringLiteral (requerido)

  • initializer: Expression (valor predeterminado: null)

Alias: TypeScript

tsExportAssignment​

JavaScript
t.tsExportAssignment(expression);

Ver también t.isTSExportAssignment(node, opts) y t.assertTSExportAssignment(node, opts).

Estructura del nodo AST TSExportAssignment:

  • expression: Expression (requerido)

Alias: TypeScript, Statement

tsExpressionWithTypeArguments​

JavaScript
t.tsExpressionWithTypeArguments(expression, typeParameters);

Ver también t.isTSExpressionWithTypeArguments(node, opts) y t.assertTSExpressionWithTypeArguments(node, opts).

Estructura del nodo AST TSExpressionWithTypeArguments:

  • expression: TSEntityName (requerido)

  • typeParameters: TSTypeParameterInstantiation (predeterminado: null)

Alias: TypeScript, TSType

tsExternalModuleReference​

JavaScript
t.tsExternalModuleReference(expression);

Ver también t.isTSExternalModuleReference(node, opts) y t.assertTSExternalModuleReference(node, opts).

Estructura del nodo AST TSExternalModuleReference:

  • expression: StringLiteral (requerido)

Alias: TypeScript

tsFunctionType​

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

Ver también t.isTSFunctionType(node, opts) y t.assertTSFunctionType(node, opts).

Estructura del nodo AST TSFunctionType:

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

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

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

Alias: TypeScript, TSType

tsImportEqualsDeclaration​

JavaScript
t.tsImportEqualsDeclaration(id, moduleReference);

Ver también t.isTSImportEqualsDeclaration(node, opts) y t.assertTSImportEqualsDeclaration(node, opts).

Estructura del nodo AST TSImportEqualsDeclaration:

  • id: Identifier (requerido)

  • moduleReference: TSEntityName | TSExternalModuleReference (requerido)

  • importKind: "type" | "value" (valor predeterminado: null, excluido de la función constructora)

  • isExport: boolean (requerido)

Alias: TypeScript, Statement, Declaration

tsImportType​

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

Ver también t.isTSImportType(node, opts) y t.assertTSImportType(node, opts).

Estructura del nodo AST TSImportType:

  • argument: StringLiteral (requerido)

  • qualifier: TSEntityName (por defecto: null)

  • typeParameters: TSTypeParameterInstantiation (predeterminado: null)

  • options: ObjectExpression (por defecto: null, excluido de la función constructora)

Alias: TypeScript, TSType

tsIndexSignature​

JavaScript
t.tsIndexSignature(parameters, typeAnnotation);

Ver también t.isTSIndexSignature(node, opts) y t.assertTSIndexSignature(node, opts).

Forma del nodo AST TSIndexSignature:

  • parameters: Identifier[] (requerido)

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

  • readonly: boolean (por defecto: null, excluido de la función constructora)

  • static: boolean (por defecto: null, excluido de la función constructora)

Alias: TypeScript, TSTypeElement

tsIndexedAccessType​

JavaScript
t.tsIndexedAccessType(objectType, indexType);

Ver también t.isTSIndexedAccessType(node, opts) y t.assertTSIndexedAccessType(node, opts).

Forma del nodo AST TSIndexedAccessType:

  • objectType: TSType (requerido)

  • indexType: TSType (requerido)

Alias: TypeScript, TSType

tsInferType​

JavaScript
t.tsInferType(typeParameter);

Ver también t.isTSInferType(node, opts) y t.assertTSInferType(node, opts).

Forma del nodo AST TSInferType:

  • typeParameter: TSTypeParameter (requerido)

Alias: TypeScript, TSType

tsInstantiationExpression​

JavaScript
t.tsInstantiationExpression(expression, typeParameters);

Ver también t.isTSInstantiationExpression(node, opts) y t.assertTSInstantiationExpression(node, opts).

Forma del nodo AST TSInstantiationExpression:

  • expression: Expression (requerido)

  • typeParameters: TSTypeParameterInstantiation (predeterminado: null)

Alias: TypeScript, Expression

tsInterfaceBody​

JavaScript
t.tsInterfaceBody(body);

Ver también t.isTSInterfaceBody(node, opts) y t.assertTSInterfaceBody(node, opts).

Forma del nodo AST TSInterfaceBody:

  • body: TSTypeElement[] (requerido)

Alias: TypeScript

tsInterfaceDeclaration​

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

Ver también t.isTSInterfaceDeclaration(node, opts) y t.assertTSInterfaceDeclaration(node, opts).

Forma del nodo AST TSInterfaceDeclaration:

  • id: Identifier (requerido)

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

  • extends: TSExpressionWithTypeArguments[] (por defecto: null)

  • body: TSInterfaceBody (requerido)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

Alias: TypeScript, Statement, Declaration

tsIntersectionType​

JavaScript
t.tsIntersectionType(types);

Véase también t.isTSIntersectionType(node, opts) y t.assertTSIntersectionType(node, opts).

Forma del nodo AST TSIntersectionType:

  • types: TSType[] (requerido)

Alias: TypeScript, TSType

tsIntrinsicKeyword​

JavaScript
t.tsIntrinsicKeyword();

Véase también t.isTSIntrinsicKeyword(node, opts) y t.assertTSIntrinsicKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsLiteralType​

JavaScript
t.tsLiteralType(literal);

Véase también t.isTSLiteralType(node, opts) y t.assertTSLiteralType(node, opts).

Forma del nodo AST TSLiteralType:

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

Alias: TypeScript, TSType, TSBaseType

tsMappedType​

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

Véase también t.isTSMappedType(node, opts) y t.assertTSMappedType(node, opts).

Forma del nodo AST TSMappedType:

  • typeParameter: TSTypeParameter (requerido)

  • typeAnnotation: TSType (predeterminado: null)

  • nameType: TSType (predeterminado: null)

  • optional: true | false | "+" | "-" (predeterminado: null, excluido de la función de construcción)

  • readonly: true | false | "+" | "-" (predeterminado: null, excluido de la función de construcción)

Alias: TypeScript, TSType

tsMethodSignature​

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

Véase también t.isTSMethodSignature(node, opts) y t.assertTSMethodSignature(node, opts).

Forma del nodo AST TSMethodSignature:

  • key: Expression (requerido)

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

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

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

  • computed: boolean (por defecto: false, excluido de la función constructora)

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

  • optional: boolean (por defecto: null, excluido de la función constructora)

Alias: TypeScript, TSTypeElement

tsModuleBlock​

JavaScript
t.tsModuleBlock(body);

Véase también t.isTSModuleBlock(node, opts) y t.assertTSModuleBlock(node, opts).

Estructura del nodo AST TSModuleBlock:

  • body: Statement[] (requerido)

Alias: TypeScript, Scopable, Block, BlockParent, FunctionParent

tsModuleDeclaration​

JavaScript
t.tsModuleDeclaration(id, body);

Véase también t.isTSModuleDeclaration(node, opts) y t.assertTSModuleDeclaration(node, opts).

Estructura del nodo AST TSModuleDeclaration:

  • id: Identifier | StringLiteral (requerido)

  • body: TSModuleBlock | TSModuleDeclaration (requerido)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

  • global: boolean (valor por defecto: null, excluido de la función constructora)

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

Alias: TypeScript, Statement, Declaration

tsNamedTupleMember​

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

Véase también t.isTSNamedTupleMember(node, opts) y t.assertTSNamedTupleMember(node, opts).

Estructura del nodo AST TSNamedTupleMember:

  • label: Identifier (requerido)

  • elementType: TSType (requerido)

  • optional: boolean (valor por defecto: false)

Alias: TypeScript

tsNamespaceExportDeclaration​

JavaScript
t.tsNamespaceExportDeclaration(id);

Véase también t.isTSNamespaceExportDeclaration(node, opts) y t.assertTSNamespaceExportDeclaration(node, opts).

Estructura del nodo AST TSNamespaceExportDeclaration:

  • id: Identifier (requerido)

Alias: TypeScript, Statement

tsNeverKeyword​

JavaScript
t.tsNeverKeyword();

Véase también t.isTSNeverKeyword(node, opts) y t.assertTSNeverKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsNonNullExpression​

JavaScript
t.tsNonNullExpression(expression);

Véase también t.isTSNonNullExpression(node, opts) y t.assertTSNonNullExpression(node, opts).

Estructura del nodo AST TSNonNullExpression:

  • expression: Expression (requerido)

Alias: TypeScript, Expression, LVal, PatternLike

tsNullKeyword​

JavaScript
t.tsNullKeyword();

Véase también t.isTSNullKeyword(node, opts) y t.assertTSNullKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsNumberKeyword​

JavaScript
t.tsNumberKeyword();

Véase también t.isTSNumberKeyword(node, opts) y t.assertTSNumberKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsObjectKeyword​

JavaScript
t.tsObjectKeyword();

Ver también t.isTSObjectKeyword(node, opts) y t.assertTSObjectKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsOptionalType​

JavaScript
t.tsOptionalType(typeAnnotation);

Ver también t.isTSOptionalType(node, opts) y t.assertTSOptionalType(node, opts).

Forma del nodo AST TSOptionalType:

  • typeAnnotation: TSType (requerido)

Alias: TypeScript, TSType

tsParameterProperty​

JavaScript
t.tsParameterProperty(parameter);

Ver también t.isTSParameterProperty(node, opts) y t.assertTSParameterProperty(node, opts).

Forma del nodo AST TSParameterProperty:

  • parameter: Identifier | AssignmentPattern (requerido)

  • accessibility: "public" | "private" | "protected" (por defecto: null, excluido de la función constructora)

  • decorators: Decorator[] (por defecto: null, excluido de la función constructora)

  • override: boolean (por defecto: null, excluido de la función constructora)

  • readonly: boolean (por defecto: null, excluido de la función constructora)

Alias: TypeScript, LVal

tsParenthesizedType​

JavaScript
t.tsParenthesizedType(typeAnnotation);

Ver también t.isTSParenthesizedType(node, opts) y t.assertTSParenthesizedType(node, opts).

Forma del nodo AST TSParenthesizedType:

  • typeAnnotation: TSType (requerido)

Alias: TypeScript, TSType

tsPropertySignature​

JavaScript
t.tsPropertySignature(key, typeAnnotation);

Ver también t.isTSPropertySignature(node, opts) y t.assertTSPropertySignature(node, opts).

Forma del nodo AST TSPropertySignature:

  • key: Expression (requerido)

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

  • computed: boolean (por defecto: false, excluido de la función constructora)

  • kind: "get" | "set" (por defecto: null, excluido de la función constructora)

  • optional: boolean (por defecto: null, excluido de la función constructora)

  • readonly: boolean (por defecto: null, excluido de la función constructora)

Alias: TypeScript, TSTypeElement

tsQualifiedName​

JavaScript
t.tsQualifiedName(left, right);

Ver también t.isTSQualifiedName(node, opts) y t.assertTSQualifiedName(node, opts).

Forma del nodo AST TSQualifiedName:

  • left: TSEntityName (requerido)

  • right: Identifier (requerido)

Alias: TypeScript, TSEntityName

tsRestType​

JavaScript
t.tsRestType(typeAnnotation);

Ver también t.isTSRestType(node, opts) y t.assertTSRestType(node, opts).

Forma del nodo AST TSRestType:

  • typeAnnotation: TSType (requerido)

Alias: TypeScript, TSType

tsSatisfiesExpression​

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

Ver también t.isTSSatisfiesExpression(node, opts) y t.assertTSSatisfiesExpression(node, opts).

Forma del nodo AST TSSatisfiesExpression:

  • expression: Expression (requerido)

  • typeAnnotation: TSType (requerido)

Alias: TypeScript, Expression, LVal, PatternLike

tsStringKeyword​

JavaScript
t.tsStringKeyword();

Ver también t.isTSStringKeyword(node, opts) y t.assertTSStringKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsSymbolKeyword​

JavaScript
t.tsSymbolKeyword();

Ver también t.isTSSymbolKeyword(node, opts) y t.assertTSSymbolKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsTemplateLiteralType​

JavaScript
t.tsTemplateLiteralType(quasis, types);

Ver también t.isTSTemplateLiteralType(node, opts) y t.assertTSTemplateLiteralType(node, opts).

Forma del nodo AST TSTemplateLiteralType:

  • quasis: TemplateElement[] (requerido)

  • types: TSType[] (requerido)

Alias: TypeScript, TSType, TSBaseType

tsThisType​

JavaScript
t.tsThisType();

Ver también t.isTSThisType(node, opts) y t.assertTSThisType(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsTupleType​

JavaScript
t.tsTupleType(elementTypes);

Ver también t.isTSTupleType(node, opts) y t.assertTSTupleType(node, opts).

Forma del nodo AST TSTupleType:

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

Alias: TypeScript, TSType

tsTypeAliasDeclaration​

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

Ver también t.isTSTypeAliasDeclaration(node, opts) y t.assertTSTypeAliasDeclaration(node, opts).

Forma del nodo AST TSTypeAliasDeclaration:

  • id: Identifier (requerido)

  • typeParameters: TSTypeParameterDeclaration (valor por defecto: null)

  • typeAnnotation: TSType (requerido)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

Alias: TypeScript, Statement, Declaration

tsTypeAnnotation​

JavaScript
t.tsTypeAnnotation(typeAnnotation);

Ver también t.isTSTypeAnnotation(node, opts) y t.assertTSTypeAnnotation(node, opts).

Estructura del nodo AST TSTypeAnnotation:

  • typeAnnotation: TSType (requerido)

Alias: TypeScript

tsTypeAssertion​

JavaScript
t.tsTypeAssertion(typeAnnotation, expression);

Ver también t.isTSTypeAssertion(node, opts) y t.assertTSTypeAssertion(node, opts).

Estructura del nodo AST TSTypeAssertion:

  • typeAnnotation: TSType (requerido)

  • expression: Expression (requerido)

Alias: TypeScript, Expression, LVal, PatternLike

tsTypeLiteral​

JavaScript
t.tsTypeLiteral(members);

Ver también t.isTSTypeLiteral(node, opts) y t.assertTSTypeLiteral(node, opts).

Estructura del nodo AST TSTypeLiteral:

  • members: TSTypeElement[] (requerido)

Alias: TypeScript, TSType

tsTypeOperator​

JavaScript
t.tsTypeOperator(typeAnnotation, operator);

Ver también t.isTSTypeOperator(node, opts) y t.assertTSTypeOperator(node, opts).

Estructura del nodo AST TSTypeOperator:

  • typeAnnotation: TSType (requerido)

  • operator: string (valor por defecto: 'keyof')

Alias: TypeScript, TSType

tsTypeParameter​

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

Ver también t.isTSTypeParameter(node, opts) y t.assertTSTypeParameter(node, opts).

Estructura del nodo AST TSTypeParameter:

  • constraint: TSType (valor por defecto: null)

  • default: TSType (valor por defecto: null)

  • name: string (requerido)

  • const: boolean (valor por defecto: null, excluido de la función constructora)

  • in: boolean (valor por defecto: null, excluido de la función constructora)

  • out: boolean (valor por defecto: null, excluido de la función constructora)

Alias: TypeScript

tsTypeParameterDeclaration​

JavaScript
t.tsTypeParameterDeclaration(params);

Ver también t.isTSTypeParameterDeclaration(node, opts) y t.assertTSTypeParameterDeclaration(node, opts).

Estructura del nodo AST TSTypeParameterDeclaration:

  • params: TSTypeParameter[] (requerido)

Alias: TypeScript

tsTypeParameterInstantiation​

JavaScript
t.tsTypeParameterInstantiation(params);

Ver también t.isTSTypeParameterInstantiation(node, opts) y t.assertTSTypeParameterInstantiation(node, opts).

Estructura del nodo AST TSTypeParameterInstantiation:

  • params: TSType[] (requerido)

Alias: TypeScript

tsTypePredicate​

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

Ver también t.isTSTypePredicate(node, opts) y t.assertTSTypePredicate(node, opts).

Estructura del nodo AST TSTypePredicate:

  • parameterName: Identifier | TSThisType (requerido)

  • typeAnnotation: TSTypeAnnotation (predeterminado: null)

  • asserts: boolean (predeterminado: null)

Alias: TypeScript, TSType

tsTypeQuery​

JavaScript
t.tsTypeQuery(exprName, typeParameters);

Ver también t.isTSTypeQuery(node, opts) y t.assertTSTypeQuery(node, opts).

Estructura del nodo AST TSTypeQuery:

  • exprName: TSEntityName | TSImportType (requerido)

  • typeParameters: TSTypeParameterInstantiation (predeterminado: null)

Alias: TypeScript, TSType

tsTypeReference​

JavaScript
t.tsTypeReference(typeName, typeParameters);

Ver también t.isTSTypeReference(node, opts) y t.assertTSTypeReference(node, opts).

Estructura del nodo AST TSTypeReference:

  • typeName: TSEntityName (requerido)

  • typeParameters: TSTypeParameterInstantiation (predeterminado: null)

Alias: TypeScript, TSType

tsUndefinedKeyword​

JavaScript
t.tsUndefinedKeyword();

Ver también t.isTSUndefinedKeyword(node, opts) y t.assertTSUndefinedKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsUnionType​

JavaScript
t.tsUnionType(types);

Ver también t.isTSUnionType(node, opts) y t.assertTSUnionType(node, opts).

Estructura del nodo AST TSUnionType:

  • types: TSType[] (requerido)

Alias: TypeScript, TSType

tsUnknownKeyword​

JavaScript
t.tsUnknownKeyword();

Ver también t.isTSUnknownKeyword(node, opts) y t.assertTSUnknownKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

tsVoidKeyword​

JavaScript
t.tsVoidKeyword();

Ver también t.isTSVoidKeyword(node, opts) y t.assertTSVoidKeyword(node, opts).

Alias: TypeScript, TSType, TSBaseType

taggedTemplateExpression​

JavaScript
t.taggedTemplateExpression(tag, quasi);

Véase también t.isTaggedTemplateExpression(node, opts) y t.assertTaggedTemplateExpression(node, opts).

Forma del nodo AST TaggedTemplateExpression:

  • tag: Expression (requerido)

  • quasi: TemplateLiteral (requerido)

  • typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (por defecto: null, excluido de la función constructora)

Alias: Standardized, Expression

templateElement​

JavaScript
t.templateElement(value, tail);

Véase también t.isTemplateElement(node, opts) y t.assertTemplateElement(node, opts).

Forma del nodo AST TemplateElement:

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

  • tail: boolean (por defecto: false)

Alias: Standardized

templateLiteral​

JavaScript
t.templateLiteral(quasis, expressions);

Véase también t.isTemplateLiteral(node, opts) y t.assertTemplateLiteral(node, opts).

Forma del nodo AST TemplateLiteral:

  • quasis: TemplateElement[] (requerido)

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

Alias: Standardized, Expression, Literal

thisExpression​

JavaScript
t.thisExpression();

Véase también t.isThisExpression(node, opts) y t.assertThisExpression(node, opts).

Alias: Standardized, Expression

thisTypeAnnotation​

JavaScript
t.thisTypeAnnotation();

Véase también t.isThisTypeAnnotation(node, opts) y t.assertThisTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

throwStatement​

JavaScript
t.throwStatement(argument);

Véase también t.isThrowStatement(node, opts) y t.assertThrowStatement(node, opts).

Forma del nodo AST ThrowStatement:

  • argument: Expression (requerido)

Alias: Standardized, Statement, Terminatorless, CompletionStatement

topicReference​

JavaScript
t.topicReference();

Véase también t.isTopicReference(node, opts) y t.assertTopicReference(node, opts).

Alias: Expression

tryStatement​

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

Véase también t.isTryStatement(node, opts) y t.assertTryStatement(node, opts).

Forma del nodo AST TryStatement:

  • block: BlockStatement (requerido)

  • handler: CatchClause (por defecto: null)

  • finalizer: BlockStatement (por defecto: null)

Alias: Standardized, Statement

tupleExpression​

JavaScript
t.tupleExpression(elements);

Ver también t.isTupleExpression(node, opts) y t.assertTupleExpression(node, opts).

Forma del nodo AST TupleExpression:

  • elements: (Expression | SpreadElement)[] (por defecto: [])

Alias: Expression

tupleTypeAnnotation​

JavaScript
t.tupleTypeAnnotation(types);

Ver también t.isTupleTypeAnnotation(node, opts) y t.assertTupleTypeAnnotation(node, opts).

Forma del nodo AST TupleTypeAnnotation:

  • types: FlowType[] (requerido)

Alias: Flow, FlowType

typeAlias​

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

Ver también t.isTypeAlias(node, opts) y t.assertTypeAlias(node, opts).

Forma del nodo AST TypeAlias:

  • id: Identifier (requerido)

  • typeParameters: TypeParameterDeclaration (valor por defecto: null)

  • right: FlowType (requerido)

Alias: Flow, FlowDeclaration, Statement, Declaration

typeAnnotation​

JavaScript
t.typeAnnotation(typeAnnotation);

Ver también t.isTypeAnnotation(node, opts) y t.assertTypeAnnotation(node, opts).

Forma del nodo AST TypeAnnotation:

  • typeAnnotation: FlowType (requerido)

Alias: Flow

typeCastExpression​

JavaScript
t.typeCastExpression(expression, typeAnnotation);

Ver también t.isTypeCastExpression(node, opts) y t.assertTypeCastExpression(node, opts).

Forma del nodo AST TypeCastExpression:

  • expression: Expression (requerido)

  • typeAnnotation: TypeAnnotation (requerido)

Alias: Flow, ExpressionWrapper, Expression

typeParameter​

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

Ver también t.isTypeParameter(node, opts) y t.assertTypeParameter(node, opts).

Forma del nodo AST TypeParameter:

  • bound: TypeAnnotation (valor por defecto: null)

  • default: FlowType (valor por defecto: null)

  • variance: Variance (valor por defecto: null)

  • name: string (requerido)

Alias: Flow

typeParameterDeclaration​

JavaScript
t.typeParameterDeclaration(params);

Ver también t.isTypeParameterDeclaration(node, opts) y t.assertTypeParameterDeclaration(node, opts).

Forma del nodo AST TypeParameterDeclaration:

  • params: TypeParameter[] (requerido)

Alias: Flow

typeParameterInstantiation​

JavaScript
t.typeParameterInstantiation(params);

Ver también t.isTypeParameterInstantiation(node, opts) y t.assertTypeParameterInstantiation(node, opts).

Forma del nodo AST TypeParameterInstantiation:

  • params: FlowType[] (requerido)

Alias: Flow

typeofTypeAnnotation​

JavaScript
t.typeofTypeAnnotation(argument);

Ver también t.isTypeofTypeAnnotation(node, opts) y t.assertTypeofTypeAnnotation(node, opts).

Forma del nodo AST TypeofTypeAnnotation:

  • argument: FlowType (requerido)

Alias: Flow, FlowType

unaryExpression​

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

Ver también t.isUnaryExpression(node, opts) y t.assertUnaryExpression(node, opts).

Forma del nodo AST UnaryExpression:

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

  • argument: Expression (requerido)

  • prefix: boolean (valor predeterminado: true)

Alias: Standardized, UnaryLike, Expression

unionTypeAnnotation​

JavaScript
t.unionTypeAnnotation(types);

Ver también t.isUnionTypeAnnotation(node, opts) y t.assertUnionTypeAnnotation(node, opts).

Forma del nodo AST UnionTypeAnnotation:

  • types: FlowType[] (requerido)

Alias: Flow, FlowType

updateExpression​

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

Ver también t.isUpdateExpression(node, opts) y t.assertUpdateExpression(node, opts).

Forma del nodo AST UpdateExpression:

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

  • argument: Expression (requerido)

  • prefix: boolean (valor predeterminado: false)

Alias: Standardized, Expression

v8IntrinsicIdentifier​

JavaScript
t.v8IntrinsicIdentifier(name);

Ver también t.isV8IntrinsicIdentifier(node, opts) y t.assertV8IntrinsicIdentifier(node, opts).

Forma del nodo AST V8IntrinsicIdentifier:

  • name: string (requerido)

Alias: Miscellaneous

variableDeclaration​

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

Ver también t.isVariableDeclaration(node, opts) y t.assertVariableDeclaration(node, opts).

Forma del nodo AST VariableDeclaration:

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

  • declarations: VariableDeclarator[] (requerido)

  • declare: boolean (valor predeterminado: null, excluido de la función constructora)

Alias: Standardized, Statement, Declaration

variableDeclarator​

JavaScript
t.variableDeclarator(id, init);

Ver también t.isVariableDeclarator(node, opts) y t.assertVariableDeclarator(node, opts).

Forma del nodo AST VariableDeclarator:

  • id: LVal | VoidPattern (requerido)

  • init: Expression (valor por defecto: null)

  • definite: boolean (valor por defecto: null, excluido de la función constructora)

Alias: Standardized

variance​

JavaScript
t.variance(kind);

Ver también t.isVariance(node, opts) y t.assertVariance(node, opts).

Estructura del nodo AST Variance:

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

Alias: Flow

voidPattern​

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

Ver también t.isVoidPattern(node, opts) y t.assertVoidPattern(node, opts).

Alias: Pattern, PatternLike, FunctionParameter

voidTypeAnnotation​

JavaScript
t.voidTypeAnnotation();

Ver también t.isVoidTypeAnnotation(node, opts) y t.assertVoidTypeAnnotation(node, opts).

Alias: Flow, FlowType, FlowBaseAnnotation

whileStatement​

JavaScript
t.whileStatement(test, body);

Ver también t.isWhileStatement(node, opts) y t.assertWhileStatement(node, opts).

Estructura del nodo AST WhileStatement:

  • test: Expression (requerido)

  • body: Statement (requerido)

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

withStatement​

JavaScript
t.withStatement(object, body);

Ver también t.isWithStatement(node, opts) y t.assertWithStatement(node, opts).

Estructura del nodo AST WithStatement:

  • object: Expression (requerido)

  • body: Statement (requerido)

Alias: Standardized, Statement

yieldExpression​

JavaScript
t.yieldExpression(argument, delegate);

Ver también t.isYieldExpression(node, opts) y t.assertYieldExpression(node, opts).

Estructura del nodo AST YieldExpression:

  • argument: Expression (valor por defecto: null)

  • delegate: boolean (valor por defecto: false)

Alias: Standardized, Expression, Terminatorless

Alias​

Accessor​

Obsoleto. Se eliminará en Babel 8.

JavaScript
t.isAccessor(node);

Nodos incluidos:

Binary​

Cubre BinaryExpression y LogicalExpression, que comparten la misma estructura AST.

JavaScript
t.isBinary(node);

Nodos incluidos:

Block​

Obsoleto. Se eliminará en Babel 8.

JavaScript
t.isBlock(node);

Nodos incluidos:

BlockParent​

Cobertura de nodos AST que inician un contexto de ejecución con nuevo Entorno Léxico. Definen el ámbito de las declaraciones let y const.

JavaScript
t.isBlockParent(node);

Nodos incluidos:

Class​

Cobertura de ClassExpression y ClassDeclaration, que comparten la misma estructura AST.

JavaScript
t.isClass(node);

Nodos incluidos:

CompletionStatement​

Sentencia que indica los registros de finalización. Define el flujo de control del programa, como cuándo debe interrumpirse un bucle o una acción lanza errores críticos.

JavaScript
t.isCompletionStatement(node);

Nodos incluidos:

Conditional​

Cobertura de ConditionalExpression e IfStatement, que comparten la misma estructura AST.

JavaScript
t.isConditional(node);

Nodos incluidos:

Declaration​

Cobertura de cualquier Declaración.

JavaScript
t.isDeclaration(node);

Nodos incluidos:

EnumBody​

Agrupa los cuerpos de enumeraciones de Flow.

JavaScript
t.isEnumBody(node);

Nodos incluidos:

EnumMember​

Agrupa los miembros de enumeraciones de Flow.

JavaScript
t.isEnumMember(node);

Nodos incluidos:

ExportDeclaration​

Agrupa todas las ExportDeclaration.

JavaScript
t.isExportDeclaration(node);

Nodos incluidos:

Expresión​

Agrupa todas las Expression.

JavaScript
t.isExpression(node);

Nodos incluidos:

ExpressionWrapper​

Un envoltorio de expresión que no tiene semántica en tiempo de ejecución.

JavaScript
t.isExpressionWrapper(node);

Nodos incluidos:

Flow​

Una cobertura de nodos AST definidos para Flow.

JavaScript
t.isFlow(node);

Nodos incluidos:

FlowBaseAnnotation​

Un grupo que engloba las anotaciones de tipos primarios de Flow.

JavaScript
t.isFlowBaseAnnotation(node);

Nodos incluidos:

FlowDeclaration​

Un grupo que engloba las declaraciones de Flow.

JavaScript
t.isFlowDeclaration(node);

Nodos incluidos:

FlowPredicate​

Un grupo que engloba los predicados de Flow.

JavaScript
t.isFlowPredicate(node);

Nodos incluidos:

FlowType​

Un grupo que engloba las anotaciones de tipos de Flow.

JavaScript
t.isFlowType(node);

Nodos incluidos:

Bucles For​

Agrupa ForStatements y ForXStatements.

JavaScript
t.isFor(node);

Nodos incluidos:

ForXStatement​

Cubre sentencias ForIn y ForOf.

JavaScript
t.isForXStatement(node);

Nodos incluidos:

Función​

Agrupa funciones y métodos, que deben tener body y params. Nota: Function es diferente a FunctionParent. Por ejemplo, un StaticBlock es un FunctionParent pero no una Function.

JavaScript
t.isFunction(node);

Nodos incluidos:

Parámetro de Función​

Cubre los parámetros de función. Son los elementos de la FormalParameterList.

JavaScript
t.isFunctionParameter(node);

Nodos incluidos:

FunctionParent​

Un conjunto de nodos AST que inician un contexto de ejecución con un nuevo VariableEnvironment. En otras palabras, definen el ámbito de las declaraciones var. FunctionParent no incluía Program desde Babel 7.

JavaScript
t.isFunctionParent(node);

Nodos incluidos:

Inmutables​

Conjunto de objetos inmutables y elementos JSX. Un objeto es immutable si no se pueden definir otras propiedades después de su creación.

JavaScript
t.isImmutable(node);

Nodos incluidos:

ImportOrExportDeclaration​

History
VersionChanges
v7.21.0Introduced

Conjunto que incluye ImportDeclaration y ExportDeclaration.

JavaScript
t.isImportOrExportDeclaration(node);

Nodos incluidos:

JSX​

Conjunto de nodos AST definidos para JSX.

JavaScript
t.isJSX(node);

Nodos incluidos:

LVal​

Un conjunto de expresiones del lado izquierdo utilizadas en el left de expresiones de asignación y ForXStatements.

JavaScript
t.isLVal(node);

Nodos incluidos:

Literal​

Un conjunto de literales, literales de expresión regular y literales de plantilla.

JavaScript
t.isLiteral(node);

Nodos incluidos:

Bucles​

Un conjunto de sentencias de bucle.

JavaScript
t.isLoop(node);

Nodos incluidos:

Método​

Un conjunto de métodos de objeto y métodos de clase.

JavaScript
t.isMethod(node);

Nodos incluidos:

Misceláneos​

Un conjunto de tipos AST no estándar que a veces son útiles para el desarrollo.

JavaScript
t.isMiscellaneous(node);

Nodos incluidos:

ModuleDeclaration​

History
VersionChanges
v7.21.0Deprecated
precaución

Obsoleto, usa ImportOrExportDeclaration en su lugar. Consulta el PR #15266 para notas de migración.

JavaScript
t.isModuleDeclaration(node);

Nodos incluidos:

ModuleSpecifier​

Cobertura de especificadores de importación y exportación. Nota: No es el ModuleSpecifier definido en la especificación.

JavaScript
t.isModuleSpecifier(node);

Nodos incluidos:

ObjectMember​

Cobertura de miembros en objetos literales.

JavaScript
t.isObjectMember(node);

Nodos incluidos:

Pattern​

Cobertura de BindingPattern excluyendo Identificadores.

JavaScript
t.isPattern(node);

Nodos incluidos:

PatternLike​

Cobertura de patrones de enlace (BindingPattern).

JavaScript
t.isPatternLike(node);

Nodos incluidos:

Private​

Cobertura de elementos privados de clase e identificadores privados.

JavaScript
t.isPrivate(node);

Nodos incluidos:

Propiedad​

Cobertura de propiedades de objetos y propiedades de clase.

JavaScript
t.isProperty(node);

Nodos incluidos:

Pureish​

Categoría de nodos AST que no producen efectos secundarios. Es decir, no generan cambios observables en el comportamiento si se evalúan múltiples veces.

JavaScript
t.isPureish(node);

Nodos incluidos:

Scopable​

Categoría que engloba FunctionParent y BlockParent.

JavaScript
t.isScopable(node);

Nodos incluidos:

Estandarizados​

Categoría de nodos AST que forman parte de especificaciones oficiales de ECMAScript.

JavaScript
t.isStandardized(node);

Nodos incluidos:

Declaración​

Cobertura de cualquier Declaración.

JavaScript
t.isStatement(node);

Nodos incluidos:

TSBaseType​

Una cobertura de las anotaciones de tipo primarias de TypeScript.

JavaScript
t.isTSBaseType(node);

Nodos incluidos:

TSEntityName​

Una cobertura de entidades de TypeScript.

JavaScript
t.isTSEntityName(node);

Nodos incluidos:

TSType​

Una cobertura de las anotaciones de tipo de TypeScript.

JavaScript
t.isTSType(node);

Nodos incluidos:

TSTypeElement​

Un conjunto de declaraciones de tipos de TypeScript.

JavaScript
t.isTSTypeElement(node);

Nodos incluidos:

Sin terminador​

Un conjunto de nodos AST cuya semántica cambia cuando se inserta un terminador de línea entre el operador y el operando.

JavaScript
t.isTerminatorless(node);

Nodos incluidos:

TypeScript​

Un conjunto de nodos AST definidos para TypeScript.

JavaScript
t.isTypeScript(node);

Nodos incluidos:

SimilarAUnario​

Agrupa UnaryExpression y SpreadElement.

JavaScript
t.isUnaryLike(node);

Nodos incluidos:

UserWhitespacable​

Obsoleto. Se eliminará en Babel 8.

JavaScript
t.isUserWhitespacable(node);

Nodos incluidos:

While​

Agrupa DoWhileStatement y WhileStatement, que comparten la misma estructura de AST.

JavaScript
t.isWhile(node);

Nodos incluidos: