rebuild

Author: jquense

lib/boolean.js

@@ -19,6 +19,6 @@ function BooleanSchema() {
 inherits(BooleanSchema, MixedSchema, {
 
   _typeCheck: function _typeCheck(v) {
-    return typeof v === 'boolean';
+    return typeof v === 'boolean' || typeof v === 'object' && v instanceof Boolean;
   }
 });

lib/mixed.js

@@ -39,9 +39,18 @@ SchemaType.prototype = {
   constructor: SchemaType,
 
   clone: function clone() {
+    if (this._mutate) return this;
+
     return cloneDeep(this);
   },
 
+  withMutation: function withMutation(fn) {
+    this._mutate = true;
+    var result = fn(this);
+    this._mutate = false;
+    return result;
+  },
+
   concat: function concat(schema) {
     if (!schema) return this;
 
@@ -85,22 +94,25 @@ SchemaType.prototype = {
   },
 
   _resolve: function _resolve(context, parent) {
-    var schema = this;
+    if (this._deps.length) {
+      return this._deps.reduce(function (schema, match) {
+        return match.resolve(schema, match.getValue(parent, context));
+      }, this);
+    }
 
-    return this._deps.reduce(function (schema, match) {
-      return match.resolve(schema, match.getValue(parent, context));
-    }, schema);
+    return this;
   },
 
   //-- tests
-  _validate: function _validate(value) {
+  _validate: function _validate(_value) {
     var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
     var state = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
 
     var valids = this._whitelist,
         invalids = this._blacklist,
         context = options.context,
         parent = state.parent,
+        value = _value,
         schema = undefined,
         endEarly = undefined,
         isStrict = undefined;

lib/number.js

@@ -25,7 +25,10 @@ function NumberSchema() {
 inherits(NumberSchema, SchemaObject, {
 
   _typeCheck: function _typeCheck(v) {
-    return typeof v === 'number' && !(v !== +v); //isNaN check
+    if (typeof v === 'number' && !(v !== +v)) return true;
+    if (typeof v === 'object' && v instanceof Number) return true;
+
+    return false;
   },
 
   min: function min(_min, msg) {

lib/object.js

@@ -83,46 +83,50 @@ inherits(ObjectSchema, MixedSchema, {
         value = MixedSchema.prototype._cast.call(schema, _value);
 
     //should ignore nulls here
-    if (schema._typeCheck(value)) {
-      var fields = schema.fields,
-          strip = schema._option('stripUnknown', _opts) === true,
-          extra = Object.keys(value).filter(function (v) {
-        return schema._nodes.indexOf(v) === -1;
-      }),
-          props = schema._nodes.concat(extra);
-
-      return transform(props, function (obj, prop) {
+    if (!schema._typeCheck(value)) return value;
+
+    var fields = schema.fields,
+        strip = schema._option('stripUnknown', _opts) === true,
+        extra = Object.keys(value).filter(function (v) {
+      return schema._nodes.indexOf(v) === -1;
+    }),
+        props = schema._nodes.concat(extra);
+
+    schema.withMutation(function () {
+      value = transform(props, function (obj, prop) {
         var exists = has(value, prop);
 
         if (exists && fields[prop]) {
           var fieldSchema = childSchema(fields[prop], schema['default'](undefined));
 
           obj[prop] = fieldSchema.cast(value[prop], { context: obj });
-        } else if (exists && !strip) obj[prop] = cloneDeep(value[prop]);else if (fields[prop]) {
+        } else if (exists && !strip) obj[prop] = value[prop];else if (fields[prop]) {
           var fieldDefault = fields[prop]['default'] ? fields[prop]['default']() : undefined;
 
           if (fieldDefault !== undefined) obj[prop] = fieldDefault;
         }
       }, {});
-    }
+
+      delete schema._default;
+    });
 
     return value;
   },
 
   _validate: function _validate(_value, _opts, _state) {
     var errors = [],
+        state = _state || {},
         context,
         schema,
         endEarly,
         recursive;
 
-    _state = _state || {};
-    context = _state.parent || (_opts || {}).context;
+    context = state.parent || (_opts || {}).context;
     schema = this._resolve(context);
     endEarly = schema._option('abortEarly', _opts);
     recursive = schema._option('recursive', _opts);
 
-    return MixedSchema.prototype._validate.call(this, _value, _opts, _state)['catch'](endEarly ? null : function (err) {
+    return MixedSchema.prototype._validate.call(this, _value, _opts, state)['catch'](endEarly ? null : function (err) {
       errors.push(err);
       return err.value;
     }).then(function (value) {
@@ -133,13 +137,13 @@ inherits(ObjectSchema, MixedSchema, {
       }
 
       var result = schema._nodes.map(function (key) {
-        var path = (_state.path ? _state.path + '.' : '') + key,
+        var path = (state.path ? state.path + '.' : '') + key,
             field = childSchema(schema.fields[key], schema);
 
-        return field._validate(value[key], _opts, _extends({}, _state, { key: key, path: path, parent: value }));
+        return field._validate(value[key], _opts, _extends({}, state, { key: key, path: path, parent: value }));
       });
 
-      result = endEarly ? Promise.all(result)['catch'](scopeError(value)) : collectErrors(result, value, _state.path, errors);
+      result = endEarly ? Promise.all(result)['catch'](scopeError(value)) : collectErrors(result, value, state.path, errors);
 
       return result.then(function () {
         return value;

lib/string.js

@@ -26,7 +26,7 @@ function StringSchema() {
 inherits(StringSchema, MixedSchema, {
 
   _typeCheck: function _typeCheck(value) {
-    return typeof value === 'string';
+    return typeof value === 'string' || typeof value === 'object' && value instanceof String;
   },
 
   required: function required(msg) {

lib/util/clone.js

@@ -4,10 +4,18 @@
 
 'use strict';
 
+var isSchema = function isSchema(schema) {
+  return schema && !!schema.__isYupSchema__;
+};
+
 module.exports = function clone(obj, seen) {
-  var isFirst = !seen;
+  var isFirst = !seen,
+      isImmutable = isSchema(obj) && !isFirst;
+
+  if (typeof obj !== 'object' || obj === null || isImmutable) return obj;
 
-  if (typeof obj !== 'object' || obj === null) return obj;
+  // if (global.REPORT_CLONE && isFirst)
+  //   throw new Error() //console.log('clone')
 
   seen = seen || { orig: [], copy: [] };
 
@@ -26,7 +34,7 @@ module.exports = function clone(obj, seen) {
     } else {
       var proto = Object.getPrototypeOf(obj);
 
-      if (proto !== null && (!proto || proto.__isYupSchema__ && !isFirst)) {
+      if (proto !== null && !proto) {
         newObj = obj;
       } else {
         newObj = Object.create(proto);

lib/util/condition.js

@@ -28,9 +28,6 @@ var Conditional = (function () {
 
       if (!options.then && !options.otherwise) throw new TypeError('either `then:` or `otherwise:` is required for `when()` conditions');
 
-      // if(  options.then && options.then._type !== type || options.otherwise && options.otherwise._type !== type)
-      //   throw new TypeError(`cannot create polymorphic conditionals, \`then\` and \`otherwise\` must be the same type: ${type}`)
-
       is = typeof is === 'function' ? is : (function (is, value) {
         return is === value;
       }).bind(null, is);