condenser 0.2 → 0.3

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/es2015.js

@@ -9,6 +9,10 @@ var _utils = _interopRequireWildcard(require("./utils"));
 
 var _core = require("./core");
 
+var _is = _interopRequireDefault(require("../validators/is"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -25,7 +29,8 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
       validate: (0, _utils.assertNodeType)("Expression")
     },
     decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
     }
   })
 });
@@ -35,10 +40,11 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
   aliases: ["Pattern", "PatternLike", "LVal"],
   fields: Object.assign({}, _core.patternLikeCommon, {
     elements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("PatternLike")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike")))
     },
     decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
     }
   })
 });
@@ -63,57 +69,18 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
     }
   }
 });
-const classCommon = {
-  typeParameters: {
-    validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-    optional: true
-  },
-  body: {
-    validate: (0, _utils.assertNodeType)("ClassBody")
-  },
-  superClass: {
-    optional: true,
-    validate: (0, _utils.assertNodeType)("Expression")
-  },
-  superTypeParameters: {
-    validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-    optional: true
-  },
-  implements: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
-    optional: true
-  }
-};
-(0, _utils.default)("ClassDeclaration", {
+(0, _utils.default)("ClassExpression", {
   builder: ["id", "superClass", "body", "decorators"],
   visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
-  aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"],
-  fields: Object.assign({}, classCommon, {
-    declare: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
-    abstract: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
+  aliases: ["Scopable", "Class", "Expression"],
+  fields: {
     id: {
       validate: (0, _utils.assertNodeType)("Identifier"),
       optional: true
     },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+    typeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
       optional: true
-    }
-  })
-});
-(0, _utils.default)("ClassExpression", {
-  inherits: "ClassDeclaration",
-  aliases: ["Scopable", "Class", "Expression", "Pureish"],
-  fields: Object.assign({}, classCommon, {
-    id: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("Identifier")
     },
     body: {
       validate: (0, _utils.assertNodeType)("ClassBody")
@@ -122,11 +89,43 @@ const classCommon = {
       optional: true,
       validate: (0, _utils.assertNodeType)("Expression")
     },
+    superTypeParameters: {
+      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+      optional: true
+    },
+    implements: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
+      optional: true
+    },
     decorators: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
       optional: true
     }
-  })
+  }
+});
+(0, _utils.default)("ClassDeclaration", {
+  inherits: "ClassExpression",
+  aliases: ["Scopable", "Class", "Statement", "Declaration"],
+  fields: {
+    declare: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    },
+    abstract: {
+      validate: (0, _utils.assertValueType)("boolean"),
+      optional: true
+    }
+  },
+  validate: function () {
+    const identifier = (0, _utils.assertNodeType)("Identifier");
+    return function (parent, key, node) {
+      if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+      if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
+        identifier(node, "id", node.id);
+      }
+    };
+  }()
 });
 (0, _utils.default)("ExportAllDeclaration", {
   visitor: ["source"],
@@ -151,11 +150,32 @@ const classCommon = {
   aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
   fields: {
     declaration: {
-      validate: (0, _utils.assertNodeType)("Declaration"),
-      optional: true
+      optional: true,
+      validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (val && node.specifiers.length) {
+          throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
+        }
+      }, function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (val && node.source) {
+          throw new TypeError("Cannot export a declaration from a source");
+        }
+      })
     },
     specifiers: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier")))
+      default: [],
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
+        const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
+        const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
+        if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
+        return function (node, key, val) {
+          const validator = node.source ? sourced : sourceless;
+          validator(node, key, val);
+        };
+      }()))
     },
     source: {
       validate: (0, _utils.assertNodeType)("StringLiteral"),
@@ -178,10 +198,25 @@ const classCommon = {
 });
 (0, _utils.default)("ForOfStatement", {
   visitor: ["left", "right", "body"],
+  builder: ["left", "right", "body", "await"],
   aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
   fields: {
     left: {
-      validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal")
+      validate: function () {
+        if (!process.env.BABEL_TYPES_8_BREAKING) {
+          return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
+        }
+
+        const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
+        const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern");
+        return function (node, key, val) {
+          if ((0, _is.default)("VariableDeclaration", val)) {
+            declaration(node, key, val);
+          } else {
+            lval(node, key, val);
+          }
+        };
+      }()
     },
     right: {
       validate: (0, _utils.assertNodeType)("Expression")
@@ -190,8 +225,7 @@ const classCommon = {
       validate: (0, _utils.assertNodeType)("Statement")
     },
     await: {
-      default: false,
-      validate: (0, _utils.assertValueType)("boolean")
+      default: false
     }
   }
 });
@@ -250,7 +284,30 @@ const classCommon = {
   aliases: ["Expression"],
   fields: {
     meta: {
-      validate: (0, _utils.assertNodeType)("Identifier")
+      validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+        let property;
+
+        switch (val.name) {
+          case "function":
+            property = "sent";
+            break;
+
+          case "new":
+            property = "target";
+            break;
+
+          case "import":
+            property = "meta";
+            break;
+        }
+
+        if (!(0, _is.default)("Identifier", node.property, {
+          name: property
+        })) {
+          throw new TypeError("Unrecognised MetaProperty");
+        }
+      })
     },
     property: {
       validate: (0, _utils.assertNodeType)("Identifier")
@@ -263,16 +320,14 @@ const classMethodOrPropertyCommon = {
     optional: true
   },
   accessibility: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
+    validate: (0, _utils.assertOneOf)("public", "private", "protected"),
     optional: true
   },
   static: {
-    default: false,
-    validate: (0, _utils.assertValueType)("boolean")
+    default: false
   },
   computed: {
-    default: false,
-    validate: (0, _utils.assertValueType)("boolean")
+    default: false
   },
   optional: {
     validate: (0, _utils.assertValueType)("boolean"),
@@ -292,7 +347,7 @@ const classMethodOrPropertyCommon = {
 exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
 const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon, {}, classMethodOrPropertyCommon, {
   kind: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")),
+    validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
     default: "method"
   },
   access: {
@@ -307,7 +362,7 @@ const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon,
 exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
 (0, _utils.default)("ClassMethod", {
   aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
-  builder: ["kind", "key", "params", "body", "computed", "static"],
+  builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
   visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
   fields: Object.assign({}, classMethodOrDeclareMethodCommon, {}, _core.functionTypeAnnotationCommon, {
     body: {
@@ -369,7 +424,6 @@ exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
       })
     },
     tail: {
-      validate: (0, _utils.assertValueType)("boolean"),
       default: false
     }
   }
@@ -396,7 +450,13 @@ exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
   aliases: ["Expression", "Terminatorless"],
   fields: {
     delegate: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (val && !node.argument) {
+          throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
+        }
+      }),
       default: false
     },
     argument: {

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/experimental.js

@@ -22,7 +22,14 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 (0, _utils.default)("BindExpression", {
   visitor: ["object", "callee"],
   aliases: ["Expression"],
-  fields: {}
+  fields: !process.env.BABEL_TYPES_8_BREAKING ? {} : {
+    object: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    },
+    callee: {
+      validate: (0, _utils.assertNodeType)("Expression")
+    }
+  }
 });
 (0, _utils.default)("ClassProperty", {
   visitor: ["key", "value", "typeAnnotation", "decorators"],
@@ -77,7 +84,7 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
       default: false
     },
     optional: {
-      validate: (0, _utils.assertValueType)("boolean")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
     }
   }
 });
@@ -114,7 +121,7 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName")))
     },
     optional: {
-      validate: (0, _utils.assertValueType)("boolean")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
     },
     typeArguments: {
       validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
@@ -212,4 +219,23 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
     }
   },
   aliases: ["Expression", "Pureish", "Literal", "Immutable"]
+});
+(0, _utils.default)("RecordExpression", {
+  visitor: ["properties"],
+  aliases: ["Expression"],
+  fields: {
+    properties: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "ObjectMethod", "SpreadElement")))
+    }
+  }
+});
+(0, _utils.default)("TupleExpression", {
+  fields: {
+    elements: {
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
+      default: []
+    }
+  },
+  visitor: ["elements"],
+  aliases: ["Expression"]
 });

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/flow.js

@@ -304,6 +304,9 @@ defineInterfaceishType("InterfaceDeclaration");
 (0, _utils.default)("StringTypeAnnotation", {
   aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
+(0, _utils.default)("SymbolTypeAnnotation", {
+  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
+});
 (0, _utils.default)("ThisTypeAnnotation", {
   aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
@@ -387,7 +390,7 @@ defineInterfaceishType("InterfaceDeclaration");
   aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
 });
 (0, _utils.default)("EnumDeclaration", {
-  alises: ["Declaration"],
+  aliases: ["Statement", "Declaration"],
   visitor: ["id", "body"],
   fields: {
     id: (0, _utils.validateType)("Identifier"),

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/index.js

@@ -39,6 +39,12 @@ Object.defineProperty(exports, "DEPRECATED_KEYS", {
     return _utils.DEPRECATED_KEYS;
   }
 });
+Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
+  enumerable: true,
+  get: function () {
+    return _utils.NODE_PARENT_VALIDATIONS;
+  }
+});
 Object.defineProperty(exports, "PLACEHOLDERS", {
   enumerable: true,
   get: function () {

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/jsx.js

@@ -108,8 +108,7 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
       validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
     },
     selfClosing: {
-      default: false,
-      validate: (0, _utils.assertValueType)("boolean")
+      default: false
     },
     attributes: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/utils.js

@@ -17,9 +17,10 @@ exports.assertNodeType = assertNodeType;
 exports.assertNodeOrValueType = assertNodeOrValueType;
 exports.assertValueType = assertValueType;
 exports.assertShape = assertShape;
+exports.assertOptionalChainStart = assertOptionalChainStart;
 exports.chain = chain;
 exports.default = defineType;
-exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0;
+exports.NODE_PARENT_VALIDATIONS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0;
 
 var _is = _interopRequireDefault(require("../validators/is"));
 
@@ -39,14 +40,14 @@ const BUILDER_KEYS = {};
 exports.BUILDER_KEYS = BUILDER_KEYS;
 const DEPRECATED_KEYS = {};
 exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
+const NODE_PARENT_VALIDATIONS = {};
+exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
 
 function getType(val) {
   if (Array.isArray(val)) {
     return "array";
   } else if (val === null) {
     return "null";
-  } else if (val === undefined) {
-    return "undefined";
   } else {
     return typeof val;
   }
@@ -97,7 +98,10 @@ function assertEach(callback) {
     if (!Array.isArray(val)) return;
 
     for (let i = 0; i < val.length; i++) {
-      callback(node, `${key}[${i}]`, val[i]);
+      const subkey = `${key}[${i}]`;
+      const v = val[i];
+      callback(node, subkey, v);
+      if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
     }
   }
 
@@ -118,18 +122,14 @@ function assertOneOf(...values) {
 
 function assertNodeType(...types) {
   function validate(node, key, val) {
-    let valid = false;
-
     for (const type of types) {
       if ((0, _is.default)(type, val)) {
-        valid = true;
-        break;
+        (0, _validate.validateChild)(node, key, val);
+        return;
       }
     }
 
-    if (!valid) {
-      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`);
-    }
+    throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val && val.type)}`);
   }
 
   validate.oneOfNodeTypes = types;
@@ -138,18 +138,14 @@ function assertNodeType(...types) {
 
 function assertNodeOrValueType(...types) {
   function validate(node, key, val) {
-    let valid = false;
-
     for (const type of types) {
       if (getType(val) === type || (0, _is.default)(type, val)) {
-        valid = true;
-        break;
+        (0, _validate.validateChild)(node, key, val);
+        return;
       }
     }
 
-    if (!valid) {
-      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} ` + `but instead got ${JSON.stringify(val && val.type)}`);
-    }
+    throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val && val.type)}`);
   }
 
   validate.oneOfNodeOrValueTypes = types;
@@ -195,6 +191,38 @@ function assertShape(shape) {
   return validate;
 }
 
+function assertOptionalChainStart() {
+  function validate(node) {
+    var _current;
+
+    let current = node;
+
+    while (node) {
+      const {
+        type
+      } = current;
+
+      if (type === "OptionalCallExpression") {
+        if (current.optional) return;
+        current = current.callee;
+        continue;
+      }
+
+      if (type === "OptionalMemberExpression") {
+        if (current.optional) return;
+        current = current.object;
+        continue;
+      }
+
+      break;
+    }
+
+    throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);
+  }
+
+  return validate;
+}
+
 function chain(...fns) {
   function validate(...args) {
     for (const fn of fns) {
@@ -206,13 +234,40 @@ function chain(...fns) {
   return validate;
 }
 
+const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
+const validFieldKeys = ["default", "optional", "validate"];
+
 function defineType(type, opts = {}) {
   const inherits = opts.inherits && store[opts.inherits] || {};
-  const fields = opts.fields || inherits.fields || {};
+  let fields = opts.fields;
+
+  if (!fields) {
+    fields = {};
+
+    if (inherits.fields) {
+      const keys = Object.getOwnPropertyNames(inherits.fields);
+
+      for (const key of keys) {
+        const field = inherits.fields[key];
+        fields[key] = {
+          default: field.default,
+          optional: field.optional,
+          validate: field.validate
+        };
+      }
+    }
+  }
+
   const visitor = opts.visitor || inherits.visitor || [];
   const aliases = opts.aliases || inherits.aliases || [];
   const builder = opts.builder || inherits.builder || opts.visitor || [];
 
+  for (const k of Object.keys(opts)) {
+    if (validTypeOpts.indexOf(k) === -1) {
+      throw new Error(`Unknown type option "${k}" on ${type}`);
+    }
+  }
+
   if (opts.deprecatedAlias) {
     DEPRECATED_KEYS[opts.deprecatedAlias] = type;
   }
@@ -224,15 +279,21 @@ function defineType(type, opts = {}) {
   for (const key of Object.keys(fields)) {
     const field = fields[key];
 
-    if (builder.indexOf(key) === -1) {
+    if (field.default !== undefined && builder.indexOf(key) === -1) {
       field.optional = true;
     }
 
     if (field.default === undefined) {
       field.default = null;
-    } else if (!field.validate) {
+    } else if (!field.validate && field.default != null) {
       field.validate = assertValueType(getType(field.default));
     }
+
+    for (const k of Object.keys(field)) {
+      if (validFieldKeys.indexOf(k) === -1) {
+        throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
+      }
+    }
   }
 
   VISITOR_KEYS[type] = opts.visitor = visitor;
@@ -243,6 +304,11 @@ function defineType(type, opts = {}) {
     FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
     FLIPPED_ALIAS_KEYS[alias].push(type);
   });
+
+  if (opts.validate) {
+    NODE_PARENT_VALIDATIONS[type] = opts.validate;
+  }
+
   store[type] = opts;
 }