@babel/types - npm Package Compare versions

Comparing version 7.0.0-beta.36 to 7.0.0-beta.37

lib/asserts/generated/index.js

@@ -240,2 +240,3 @@ "use strict";
 exports.assertFlow = assertFlow;
+exports.assertFlowType = assertFlowType;
 exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
@@ -2150,2 +2151,10 @@ exports.assertFlowDeclaration = assertFlowDeclaration;
 
+function assertFlowType(node, opts) {
+  if (opts === void 0) {
+    opts = {};
+  }
+
+  assert("FlowType", node, opts);
+}
+
 function assertFlowBaseAnnotation(node, opts) {
@@ -2152,0 +2161,0 @@ if (opts === void 0) {

lib/constants/generated/index.js

 "use strict";
 
 exports.__esModule = true;
-exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.JSX_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.FLOW_TYPES = exports.MODULESPECIFIER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = exports.CLASS_TYPES = exports.PATTERN_TYPES = exports.UNARYLIKE_TYPES = exports.PROPERTY_TYPES = exports.OBJECTMEMBER_TYPES = exports.METHOD_TYPES = exports.USERWHITESPACABLE_TYPES = exports.IMMUTABLE_TYPES = exports.LITERAL_TYPES = exports.TSENTITYNAME_TYPES = exports.LVAL_TYPES = exports.PATTERNLIKE_TYPES = exports.DECLARATION_TYPES = exports.PUREISH_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTION_TYPES = exports.FORXSTATEMENT_TYPES = exports.FOR_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.WHILE_TYPES = exports.LOOP_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.SCOPABLE_TYPES = exports.BINARY_TYPES = exports.EXPRESSION_TYPES = void 0;
+exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.JSX_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.FLOWTYPE_TYPES = exports.FLOW_TYPES = exports.MODULESPECIFIER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = exports.CLASS_TYPES = exports.PATTERN_TYPES = exports.UNARYLIKE_TYPES = exports.PROPERTY_TYPES = exports.OBJECTMEMBER_TYPES = exports.METHOD_TYPES = exports.USERWHITESPACABLE_TYPES = exports.IMMUTABLE_TYPES = exports.LITERAL_TYPES = exports.TSENTITYNAME_TYPES = exports.LVAL_TYPES = exports.PATTERNLIKE_TYPES = exports.DECLARATION_TYPES = exports.PUREISH_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTION_TYPES = exports.FORXSTATEMENT_TYPES = exports.FOR_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.WHILE_TYPES = exports.LOOP_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.SCOPABLE_TYPES = exports.BINARY_TYPES = exports.EXPRESSION_TYPES = void 0;
 
@@ -76,2 +76,4 @@ var _definitions = require("../../definitions");
 exports.FLOW_TYPES = FLOW_TYPES;
+var FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
+exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
 var FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
@@ -78,0 +80,0 @@ exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;

lib/definitions/flow.js

@@ -8,21 +8,22 @@ "use strict";
 (0, _utils.default)("AnyTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("ArrayTypeAnnotation", {
   visitor: ["elementType"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    elementType: (0, _utils.validateType)("FlowType")
+  }
 });
 (0, _utils.default)("BooleanTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("BooleanLiteralTypeAnnotation", {
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
 });
 (0, _utils.default)("NullLiteralTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
@@ -32,3 +33,6 @@ (0, _utils.default)("ClassImplements", {
   aliases: ["Flow"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
 });
@@ -38,3 +42,9 @@ (0, _utils.default)("DeclareClass", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation"),
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+    mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
+    body: (0, _utils.validateType)("ObjectTypeAnnotation")
+  }
 });
@@ -44,3 +54,6 @@ (0, _utils.default)("DeclareFunction", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
+  }
 });
@@ -50,8 +63,19 @@ (0, _utils.default)("DeclareInterface", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    extends: (0, _utils.validateOptionalType)("InterfaceExtends"),
+    mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("Flow")),
+    body: (0, _utils.validateType)("ObjectTypeAnnotation")
+  }
 });
 (0, _utils.default)("DeclareModule", {
+  builder: ["id", "body", "kind"],
   visitor: ["id", "body"],
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)("BlockStatement"),
+    kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
+  }
 });
@@ -61,3 +85,5 @@ (0, _utils.default)("DeclareModuleExports", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+  }
 });
@@ -67,3 +93,7 @@ (0, _utils.default)("DeclareTypeAlias", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
+  }
 });
@@ -73,3 +103,7 @@ (0, _utils.default)("DeclareOpaqueType", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType")
+  }
 });
@@ -79,3 +113,5 @@ (0, _utils.default)("DeclareVariable", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier")
+  }
 });
@@ -85,3 +121,8 @@ (0, _utils.default)("DeclareExportDeclaration", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    declaration: (0, _utils.validateOptionalType)("Flow"),
+    specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
+    source: (0, _utils.validateOptionalType)("StringLiteral"),
+    default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
 });
@@ -91,3 +132,6 @@ (0, _utils.default)("DeclareExportAllDeclaration", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    source: (0, _utils.validateType)("StringLiteral"),
+    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)(["type", "value"]))
+  }
 });
@@ -97,11 +141,18 @@ (0, _utils.default)("DeclaredPredicate", {
   aliases: ["Flow", "FlowPredicate"],
-  fields: {}
+  fields: {
+    value: (0, _utils.validateType)("Flow")
+  }
 });
 (0, _utils.default)("ExistsTypeAnnotation", {
-  aliases: ["Flow"]
+  aliases: ["Flow", "FlowType"]
 });
 (0, _utils.default)("FunctionTypeAnnotation", {
   visitor: ["typeParameters", "params", "rest", "returnType"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
+    rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
+    returnType: (0, _utils.validateType)("FlowType")
+  }
 });
@@ -111,12 +162,18 @@ (0, _utils.default)("FunctionTypeParam", {
   aliases: ["Flow"],
-  fields: {}
+  fields: {
+    name: (0, _utils.validateOptionalType)("Identifier"),
+    typeAnnotation: (0, _utils.validateType)("FlowType"),
+    optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
+  }
 });
 (0, _utils.default)("GenericTypeAnnotation", {
   visitor: ["id", "typeParameters"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
 });
 (0, _utils.default)("InferredPredicate", {
-  aliases: ["Flow", "FlowPredicate"],
-  fields: {}
+  aliases: ["Flow", "FlowPredicate"]
 });
@@ -126,3 +183,6 @@ (0, _utils.default)("InterfaceExtends", {
   aliases: ["Flow"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
+  }
 });
@@ -132,32 +192,48 @@ (0, _utils.default)("InterfaceDeclaration", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    extends: (0, _utils.validate)((0, _utils.arrayOfType)("InterfaceExtends")),
+    mixins: (0, _utils.validate)((0, _utils.arrayOfType)("InterfaceExtends")),
+    body: (0, _utils.validateType)("ObjectTypeAnnotation")
+  }
 });
 (0, _utils.default)("IntersectionTypeAnnotation", {
   visitor: ["types"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
 });
 (0, _utils.default)("MixedTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"]
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("EmptyTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"]
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("NullableTypeAnnotation", {
   visitor: ["typeAnnotation"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    typeAnnotation: (0, _utils.validateType)("FlowType")
+  }
 });
 (0, _utils.default)("NumberLiteralTypeAnnotation", {
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
+  }
 });
 (0, _utils.default)("NumberTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("ObjectTypeAnnotation", {
   visitor: ["properties", "indexers", "callProperties"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
+    indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
+    callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
+    exact: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
 });
@@ -167,13 +243,29 @@ (0, _utils.default)("ObjectTypeCallProperty", {
   aliases: ["Flow", "UserWhitespacable"],
-  fields: {}
+  fields: {
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
+  }
 });
 (0, _utils.default)("ObjectTypeIndexer", {
-  visitor: ["id", "key", "value"],
+  visitor: ["id", "key", "value", "variance"],
   aliases: ["Flow", "UserWhitespacable"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateOptionalType)("Identifier"),
+    key: (0, _utils.validateType)("FlowType"),
+    value: (0, _utils.validateType)("FlowType"),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
 });
 (0, _utils.default)("ObjectTypeProperty", {
-  visitor: ["key", "value"],
+  visitor: ["key", "value", "variance"],
   aliases: ["Flow", "UserWhitespacable"],
-  fields: {}
+  fields: {
+    key: (0, _utils.validateType)("Identifier"),
+    value: (0, _utils.validateType)("FlowType"),
+    kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
+    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
+    variance: (0, _utils.validateOptionalType)("Variance")
+  }
 });
@@ -183,3 +275,5 @@ (0, _utils.default)("ObjectTypeSpreadProperty", {
   aliases: ["Flow", "UserWhitespacable"],
-  fields: {}
+  fields: {
+    argument: (0, _utils.validateType)("FlowType")
+  }
 });
@@ -189,3 +283,8 @@ (0, _utils.default)("OpaqueType", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    supertype: (0, _utils.validateOptionalType)("FlowType"),
+    impltype: (0, _utils.validateType)("FlowType")
+  }
 });
@@ -195,25 +294,32 @@ (0, _utils.default)("QualifiedTypeIdentifier", {
   aliases: ["Flow"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
+  }
 });
 (0, _utils.default)("StringLiteralTypeAnnotation", {
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
+  }
 });
 (0, _utils.default)("StringTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("ThisTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("TupleTypeAnnotation", {
   visitor: ["types"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
 });
 (0, _utils.default)("TypeofTypeAnnotation", {
   visitor: ["argument"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    argument: (0, _utils.validateType)("FlowType")
+  }
 });
@@ -223,3 +329,7 @@ (0, _utils.default)("TypeAlias", {
   aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {}
+  fields: {
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
+    right: (0, _utils.validateType)("FlowType")
+  }
 });
@@ -230,5 +340,3 @@ (0, _utils.default)("TypeAnnotation", {
   fields: {
-    typeAnnotation: {
-      validate: (0, _utils.assertNodeType)("Flow")
-    }
+    typeAnnotation: (0, _utils.validateType)("FlowType")
   }
@@ -239,19 +347,15 @@ });
   aliases: ["Flow", "ExpressionWrapper", "Expression"],
-  fields: {}
+  fields: {
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
+  }
 });
 (0, _utils.default)("TypeParameter", {
   aliases: ["Flow"],
-  visitor: ["bound", "default"],
+  visitor: ["bound", "default", "variance"],
   fields: {
-    name: {
-      validate: (0, _utils.assertValueType)("string")
-    },
-    bound: {
-      validate: (0, _utils.assertNodeType)("TypeAnnotation"),
-      optional: true
-    },
-    default: {
-      validate: (0, _utils.assertNodeType)("Flow"),
-      optional: true
-    }
+    name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
+    default: (0, _utils.validateOptionalType)("FlowType"),
+    variance: (0, _utils.validateOptionalType)("Variance")
   }
@@ -263,5 +367,3 @@ });
   fields: {
-    params: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TypeParameter")))
-    }
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
   }
@@ -273,5 +375,3 @@ });
   fields: {
-    params: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Flow")))
-    }
+    params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
   }
@@ -281,8 +381,9 @@ });
   visitor: ["types"],
-  aliases: ["Flow"],
-  fields: {}
+  aliases: ["Flow", "FlowType"],
+  fields: {
+    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
+  }
 });
 (0, _utils.default)("VoidTypeAnnotation", {
-  aliases: ["Flow", "FlowBaseAnnotation"],
-  fields: {}
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });

lib/definitions/typescript.js

@@ -12,43 +12,2 @@ "use strict";
 var bool = (0, _utils.assertValueType)("boolean");
-
-function validate(validate) {
-  return {
-    validate: validate
-  };
-}
-
-function typeIs(typeName) {
-  return typeof typeName === "string" ? (0, _utils.assertNodeType)(typeName) : _utils.assertNodeType.apply(void 0, typeName);
-}
-
-function validateType(name) {
-  return validate(typeIs(name));
-}
-
-function validateOptional(validate) {
-  return {
-    validate: validate,
-    optional: true
-  };
-}
-
-function validateOptionalType(typeName) {
-  return {
-    validate: typeIs(typeName),
-    optional: true
-  };
-}
-
-function arrayOf(elementType) {
-  return (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(elementType));
-}
-
-function arrayOfType(nodeTypeName) {
-  return arrayOf(typeIs(nodeTypeName));
-}
-
-function validateArrayOfType(nodeTypeName) {
-  return validate(arrayOfType(nodeTypeName));
-}
-
 var tSFunctionTypeAnnotationCommon = {
@@ -94,10 +53,10 @@ returnType: {
   fields: {
-    left: validateType("TSEntityName"),
-    right: validateType("Identifier")
+    left: (0, _utils.validateType)("TSEntityName"),
+    right: (0, _utils.validateType)("Identifier")
   }
 });
 var signatureDeclarationCommon = {
-  typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-  parameters: validateArrayOfType(["Identifier", "RestElement"]),
-  typeAnnotation: validateOptionalType("TSTypeAnnotation")
+  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+  parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
+  typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
 };
@@ -112,5 +71,5 @@ var callConstructSignatureDeclaration = {
 var namedTypeElementCommon = {
-  key: validateType("Expression"),
-  computed: validate(bool),
-  optional: validateOptional(bool)
+  key: (0, _utils.validateType)("Expression"),
+  computed: (0, _utils.validate)(bool),
+  optional: (0, _utils.validateOptional)(bool)
 };
@@ -121,5 +80,5 @@ (0, _utils.default)("TSPropertySignature", {
   fields: Object.assign({}, namedTypeElementCommon, {
-    readonly: validateOptional(bool),
-    typeAnnotation: validateOptionalType("TSTypeAnnotation"),
-    initializer: validateOptionalType("Expression")
+    readonly: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
+    initializer: (0, _utils.validateOptionalType)("Expression")
   })
@@ -136,5 +95,5 @@ });
   fields: {
-    readonly: validateOptional(bool),
-    parameters: validateArrayOfType("Identifier"),
-    typeAnnotation: validateOptionalType("TSTypeAnnotation")
+    readonly: (0, _utils.validateOptional)(bool),
+    parameters: (0, _utils.validateArrayOfType)("Identifier"),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
   }
@@ -169,4 +128,4 @@ });
   fields: {
-    typeName: validateType("TSEntityName"),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    typeName: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -178,4 +137,4 @@ });
   fields: {
-    parameterName: validateType(["Identifier", "TSThisType"]),
-    typeAnnotation: validateType("TSTypeAnnotation")
+    parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
+    typeAnnotation: (0, _utils.validateType)("TSTypeAnnotation")
   }
@@ -187,3 +146,3 @@ });
   fields: {
-    exprName: validateType("TSEntityName")
+    exprName: (0, _utils.validateType)("TSEntityName")
   }
@@ -195,3 +154,3 @@ });
   fields: {
-    members: validateArrayOfType("TSTypeElement")
+    members: (0, _utils.validateArrayOfType)("TSTypeElement")
   }
@@ -203,3 +162,3 @@ });
   fields: {
-    elementType: validateType("TSType")
+    elementType: (0, _utils.validateType)("TSType")
   }
@@ -211,3 +170,3 @@ });
   fields: {
-    elementTypes: validateArrayOfType("TSType")
+    elementTypes: (0, _utils.validateArrayOfType)("TSType")
   }
@@ -219,3 +178,3 @@ });
   fields: {
-    types: validateArrayOfType("TSType")
+    types: (0, _utils.validateArrayOfType)("TSType")
   }
@@ -229,3 +188,3 @@ };
   fields: {
-    typeAnnotation: validateType("TSType")
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -237,4 +196,4 @@ });
   fields: {
-    operator: validate((0, _utils.assertValueType)("string")),
-    typeAnnotation: validateType("TSType")
+    operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -246,4 +205,4 @@ });
   fields: {
-    objectType: validateType("TSType"),
-    indexType: validateType("TSType")
+    objectType: (0, _utils.validateType)("TSType"),
+    indexType: (0, _utils.validateType)("TSType")
   }
@@ -255,6 +214,6 @@ });
   fields: {
-    readonly: validateOptional(bool),
-    typeParameter: validateType("TSTypeParameter"),
-    optional: validateOptional(bool),
-    typeAnnotation: validateOptionalType("TSType")
+    readonly: (0, _utils.validateOptional)(bool),
+    typeParameter: (0, _utils.validateType)("TSTypeParameter"),
+    optional: (0, _utils.validateOptional)(bool),
+    typeAnnotation: (0, _utils.validateOptionalType)("TSType")
   }
@@ -266,3 +225,3 @@ });
   fields: {
-    literal: validateType(["NumericLiteral", "StringLiteral", "BooleanLiteral"])
+    literal: (0, _utils.validateType)(["NumericLiteral", "StringLiteral", "BooleanLiteral"])
   }
@@ -274,4 +233,4 @@ });
   fields: {
-    expression: validateType("TSEntityName"),
-    typeParameters: validateOptionalType("TSTypeParameterInstantiation")
+    expression: (0, _utils.validateType)("TSEntityName"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
   }
@@ -283,7 +242,7 @@ });
   fields: {
-    declare: validateOptional(bool),
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-    extends: validateOptional(arrayOfType("TSExpressionWithTypeArguments")),
-    body: validateType("TSInterfaceBody")
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
+    body: (0, _utils.validateType)("TSInterfaceBody")
   }
@@ -294,3 +253,3 @@ });
   fields: {
-    body: validateArrayOfType("TSTypeElement")
+    body: (0, _utils.validateArrayOfType)("TSTypeElement")
   }
@@ -302,6 +261,6 @@ });
   fields: {
-    declare: validateOptional(bool),
-    id: validateType("Identifier"),
-    typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-    typeAnnotation: validateType("TSType")
+    declare: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -313,4 +272,4 @@ });
   fields: {
-    expression: validateType("Expression"),
-    typeAnnotation: validateType("TSType")
+    expression: (0, _utils.validateType)("Expression"),
+    typeAnnotation: (0, _utils.validateType)("TSType")
   }
@@ -322,4 +281,4 @@ });
   fields: {
-    typeAnnotation: validateType("TSType"),
-    expression: validateType("Expression")
+    typeAnnotation: (0, _utils.validateType)("TSType"),
+    expression: (0, _utils.validateType)("Expression")
   }
@@ -331,7 +290,7 @@ });
   fields: {
-    declare: validateOptional(bool),
-    const: validateOptional(bool),
-    id: validateType("Identifier"),
-    members: validateArrayOfType("TSEnumMember"),
-    initializer: validateOptionalType("Expression")
+    declare: (0, _utils.validateOptional)(bool),
+    const: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    members: (0, _utils.validateArrayOfType)("TSEnumMember"),
+    initializer: (0, _utils.validateOptionalType)("Expression")
   }
@@ -342,4 +301,4 @@ });
   fields: {
-    id: validateType(["Identifier", "StringLiteral"]),
-    initializer: validateOptionalType("Expression")
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    initializer: (0, _utils.validateOptionalType)("Expression")
   }
@@ -351,6 +310,6 @@ });
   fields: {
-    declare: validateOptional(bool),
-    global: validateOptional(bool),
-    id: validateType(["Identifier", "StringLiteral"]),
-    body: validateType(["TSModuleBlock", "TSModuleDeclaration"])
+    declare: (0, _utils.validateOptional)(bool),
+    global: (0, _utils.validateOptional)(bool),
+    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
+    body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
   }
@@ -361,3 +320,3 @@ });
   fields: {
-    body: validateArrayOfType("Statement")
+    body: (0, _utils.validateArrayOfType)("Statement")
   }
@@ -369,5 +328,5 @@ });
   fields: {
-    isExport: validate(bool),
-    id: validateType("Identifier"),
-    moduleReference: validateType(["TSEntityName", "TSExternalModuleReference"])
+    isExport: (0, _utils.validate)(bool),
+    id: (0, _utils.validateType)("Identifier"),
+    moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"])
   }
@@ -378,3 +337,3 @@ });
   fields: {
-    expression: validateType("StringLiteral")
+    expression: (0, _utils.validateType)("StringLiteral")
   }
@@ -386,3 +345,3 @@ });
   fields: {
-    expression: validateType("Expression")
+    expression: (0, _utils.validateType)("Expression")
   }
@@ -394,3 +353,3 @@ });
   fields: {
-    expression: validateType("Expression")
+    expression: (0, _utils.validateType)("Expression")
   }
@@ -402,3 +361,3 @@ });
   fields: {
-    id: validateType("Identifier")
+    id: (0, _utils.validateType)("Identifier")
   }
@@ -405,0 +364,0 @@ });

lib/definitions/utils.js

 "use strict";
 
 exports.__esModule = true;
+exports.validate = validate;
+exports.typeIs = typeIs;
+exports.validateType = validateType;
+exports.validateOptional = validateOptional;
+exports.validateOptionalType = validateOptionalType;
+exports.arrayOf = arrayOf;
+exports.arrayOfType = arrayOfType;
+exports.validateArrayOfType = validateArrayOfType;
 exports.assertEach = assertEach;
@@ -42,2 +50,42 @@ exports.assertOneOf = assertOneOf;
 
+function validate(validate) {
+  return {
+    validate: validate
+  };
+}
+
+function typeIs(typeName) {
+  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType.apply(void 0, typeName);
+}
+
+function validateType(typeName) {
+  return validate(typeIs(typeName));
+}
+
+function validateOptional(validate) {
+  return {
+    validate: validate,
+    optional: true
+  };
+}
+
+function validateOptionalType(typeName) {
+  return {
+    validate: typeIs(typeName),
+    optional: true
+  };
+}
+
+function arrayOf(elementType) {
+  return chain(assertValueType("array"), assertEach(elementType));
+}
+
+function arrayOfType(typeName) {
+  return arrayOf(typeIs(typeName));
+}
+
+function validateArrayOfType(typeName) {
+  return validate(arrayOfType(typeName));
+}
+
 function assertEach(callback) {
@@ -44,0 +92,0 @@ function validator(node, key, val) {

lib/validators/generated/index.js

@@ -240,2 +240,3 @@ "use strict";
 exports.isFlow = isFlow;
+exports.isFlowType = isFlowType;
 exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
@@ -1200,2 +1201,6 @@ exports.isFlowDeclaration = isFlowDeclaration;
 
+function isFlowType(node, opts) {
+  return (0, _is.default)("FlowType", node, opts);
+}
+
 function isFlowBaseAnnotation(node, opts) {
@@ -1202,0 +1207,0 @@ return (0, _is.default)("FlowBaseAnnotation", node, opts);

package.json

 {
   "name": "@babel/types",
-  "version": "7.0.0-beta.36",
+  "version": "7.0.0-beta.37",
   "description": "Babel Types is a Lodash-esque utility library for AST nodes",
@@ -16,5 +16,5 @@ "author": "Sebastian McKenzie <[e-mail]>",
   "devDependencies": {
-    "@babel/generator": "7.0.0-beta.36",
-    "babylon": "7.0.0-beta.36"
+    "@babel/generator": "7.0.0-beta.37",
+    "babylon": "7.0.0-beta.37"
   }
 }

No alert changes

Improved metrics

Total package byte prevSize

364234

increased by2.83%

Lines of code

8125

increased by1.54%

Number of lines in readme file

2856

increased by0.71%

No dependency changes