Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →

optimal

Package Overview

Dependencies

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

optimal - npm Package Compare versions

Comparing version 1.1.1 to 1.1.2

CHANGELOG.md

		# Changelog

		# 1.1.2 - 10/15/18

		#### 🐞 Fixed

		- Updated `shape` to return an object with inherited or default values, instead of an empty object.

		# 1.1.1 - 09/02/18
		@@ -4,0 +10,0 @@

634

lib/Builder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.bool = bool;
		exports.custom = custom;
		exports.func = func;
		exports.default = void 0;

		var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

		var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

		var _isObject = _interopRequireDefault(require("./isObject"));

		/**
		@@ -29,321 +6,318 @@ * @copyright 2017, Miles Johnson
		*/
		var Builder = function () {
		function Builder(type, defaultValue) {
		(0, _classCallCheck2.default)(this, Builder);
		(0, _defineProperty2.default)(this, "checks", []);
		(0, _defineProperty2.default)(this, "currentStruct", {});
		(0, _defineProperty2.default)(this, "defaultValue", void 0);
		(0, _defineProperty2.default)(this, "deprecatedMessage", '');
		(0, _defineProperty2.default)(this, "errorMessage", '');
		(0, _defineProperty2.default)(this, "isNullable", false);
		(0, _defineProperty2.default)(this, "isRequired", false);
		(0, _defineProperty2.default)(this, "options", {});
		(0, _defineProperty2.default)(this, "type", void 0);

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(typeof defaultValue !== 'undefined', "A default value for type \"".concat(type, "\" is required."));
		this.addCheck(this.checkType);
		}

		this.defaultValue = defaultValue;
		this.type = type;
		}

		(0, _createClass2.default)(Builder, [{
		key: "addCheck",
		value: function addCheck(checker) {
		for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
		args[_key - 1] = arguments[_key];
		}

		if ("production" !== process.env.NODE_ENV) {
		this.checks.push({
		args: args,
		callback: checker
		});
		}

		return this;
		}
		}, {
		key: "and",
		value: function and() {
		for (var _len2 = arguments.length, keys = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
		keys[_key2] = arguments[_key2];
		}

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(keys.length > 0, 'AND requires a list of field names.');
		}

		return this.addCheck(this.checkAnd, keys);
		}
		}, {
		key: "checkAnd",
		value: function checkAnd(path, value, otherKeys) {
		if ("production" !== process.env.NODE_ENV) {
		var keys = [this.key(path)].concat((0, _toConsumableArray2.default)(otherKeys));
		var struct = this.currentStruct;
		var undefs = keys.filter(function (key) {
		return typeof struct[key] === 'undefined' \|\| struct[key] === null;
		});

		if (undefs.length === keys.length) {
		return;
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var isObject_1 = __importDefault(require("./isObject"));
		var Builder = /** @class */ (function () {
		function Builder(type, defaultValue) {
		this.checks = [];
		this.currentStruct = {};
		this.deprecatedMessage = '';
		this.errorMessage = '';
		this.isNullable = false;
		this.isRequired = false;
		this.options = {};
		if (__DEV__) {
		this.invariant(typeof defaultValue !== 'undefined', "A default value for type \"" + type + "\" is required.");
		this.addCheck(this.checkType);
		}

		this.invariant(undefs.length === 0, "All of these fields must be defined: ".concat(keys.join(', ')));
		}
		this.defaultValue = defaultValue;
		this.type = type;
		}
		}, {
		key: "checkType",
		value: function checkType(path, value) {
		if ("production" !== process.env.NODE_ENV) {
		switch (this.type) {
		case 'array':
		this.invariant(Array.isArray(value), 'Must be an array.', path);
		break;

		case 'custom':
		case 'instance':
		case 'union':
		break;

		case 'object':
		case 'shape':
		this.invariant((0, _isObject.default)(value), 'Must be a plain object.', path);
		break;

		default:
		this.invariant((0, _typeof2.default)(value) === this.type, "Must be a ".concat(this.type, "."), path);
		break;
		/**
		* Add a checking function with optional arguments.
		*/
		Builder.prototype.addCheck = function (checker) {
		var args = [];
		for (var _i = 1; _i < arguments.length; _i++) {
		args[_i - 1] = arguments[_i];
		}
		}
		}
		}, {
		key: "custom",
		value: function custom(callback) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(typeof callback === 'function', 'Custom blueprints require a validation function.');
		}

		return this.addCheck(this.checkCustom, callback);
		}
		}, {
		key: "checkCustom",
		value: function checkCustom(path, value, callback) {
		if ("production" !== process.env.NODE_ENV) {
		try {
		callback(value, this.currentStruct);
		} catch (error) {
		this.invariant(false, error.message, path);
		if (__DEV__) {
		this.checks.push({
		args: args,
		callback: checker,
		});
		}
		}
		}
		}, {
		key: "deprecate",
		value: function deprecate(message) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(typeof message === 'string' && !!message, 'A non-empty string is required for deprecated messages.');
		this.deprecatedMessage = message;
		}

		return this;
		}
		}, {
		key: "invariant",
		value: function invariant(condition, message) {
		var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';

		if ("production" !== process.env.NODE_ENV) {
		if (condition) {
		return;
		return this;
		};
		/**
		* Map a list of names that must be defined alongside this field.
		*/
		Builder.prototype.and = function () {
		var keys = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		keys[_i] = arguments[_i];
		}

		var name = this.options.name;
		var prefix = '';

		if (path) {
		if (name) {
		prefix += "Invalid ".concat(name, " field \"").concat(path, "\". ");
		} else {
		prefix += "Invalid field \"".concat(path, "\". ");
		}
		} else if (name) {
		prefix += "".concat(name, ": ");
		if (__DEV__) {
		this.invariant(keys.length > 0, 'AND requires a list of field names.');
		}

		throw new Error("".concat(prefix).concat(this.errorMessage \|\| message));
		}
		}
		}, {
		key: "key",
		value: function key(path) {
		var index = path.lastIndexOf('.');
		return index > 0 ? path.slice(index + 1) : path;
		}
		}, {
		key: "message",
		value: function message(_message) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(typeof _message === 'string' && !!_message, 'A non-empty string is required for custom messages.');
		this.errorMessage = _message;
		}

		return this;
		}
		}, {
		key: "nullable",
		value: function nullable() {
		var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

		if ("production" !== process.env.NODE_ENV) {
		this.isNullable = state;
		}

		return this;
		}
		}, {
		key: "only",
		value: function only() {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant((0, _typeof2.default)(this.defaultValue) === this.type, "Only requires a default ".concat(this.type, " value."));
		}

		return this.addCheck(this.checkOnly);
		}
		}, {
		key: "checkOnly",
		value: function checkOnly(path, value) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(value === this.defaultValue, "Value may only be \"".concat(String(this.defaultValue), "\"."), path);
		}
		}
		}, {
		key: "or",
		value: function or() {
		for (var _len3 = arguments.length, keys = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
		keys[_key3] = arguments[_key3];
		}

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(keys.length > 0, 'OR requires a list of field names.');
		}

		return this.addCheck(this.checkOr, keys);
		}
		}, {
		key: "checkOr",
		value: function checkOr(path, value, otherKeys) {
		if ("production" !== process.env.NODE_ENV) {
		var keys = [this.key(path)].concat((0, _toConsumableArray2.default)(otherKeys));
		var struct = this.currentStruct;
		var defs = keys.filter(function (key) {
		return typeof struct[key] !== 'undefined' && struct[key] !== null;
		});
		this.invariant(defs.length > 0, "At least one of these fields must be defined: ".concat(keys.join(', ')));
		}
		}
		}, {
		key: "required",
		value: function required() {
		var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

		if ("production" !== process.env.NODE_ENV) {
		this.isRequired = state;
		}

		return this;
		}
		}, {
		key: "runChecks",
		value: function runChecks(path, initialValue, struct) {
		var _this = this;

		var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
		this.currentStruct = struct;
		this.options = options;
		var value = initialValue;

		if (typeof value === 'undefined') {
		if (!this.isRequired) {
		value = this.defaultValue;
		} else if ("production" !== process.env.NODE_ENV) {
		this.invariant(false, 'Field is required and must be defined.', path);
		return this.addCheck(this.checkAnd, keys);
		};
		/**
		* Validate that all fields have been defined.
		*/
		Builder.prototype.checkAnd = function (path, value, otherKeys) {
		if (__DEV__) {
		var keys = [this.key(path)].concat(otherKeys);
		var struct_1 = this.currentStruct;
		var undefs = keys.filter(function (key) { return typeof struct_1[key] === 'undefined' \|\| struct_1[key] === null; });
		// Only error once one of the struct is defined
		if (undefs.length === keys.length) {
		return;
		}
		this.invariant(undefs.length === 0, "All of these fields must be defined: " + keys.join(', '));
		}
		} else if (this.deprecatedMessage) {
		if ("production" !== process.env.NODE_ENV) {
		console.info("Field \"".concat(path, "\" is deprecated. ").concat(this.deprecatedMessage));
		};
		/**
		* Validate the type of value.
		*/
		Builder.prototype.checkType = function (path, value) {
		if (__DEV__) {
		switch (this.type) {
		case 'array':
		this.invariant(Array.isArray(value), 'Must be an array.', path);
		break;
		case 'custom':
		case 'instance':
		case 'union':
		// Handle in the sub-class
		break;
		case 'object':
		case 'shape':
		this.invariant(isObject_1.default(value), 'Must be a plain object.', path);
		break;
		default:
		// eslint-disable-next-line valid-typeof
		this.invariant(typeof value === this.type, "Must be a " + this.type + ".", path);
		break;
		}
		}
		}

		if (value === null) {
		if (this.isNullable) {
		return value;
		};
		/**
		* Set a callback to run custom logic.
		*/
		Builder.prototype.custom = function (callback) {
		if (__DEV__) {
		this.invariant(typeof callback === 'function', 'Custom blueprints require a validation function.');
		}

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(false, 'Null is not allowed.', path);
		return this.addCheck(this.checkCustom, callback);
		};
		/**
		* Validate the value using a custom callback.
		*/
		Builder.prototype.checkCustom = function (path, value, callback) {
		if (__DEV__) {
		try {
		callback(value, this.currentStruct);
		}
		catch (error) {
		this.invariant(false, error.message, path);
		}
		}
		}

		if ("production" !== process.env.NODE_ENV) {
		this.checks.forEach(function (checker) {
		var _checker$callback;

		(_checker$callback = checker.callback).call.apply(_checker$callback, [_this, path, value].concat((0, _toConsumableArray2.default)(checker.args)));
		});
		}

		return value;
		}
		}, {
		key: "typeAlias",
		value: function typeAlias() {
		return this.type;
		}
		}, {
		key: "xor",
		value: function xor() {
		for (var _len4 = arguments.length, keys = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
		keys[_key4] = arguments[_key4];
		}

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(keys.length > 0, 'XOR requires a list of field names.');
		}

		return this.addCheck(this.checkXor, keys);
		}
		}, {
		key: "checkXor",
		value: function checkXor(path, value, otherKeys) {
		if ("production" !== process.env.NODE_ENV) {
		var keys = [this.key(path)].concat((0, _toConsumableArray2.default)(otherKeys));
		var struct = this.currentStruct;
		var defs = keys.filter(function (key) {
		return typeof struct[key] !== 'undefined' && struct[key] !== null;
		});
		this.invariant(defs.length === 1, "Only one of these fields may be defined: ".concat(keys.join(', ')));
		}
		}
		}]);
		return Builder;
		}();

		};
		/**
		* Set a message to log when this field is present.
		*/
		Builder.prototype.deprecate = function (message) {
		if (__DEV__) {
		this.invariant(typeof message === 'string' && !!message, 'A non-empty string is required for deprecated messages.');
		this.deprecatedMessage = message;
		}
		return this;
		};
		/**
		* Throw an error if the condition is falsy.
		*/
		Builder.prototype.invariant = function (condition, message, path) {
		if (path === void 0) { path = ''; }
		if (__DEV__) {
		if (condition) {
		return;
		}
		var name_1 = this.options.name;
		var prefix = '';
		if (path) {
		if (name_1) {
		prefix += "Invalid " + name_1 + " field \"" + path + "\". ";
		}
		else {
		prefix += "Invalid field \"" + path + "\". ";
		}
		}
		else if (name_1) {
		prefix += name_1 + ": ";
		}
		throw new Error("" + prefix + (this.errorMessage \|\| message));
		}
		};
		/**
		* Return the current key from a path.
		*/
		Builder.prototype.key = function (path) {
		var index = path.lastIndexOf('.');
		return index > 0 ? path.slice(index + 1) : path;
		};
		/**
		* Set a custom error message for all checks.
		*/
		Builder.prototype.message = function (message) {
		if (__DEV__) {
		this.invariant(typeof message === 'string' && !!message, 'A non-empty string is required for custom messages.');
		this.errorMessage = message;
		}
		return this;
		};
		/**
		* Allow null values.
		*/
		Builder.prototype.nullable = function (state) {
		if (state === void 0) { state = true; }
		if (__DEV__) {
		this.isNullable = state;
		}
		return this;
		};
		/**
		* Mark a field as only the default value can be used.
		*/
		Builder.prototype.only = function () {
		if (__DEV__) {
		this.invariant(
		// eslint-disable-next-line valid-typeof
		typeof this.defaultValue === this.type, "Only requires a default " + this.type + " value.");
		}
		return this.addCheck(this.checkOnly);
		};
		/**
		* Validate the value matches only the default value.
		*/
		Builder.prototype.checkOnly = function (path, value) {
		if (__DEV__) {
		this.invariant(value === this.defaultValue, "Value may only be \"" + String(this.defaultValue) + "\".", path);
		}
		};
		/**
		* Map a list of field names that must have at least 1 defined.
		*/
		Builder.prototype.or = function () {
		var keys = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		keys[_i] = arguments[_i];
		}
		if (__DEV__) {
		this.invariant(keys.length > 0, 'OR requires a list of field names.');
		}
		return this.addCheck(this.checkOr, keys);
		};
		/**
		* Validate that at least 1 field is defined.
		*/
		Builder.prototype.checkOr = function (path, value, otherKeys) {
		if (__DEV__) {
		var keys = [this.key(path)].concat(otherKeys);
		var struct_2 = this.currentStruct;
		var defs = keys.filter(function (key) { return typeof struct_2[key] !== 'undefined' && struct_2[key] !== null; });
		this.invariant(defs.length > 0, "At least one of these fields must be defined: " + keys.join(', '));
		}
		};
		/**
		* Disallow undefined values.
		*/
		Builder.prototype.required = function (state) {
		if (state === void 0) { state = true; }
		if (__DEV__) {
		this.isRequired = state;
		}
		return this;
		};
		/**
		* Run all validation checks that have been enqueued.
		*/
		Builder.prototype.runChecks = function (path, initialValue, struct, options) {
		var _this = this;
		if (options === void 0) { options = {}; }
		this.currentStruct = struct;
		this.options = options;
		var value = initialValue;
		// Handle undefined
		if (typeof value === 'undefined') {
		if (!this.isRequired) {
		value = this.defaultValue;
		}
		else if (__DEV__) {
		this.invariant(false, 'Field is required and must be defined.', path);
		}
		}
		else if (this.deprecatedMessage) {
		if (__DEV__) {
		// eslint-disable-next-line no-console
		console.info("Field \"" + path + "\" is deprecated. " + this.deprecatedMessage);
		}
		}
		// Handle null
		if (value === null) {
		if (this.isNullable) {
		return value;
		}
		if (__DEV__) {
		this.invariant(false, 'Null is not allowed.', path);
		}
		}
		// Run all checks against the value
		if (__DEV__) {
		this.checks.forEach(function (checker) {
		var _a;
		(_a = checker.callback).call.apply(_a, [_this, path, value].concat(checker.args));
		});
		}
		return value;
		};
		/**
		* Return a human readable type name.
		*/
		Builder.prototype.typeAlias = function () {
		return this.type;
		};
		/**
		* Map a list of field names that must not be defined alongside this field.
		*/
		Builder.prototype.xor = function () {
		var keys = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		keys[_i] = arguments[_i];
		}
		if (__DEV__) {
		this.invariant(keys.length > 0, 'XOR requires a list of field names.');
		}
		return this.addCheck(this.checkXor, keys);
		};
		/**
		* Validate that only 1 field is defined.
		*/
		Builder.prototype.checkXor = function (path, value, otherKeys) {
		if (__DEV__) {
		var keys = [this.key(path)].concat(otherKeys);
		var struct_3 = this.currentStruct;
		var defs = keys.filter(function (key) { return typeof struct_3[key] !== 'undefined' && struct_3[key] !== null; });
		this.invariant(defs.length === 1, "Only one of these fields may be defined: " + keys.join(', '));
		}
		};
		return Builder;
		}());
		exports.default = Builder;

		function bool() {
		var defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
		return new Builder('boolean', defaultValue);
		function bool(defaultValue) {
		if (defaultValue === void 0) { defaultValue = false; }
		return new Builder('boolean', defaultValue);
		}

		function custom(callback) {
		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
		return new Builder('custom', defaultValue).custom(callback);
		exports.bool = bool;
		function custom(callback, defaultValue) {
		if (defaultValue === void 0) { defaultValue = null; }
		return new Builder('custom', defaultValue).custom(callback);
		}

		function func() {
		var defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
		return new Builder('function', defaultValue).nullable();
		}
		exports.custom = custom;
		function func(defaultValue) {
		if (defaultValue === void 0) { defaultValue = null; }
		return new Builder('function', defaultValue).nullable();
		}
		exports.func = func;

189

lib/CollectionBuilder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.array = array;
		exports.object = object;
		exports.default = void 0;

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

		var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

		var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));

		var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

		var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

		var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

		var _Builder2 = _interopRequireDefault(require("./Builder"));

		/**
		@@ -34,85 +6,90 @@ * @copyright 2017, Miles Johnson
		*/
		var CollectionBuilder = function (_Builder) {
		(0, _inherits2.default)(CollectionBuilder, _Builder);

		function CollectionBuilder(type) {
		var _this;

		var contents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
		var defaultValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
		(0, _classCallCheck2.default)(this, CollectionBuilder);
		_this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(CollectionBuilder).call(this, type, defaultValue));
		(0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "contents", null);

		if ("production" !== process.env.NODE_ENV) {
		if (contents) {
		if (contents instanceof _Builder2.default) {
		_this.contents = contents;

		_this.addCheck(_this.checkContents, contents);
		} else {
		_this.invariant(false, "A blueprint is required for ".concat(type, " contents."));
		}
		}
		var __extends = (this && this.__extends) \|\| (function () {
		var extendStatics = function (d, b) {
		extendStatics = Object.setPrototypeOf \|\|
		({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
		function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
		return extendStatics(d, b);
		}

		return _this;
		}

		(0, _createClass2.default)(CollectionBuilder, [{
		key: "checkContents",
		value: function checkContents(path, value, contents) {
		var _this2 = this;

		if ("production" !== process.env.NODE_ENV) {
		if (this.type === 'array') {
		value.forEach(function (item, i) {
		contents.runChecks("".concat(path, "[").concat(i, "]"), item, _this2.currentStruct, _this2.options);
		});
		} else if (this.type === 'object') {
		Object.keys(value).forEach(function (key) {
		contents.runChecks("".concat(path, ".").concat(key), value[key], _this2.currentStruct, _this2.options);
		});
		return function (d, b) {
		extendStatics(d, b);
		function __() { this.constructor = d; }
		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
		})();
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		var CollectionBuilder = /** @class */ (function (_super) {
		__extends(CollectionBuilder, _super);
		function CollectionBuilder(type, contents, defaultValue) {
		if (contents === void 0) { contents = null; }
		if (defaultValue === void 0) { defaultValue = null; }
		var _this = _super.call(this, type, defaultValue) \|\| this;
		_this.contents = null;
		if (__DEV__) {
		if (contents) {
		if (contents instanceof Builder_1.default) {
		_this.contents = contents;
		_this.addCheck(_this.checkContents, contents);
		}
		else {
		_this.invariant(false, "A blueprint is required for " + type + " contents.");
		}
		}
		}
		}
		return _this;
		}
		}, {
		key: "notEmpty",
		value: function notEmpty() {
		return this.addCheck(this.checkNotEmpty);
		}
		}, {
		key: "checkNotEmpty",
		value: function checkNotEmpty(path, value) {
		if ("production" !== process.env.NODE_ENV) {
		if (this.type === 'array') {
		this.invariant(value.length > 0, 'Array cannot be empty.', path);
		} else if (this.type === 'object') {
		this.invariant(Object.keys(value).length > 0, 'Object cannot be empty.', path);
		CollectionBuilder.prototype.checkContents = function (path, value, contents) {
		var _this = this;
		if (__DEV__) {
		if (this.type === 'array') {
		value.forEach(function (item, i) {
		contents.runChecks(path + "[" + i + "]", item, _this.currentStruct, _this.options);
		});
		}
		else if (this.type === 'object') {
		Object.keys(value).forEach(function (key) {
		contents.runChecks(path + "." + key, value[key], _this.currentStruct, _this.options);
		});
		}
		}
		}
		}
		}, {
		key: "typeAlias",
		value: function typeAlias() {
		var contents = this.contents;
		var alias = (0, _get2.default)((0, _getPrototypeOf2.default)(CollectionBuilder.prototype), "typeAlias", this).call(this);
		return contents ? "".concat(alias, "<").concat(contents.typeAlias(), ">") : alias;
		}
		}]);
		return CollectionBuilder;
		}(_Builder2.default);

		};
		CollectionBuilder.prototype.notEmpty = function () {
		return this.addCheck(this.checkNotEmpty);
		};
		CollectionBuilder.prototype.checkNotEmpty = function (path, value) {
		if (__DEV__) {
		if (this.type === 'array') {
		this.invariant(value.length > 0, 'Array cannot be empty.', path);
		}
		else if (this.type === 'object') {
		this.invariant(Object.keys(value).length > 0, 'Object cannot be empty.', path);
		}
		}
		};
		/**
		* If contents are defined, return the type name using generics syntax.
		*/
		CollectionBuilder.prototype.typeAlias = function () {
		var contents = this.contents;
		var alias = _super.prototype.typeAlias.call(this);
		return contents ? alias + "<" + contents.typeAlias() + ">" : alias;
		};
		return CollectionBuilder;
		}(Builder_1.default));
		exports.default = CollectionBuilder;

		function array() {
		var contents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
		return new CollectionBuilder('array', contents, defaultValue);
		function array(contents, defaultValue) {
		if (contents === void 0) { contents = null; }
		if (defaultValue === void 0) { defaultValue = []; }
		return new CollectionBuilder('array', contents, defaultValue);
		}

		function object() {
		var contents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
		return new CollectionBuilder('object', contents, defaultValue);
		}
		exports.array = array;
		function object(contents, defaultValue) {
		if (contents === void 0) { contents = null; }
		if (defaultValue === void 0) { defaultValue = {}; }
		return new CollectionBuilder('object', contents, defaultValue);
		}
		exports.object = object;

215

lib/index.js

		"use strict";

		var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		var _exportNames = {
		Builder: true,
		bool: true,
		custom: true,
		func: true,
		CollectionBuilder: true,
		array: true,
		object: true,
		InstanceBuilder: true,
		instance: true,
		date: true,
		regex: true,
		NumberBuilder: true,
		number: true,
		ShapeBuilder: true,
		shape: true,
		StringBuilder: true,
		string: true,
		UnionBuilder: true,
		union: true
		};
		Object.defineProperty(exports, "Builder", {
		enumerable: true,
		get: function get() {
		return _Builder.default;
		}
		});
		Object.defineProperty(exports, "bool", {
		enumerable: true,
		get: function get() {
		return _Builder.bool;
		}
		});
		Object.defineProperty(exports, "custom", {
		enumerable: true,
		get: function get() {
		return _Builder.custom;
		}
		});
		Object.defineProperty(exports, "func", {
		enumerable: true,
		get: function get() {
		return _Builder.func;
		}
		});
		Object.defineProperty(exports, "CollectionBuilder", {
		enumerable: true,
		get: function get() {
		return _CollectionBuilder.default;
		}
		});
		Object.defineProperty(exports, "array", {
		enumerable: true,
		get: function get() {
		return _CollectionBuilder.array;
		}
		});
		Object.defineProperty(exports, "object", {
		enumerable: true,
		get: function get() {
		return _CollectionBuilder.object;
		}
		});
		Object.defineProperty(exports, "InstanceBuilder", {
		enumerable: true,
		get: function get() {
		return _InstanceBuilder.default;
		}
		});
		Object.defineProperty(exports, "instance", {
		enumerable: true,
		get: function get() {
		return _InstanceBuilder.instance;
		}
		});
		Object.defineProperty(exports, "date", {
		enumerable: true,
		get: function get() {
		return _InstanceBuilder.date;
		}
		});
		Object.defineProperty(exports, "regex", {
		enumerable: true,
		get: function get() {
		return _InstanceBuilder.regex;
		}
		});
		Object.defineProperty(exports, "NumberBuilder", {
		enumerable: true,
		get: function get() {
		return _NumberBuilder.default;
		}
		});
		Object.defineProperty(exports, "number", {
		enumerable: true,
		get: function get() {
		return _NumberBuilder.number;
		}
		});
		Object.defineProperty(exports, "ShapeBuilder", {
		enumerable: true,
		get: function get() {
		return _ShapeBuilder.default;
		}
		});
		Object.defineProperty(exports, "shape", {
		enumerable: true,
		get: function get() {
		return _ShapeBuilder.shape;
		}
		});
		Object.defineProperty(exports, "StringBuilder", {
		enumerable: true,
		get: function get() {
		return _StringBuilder.default;
		}
		});
		Object.defineProperty(exports, "string", {
		enumerable: true,
		get: function get() {
		return _StringBuilder.string;
		}
		});
		Object.defineProperty(exports, "UnionBuilder", {
		enumerable: true,
		get: function get() {
		return _UnionBuilder.default;
		}
		});
		Object.defineProperty(exports, "union", {
		enumerable: true,
		get: function get() {
		return _UnionBuilder.union;
		}
		});
		exports.default = void 0;

		var _optimal = _interopRequireDefault(require("./optimal"));

		var _Builder = _interopRequireWildcard(require("./Builder"));

		var _CollectionBuilder = _interopRequireWildcard(require("./CollectionBuilder"));

		var _InstanceBuilder = _interopRequireWildcard(require("./InstanceBuilder"));

		var _NumberBuilder = _interopRequireWildcard(require("./NumberBuilder"));

		var _ShapeBuilder = _interopRequireWildcard(require("./ShapeBuilder"));

		var _StringBuilder = _interopRequireWildcard(require("./StringBuilder"));

		var _UnionBuilder = _interopRequireWildcard(require("./UnionBuilder"));

		var _types = require("./types");

		Object.keys(_types).forEach(function (key) {
		if (key === "default" \|\| key === "__esModule") return;
		if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
		Object.defineProperty(exports, key, {
		enumerable: true,
		get: function get() {
		return _types[key];
		}
		});
		});

		/**
		@@ -180,3 +6,40 @@ * @copyright 2017, Miles Johnson
		*/
		var _default = _optimal.default;
		exports.default = _default;
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		var __importStar = (this && this.__importStar) \|\| function (mod) {
		if (mod && mod.__esModule) return mod;
		var result = {};
		if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
		result["default"] = mod;
		return result;
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var optimal_1 = __importDefault(require("./optimal"));
		var Builder_1 = __importStar(require("./Builder"));
		exports.Builder = Builder_1.default;
		exports.bool = Builder_1.bool;
		exports.custom = Builder_1.custom;
		exports.func = Builder_1.func;
		var CollectionBuilder_1 = __importStar(require("./CollectionBuilder"));
		exports.CollectionBuilder = CollectionBuilder_1.default;
		exports.array = CollectionBuilder_1.array;
		exports.object = CollectionBuilder_1.object;
		var InstanceBuilder_1 = __importStar(require("./InstanceBuilder"));
		exports.InstanceBuilder = InstanceBuilder_1.default;
		exports.instance = InstanceBuilder_1.instance;
		exports.date = InstanceBuilder_1.date;
		exports.regex = InstanceBuilder_1.regex;
		var NumberBuilder_1 = __importStar(require("./NumberBuilder"));
		exports.NumberBuilder = NumberBuilder_1.default;
		exports.number = NumberBuilder_1.number;
		var ShapeBuilder_1 = __importStar(require("./ShapeBuilder"));
		exports.ShapeBuilder = ShapeBuilder_1.default;
		exports.shape = ShapeBuilder_1.shape;
		var StringBuilder_1 = __importStar(require("./StringBuilder"));
		exports.StringBuilder = StringBuilder_1.default;
		exports.string = StringBuilder_1.string;
		var UnionBuilder_1 = __importStar(require("./UnionBuilder"));
		exports.UnionBuilder = UnionBuilder_1.default;
		exports.union = UnionBuilder_1.union;
		exports.default = optimal_1.default;

143

lib/InstanceBuilder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.instance = instance;
		exports.regex = regex;
		exports.date = date;
		exports.default = void 0;

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

		var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

		var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

		var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

		var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

		var _Builder2 = _interopRequireDefault(require("./Builder"));

		var _isObject = _interopRequireDefault(require("./isObject"));

		/**
		@@ -35,62 +6,70 @@ * @copyright 2017, Miles Johnson
		*/
		var InstanceBuilder = function (_Builder) {
		(0, _inherits2.default)(InstanceBuilder, _Builder);

		function InstanceBuilder() {
		var _this;

		var refClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
		(0, _classCallCheck2.default)(this, InstanceBuilder);
		_this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(InstanceBuilder).call(this, 'instance', null));
		(0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "refClass", null);

		_this.nullable();

		if ("production" !== process.env.NODE_ENV) {
		if (refClass) {
		_this.invariant(typeof refClass === 'function', 'A class reference is required.');
		}

		_this.refClass = refClass;

		_this.addCheck(_this.checkInstance, refClass);
		var __extends = (this && this.__extends) \|\| (function () {
		var extendStatics = function (d, b) {
		extendStatics = Object.setPrototypeOf \|\|
		({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
		function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
		return extendStatics(d, b);
		}

		return _this;
		}

		(0, _createClass2.default)(InstanceBuilder, [{
		key: "checkInstance",
		value: function checkInstance(path, value, refClass) {
		if ("production" !== process.env.NODE_ENV) {
		if (refClass) {
		this.invariant(typeof refClass === 'function' && value instanceof refClass, "Must be an instance of \"".concat(this.typeAlias(), "\"."), path);
		} else {
		this.invariant((0, _isObject.default)(value) && value.constructor !== Object, 'Must be a class instance.', path);
		return function (d, b) {
		extendStatics(d, b);
		function __() { this.constructor = d; }
		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
		})();
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		var isObject_1 = __importDefault(require("./isObject"));
		var InstanceBuilder = /** @class */ (function (_super) {
		__extends(InstanceBuilder, _super);
		function InstanceBuilder(refClass) {
		if (refClass === void 0) { refClass = null; }
		var _this = _super.call(this, 'instance', null) \|\| this;
		_this.refClass = null;
		// Nullable by default
		_this.nullable();
		if (__DEV__) {
		if (refClass) {
		_this.invariant(typeof refClass === 'function', 'A class reference is required.');
		}
		_this.refClass = refClass;
		_this.addCheck(_this.checkInstance, refClass);
		}
		}
		return _this;
		}
		}, {
		key: "typeAlias",
		value: function typeAlias() {
		var refClass = this.refClass;
		return refClass ? refClass.name \|\| refClass.constructor.name : 'class';
		}
		}]);
		return InstanceBuilder;
		}(_Builder2.default);

		InstanceBuilder.prototype.checkInstance = function (path, value, refClass) {
		if (__DEV__) {
		if (refClass) {
		this.invariant(typeof refClass === 'function' && value instanceof refClass, "Must be an instance of \"" + this.typeAlias() + "\".", path);
		}
		else {
		this.invariant(isObject_1.default(value) && value.constructor !== Object, 'Must be a class instance.', path);
		}
		}
		};
		/**
		* If reference class is defined, return the class name if available.
		*/
		InstanceBuilder.prototype.typeAlias = function () {
		var refClass = this.refClass;
		return refClass ? refClass.name \|\| refClass.constructor.name : 'class';
		};
		return InstanceBuilder;
		}(Builder_1.default));
		exports.default = InstanceBuilder;

		function instance() {
		var refClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
		return new InstanceBuilder(refClass);
		function instance(refClass) {
		if (refClass === void 0) { refClass = null; }
		return new InstanceBuilder(refClass);
		}

		exports.instance = instance;
		function regex() {
		return instance(RegExp);
		return instance(RegExp);
		}

		exports.regex = regex;
		function date() {
		return instance(Date);
		}
		return instance(Date);
		}
		exports.date = date;

lib/isObject.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = isObject;

		var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

		/**
		@@ -16,4 +6,9 @@ * @copyright 2017, Miles Johnson
		*/
		Object.defineProperty(exports, "__esModule", { value: true });
		/**
		* Return true if the value is a plain object.
		*/
		function isObject(value) {
		return (0, _typeof2.default)(value) === 'object' && value !== null && !Array.isArray(value);
		}
		return typeof value === 'object' && value !== null && !Array.isArray(value);
		}
		exports.default = isObject;

229

lib/NumberBuilder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.number = number;
		exports.default = void 0;

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

		var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

		var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

		var _Builder2 = _interopRequireDefault(require("./Builder"));

		/**
		@@ -27,120 +6,102 @@ * @copyright 2017, Miles Johnson
		*/
		var __extends = (this && this.__extends) \|\| (function () {
		var extendStatics = function (d, b) {
		extendStatics = Object.setPrototypeOf \|\|
		({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
		function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
		return extendStatics(d, b);
		}
		return function (d, b) {
		extendStatics(d, b);
		function __() { this.constructor = d; }
		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
		})();
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		function isNumber(value) {
		return typeof value === 'number';
		return typeof value === 'number';
		}

		var NumberBuilder = function (_Builder) {
		(0, _inherits2.default)(NumberBuilder, _Builder);

		function NumberBuilder() {
		var defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
		(0, _classCallCheck2.default)(this, NumberBuilder);
		return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(NumberBuilder).call(this, 'number', defaultValue));
		}

		(0, _createClass2.default)(NumberBuilder, [{
		key: "between",
		value: function between(min, max) {
		var inclusive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(isNumber(min) && isNumber(max), 'Between requires a minimum and maximum number.');
		}

		return this.addCheck(this.checkBetween, min, max, inclusive);
		var NumberBuilder = /** @class */ (function (_super) {
		__extends(NumberBuilder, _super);
		function NumberBuilder(defaultValue) {
		if (defaultValue === void 0) { defaultValue = 0; }
		return _super.call(this, 'number', defaultValue) \|\| this;
		}
		}, {
		key: "checkBetween",
		value: function checkBetween(path, value, min, max) {
		var inclusive = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(isNumber(value) && (inclusive ? value >= min && value <= max : value > min && value < max), "Number must be between ".concat(min, " and ").concat(max).concat(inclusive ? ' inclusive' : '', "."), path);
		}
		}
		}, {
		key: "gt",
		value: function gt(min) {
		var inclusive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(isNumber(min), 'Greater-than requires a minimum number.');
		}

		return this.addCheck(this.checkGreaterThan, min, inclusive);
		}
		}, {
		key: "gte",
		value: function gte(min) {
		return this.gt(min, true);
		}
		}, {
		key: "checkGreaterThan",
		value: function checkGreaterThan(path, value, min) {
		var inclusive = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

		if ("production" !== process.env.NODE_ENV) {
		if (inclusive) {
		this.invariant(isNumber(value) && value >= min, "Number must be greater than or equal to ".concat(min, "."), path);
		} else {
		this.invariant(isNumber(value) && value > min, "Number must be greater than ".concat(min, "."), path);
		NumberBuilder.prototype.between = function (min, max, inclusive) {
		if (inclusive === void 0) { inclusive = false; }
		if (__DEV__) {
		this.invariant(isNumber(min) && isNumber(max), 'Between requires a minimum and maximum number.');
		}
		}
		}
		}, {
		key: "lt",
		value: function lt(max) {
		var inclusive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(isNumber(max), 'Less-than requires a maximum number.');
		}

		return this.addCheck(this.checkLessThan, max, inclusive);
		}
		}, {
		key: "lte",
		value: function lte(max) {
		return this.lt(max, true);
		}
		}, {
		key: "checkLessThan",
		value: function checkLessThan(path, value, max) {
		var inclusive = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

		if ("production" !== process.env.NODE_ENV) {
		if (inclusive) {
		this.invariant(isNumber(value) && value <= max, "Number must be less than or equal to ".concat(max, "."), path);
		} else {
		this.invariant(isNumber(value) && value < max, "Number must be less than ".concat(max, "."), path);
		return this.addCheck(this.checkBetween, min, max, inclusive);
		};
		NumberBuilder.prototype.checkBetween = function (path, value, min, max, inclusive) {
		if (inclusive === void 0) { inclusive = false; }
		if (__DEV__) {
		this.invariant(isNumber(value) && (inclusive ? value >= min && value <= max : value > min && value < max), "Number must be between " + min + " and " + max + (inclusive ? ' inclusive' : '') + ".", path);
		}
		}
		}
		}, {
		key: "oneOf",
		value: function oneOf(list) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(Array.isArray(list) && list.length > 0 && list.every(function (item) {
		return isNumber(item);
		}), 'One of requires a non-empty array of numbers.');
		}

		return this.addCheck(this.checkOneOf, list);
		}
		}, {
		key: "checkOneOf",
		value: function checkOneOf(path, value, list) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(list.indexOf(value) >= 0, "Number must be one of: ".concat(list.join(', ')), path);
		}
		}
		}]);
		return NumberBuilder;
		}(_Builder2.default);

		};
		NumberBuilder.prototype.gt = function (min, inclusive) {
		if (inclusive === void 0) { inclusive = false; }
		if (__DEV__) {
		this.invariant(isNumber(min), 'Greater-than requires a minimum number.');
		}
		return this.addCheck(this.checkGreaterThan, min, inclusive);
		};
		NumberBuilder.prototype.gte = function (min) {
		return this.gt(min, true);
		};
		NumberBuilder.prototype.checkGreaterThan = function (path, value, min, inclusive) {
		if (inclusive === void 0) { inclusive = false; }
		if (__DEV__) {
		if (inclusive) {
		this.invariant(isNumber(value) && value >= min, "Number must be greater than or equal to " + min + ".", path);
		}
		else {
		this.invariant(isNumber(value) && value > min, "Number must be greater than " + min + ".", path);
		}
		}
		};
		NumberBuilder.prototype.lt = function (max, inclusive) {
		if (inclusive === void 0) { inclusive = false; }
		if (__DEV__) {
		this.invariant(isNumber(max), 'Less-than requires a maximum number.');
		}
		return this.addCheck(this.checkLessThan, max, inclusive);
		};
		NumberBuilder.prototype.lte = function (max) {
		return this.lt(max, true);
		};
		NumberBuilder.prototype.checkLessThan = function (path, value, max, inclusive) {
		if (inclusive === void 0) { inclusive = false; }
		if (__DEV__) {
		if (inclusive) {
		this.invariant(isNumber(value) && value <= max, "Number must be less than or equal to " + max + ".", path);
		}
		else {
		this.invariant(isNumber(value) && value < max, "Number must be less than " + max + ".", path);
		}
		}
		};
		NumberBuilder.prototype.oneOf = function (list) {
		if (__DEV__) {
		this.invariant(Array.isArray(list) && list.length > 0 && list.every(function (item) { return isNumber(item); }), 'One of requires a non-empty array of numbers.');
		}
		return this.addCheck(this.checkOneOf, list);
		};
		NumberBuilder.prototype.checkOneOf = function (path, value, list) {
		if (__DEV__) {
		this.invariant(list.indexOf(value) >= 0, "Number must be one of: " + list.join(', '), path);
		}
		};
		return NumberBuilder;
		}(Builder_1.default));
		exports.default = NumberBuilder;

		function number() {
		var defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
		return new NumberBuilder(defaultValue);
		}
		function number(defaultValue) {
		if (defaultValue === void 0) { defaultValue = 0; }
		return new NumberBuilder(defaultValue);
		}
		exports.number = number;

126

lib/optimal.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = optimal;

		var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

		var _Builder = _interopRequireDefault(require("./Builder"));

		var _isObject = _interopRequireDefault(require("./isObject"));

		var _typeOf = _interopRequireDefault(require("./typeOf"));

		/**
		@@ -22,49 +6,71 @@ * @copyright 2017, Miles Johnson
		*/
		function buildAndCheck(struct, blueprint) {
		var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
		var parentPath = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
		var unknownFields = (0, _objectSpread2.default)({}, struct);
		var builtStruct = {};
		Object.keys(blueprint).forEach(function (key) {
		var builder = blueprint[key];
		var path = parentPath ? "".concat(parentPath, ".").concat(key) : key;

		if (builder instanceof _Builder.default) {
		builtStruct[key] = builder.runChecks(path, struct[key], struct, options);
		} else if ((0, _isObject.default)(builder)) {
		builtStruct[key] = buildAndCheck(struct[key] \|\| {}, builder, options, path);
		} else if ("production" !== process.env.NODE_ENV) {
		throw new Error('Unknown blueprint. Must be a builder or plain object.');
		var __assign = (this && this.__assign) \|\| function () {
		__assign = Object.assign \|\| function(t) {
		for (var s, i = 1, n = arguments.length; i < n; i++) {
		s = arguments[i];
		for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		t[p] = s[p];
		}
		return t;
		};
		return __assign.apply(this, arguments);
		};
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		var isObject_1 = __importDefault(require("./isObject"));
		var typeOf_1 = __importDefault(require("./typeOf"));
		function buildAndCheck(struct, blueprint, options, parentPath) {
		if (options === void 0) { options = {}; }
		if (parentPath === void 0) { parentPath = ''; }
		var unknownFields = __assign({}, struct);
		var builtStruct = {};
		// Validate using the blueprint
		Object.keys(blueprint).forEach(function (key) {
		var builder = blueprint[key];
		var path = parentPath ? parentPath + "." + key : key;
		// Run validation checks
		if (builder instanceof Builder_1.default) {
		builtStruct[key] = builder.runChecks(path, struct[key], struct, options);
		// Builder is a plain object, so let's recursively try again
		}
		else if (isObject_1.default(builder)) {
		builtStruct[key] = buildAndCheck(struct[key] \|\| {}, builder, options, path);
		// Oops
		}
		else if (__DEV__) {
		throw new Error('Unknown blueprint. Must be a builder or plain object.');
		}
		// Delete the prop and mark it as known
		delete unknownFields[key];
		});
		// Handle unknown options
		if (options.unknown) {
		Object.assign(builtStruct, unknownFields);
		}

		delete unknownFields[key];
		});

		if (options.unknown) {
		Object.assign(builtStruct, unknownFields);
		} else if ("production" !== process.env.NODE_ENV) {
		var unknownKeys = Object.keys(unknownFields);

		if (unknownKeys.length > 0) {
		throw new Error("Unknown fields: ".concat(unknownKeys.join(', '), "."));
		else if (__DEV__) {
		var unknownKeys = Object.keys(unknownFields);
		if (unknownKeys.length > 0) {
		throw new Error("Unknown fields: " + unknownKeys.join(', ') + ".");
		}
		}
		}

		return builtStruct;
		return builtStruct;
		}

		function optimal(struct, blueprint) {
		var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

		if ("production" !== process.env.NODE_ENV) {
		if (!(0, _isObject.default)(struct)) {
		throw new TypeError("Optimal requires a plain object, found ".concat((0, _typeOf.default)(struct), "."));
		} else if (!(0, _isObject.default)(options)) {
		throw new TypeError('Optimal options must be a plain object.');
		} else if (!(0, _isObject.default)(blueprint)) {
		throw new TypeError('A blueprint is required.');
		function optimal(struct, blueprint, options) {
		if (options === void 0) { options = {}; }
		if (__DEV__) {
		if (!isObject_1.default(struct)) {
		throw new TypeError("Optimal requires a plain object, found " + typeOf_1.default(struct) + ".");
		}
		else if (!isObject_1.default(options)) {
		throw new TypeError('Optimal options must be a plain object.');
		}
		else if (!isObject_1.default(blueprint)) {
		throw new TypeError('A blueprint is required.');
		}
		}
		}

		return buildAndCheck(struct, blueprint, options);
		}
		return buildAndCheck(struct, blueprint, options);
		}
		exports.default = optimal;

lib/ShapeBuilder.d.ts

		@@ -6,3 +6,3 @@ /**
		import Builder from './Builder';
		import { Blueprint } from './types';
		import { Blueprint, Struct, OptimalOptions } from './types';
		export interface Shape {
		@@ -12,5 +12,6 @@ [key: string]: any;
		export default class ShapeBuilder extends Builder<Shape \| null> {
		contents: Blueprint;
		constructor(contents: Blueprint, defaultValue?: Shape \| null);
		checkContents(path: string, object: any, contents: Blueprint): void;
		runChecks(path: string, initialValue: any, struct: Struct, options?: OptimalOptions): any;
		}
		export declare function shape(contents: Blueprint, defaultValue?: Shape \| null): ShapeBuilder;

122

lib/ShapeBuilder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.shape = shape;
		exports.default = void 0;

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

		var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

		var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

		var _Builder2 = _interopRequireDefault(require("./Builder"));

		var _isObject = _interopRequireDefault(require("./isObject"));

		/**
		@@ -29,47 +6,60 @@ * @copyright 2017, Miles Johnson
		*/
		var ShapeBuilder = function (_Builder) {
		(0, _inherits2.default)(ShapeBuilder, _Builder);

		function ShapeBuilder(contents) {
		var _this;

		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
		(0, _classCallCheck2.default)(this, ShapeBuilder);
		_this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ShapeBuilder).call(this, 'shape', defaultValue));

		if ("production" !== process.env.NODE_ENV) {
		_this.invariant((0, _isObject.default)(contents) && Object.keys(contents).length > 0 && Object.keys(contents).every(function (key) {
		return contents[key] instanceof _Builder2.default;
		}), 'A non-empty object of properties to blueprints are required for a shape.');

		_this.addCheck(_this.checkContents, contents);
		var __extends = (this && this.__extends) \|\| (function () {
		var extendStatics = function (d, b) {
		extendStatics = Object.setPrototypeOf \|\|
		({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
		function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
		return extendStatics(d, b);
		}

		return _this;
		}

		(0, _createClass2.default)(ShapeBuilder, [{
		key: "checkContents",
		value: function checkContents(path, object, contents) {
		var _this2 = this;

		if ("production" !== process.env.NODE_ENV) {
		Object.keys(contents).forEach(function (key) {
		var builder = contents[key];

		if (builder instanceof _Builder2.default && (builder.isRequired \|\| typeof object[key] !== 'undefined')) {
		builder.runChecks("".concat(path, ".").concat(key), object[key], object, _this2.options);
		}
		return function (d, b) {
		extendStatics(d, b);
		function __() { this.constructor = d; }
		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
		})();
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		var isObject_1 = __importDefault(require("./isObject"));
		var ShapeBuilder = /** @class */ (function (_super) {
		__extends(ShapeBuilder, _super);
		function ShapeBuilder(contents, defaultValue) {
		if (defaultValue === void 0) { defaultValue = {}; }
		var _this = _super.call(this, 'shape', defaultValue) \|\| this;
		if (__DEV__) {
		_this.invariant(isObject_1.default(contents) &&
		Object.keys(contents).length > 0 &&
		Object.keys(contents).every(function (key) { return contents[key] instanceof Builder_1.default; }), 'A non-empty object of properties to blueprints are required for a shape.');
		}
		_this.contents = contents;
		return _this;
		}
		ShapeBuilder.prototype.runChecks = function (path, initialValue, struct, options) {
		var _this = this;
		if (options === void 0) { options = {}; }
		var value = {};
		var object = initialValue \|\| this.defaultValue \|\| {};
		if (__DEV__) {
		this.invariant(typeof object === 'object' && object, 'Value passed to shape must be an object.', path);
		}
		Object.keys(this.contents).forEach(function (key) {
		var builder = _this.contents[key];
		if (builder instanceof Builder_1.default) {
		value[key] = builder.runChecks(path + "." + key, object[key], object, options);
		}
		else {
		value[key] = object[key];
		}
		});
		}
		}
		}]);
		return ShapeBuilder;
		}(_Builder2.default);

		return value;
		};
		return ShapeBuilder;
		}(Builder_1.default));
		exports.default = ShapeBuilder;

		function shape(contents) {
		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
		return new ShapeBuilder(contents, defaultValue);
		}
		function shape(contents, defaultValue) {
		if (defaultValue === void 0) { defaultValue = {}; }
		return new ShapeBuilder(contents, defaultValue);
		}
		exports.shape = shape;

208

lib/StringBuilder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.string = string;
		exports.default = void 0;

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

		var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

		var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

		var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

		var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

		var _Builder2 = _interopRequireDefault(require("./Builder"));

		/**
		@@ -31,105 +6,90 @@ * @copyright 2017, Miles Johnson
		*/
		var __extends = (this && this.__extends) \|\| (function () {
		var extendStatics = function (d, b) {
		extendStatics = Object.setPrototypeOf \|\|
		({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
		function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
		return extendStatics(d, b);
		}
		return function (d, b) {
		extendStatics(d, b);
		function __() { this.constructor = d; }
		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
		})();
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		function isString(value) {
		return typeof value === 'string' && value !== '';
		return typeof value === 'string' && value !== '';
		}

		var StringBuilder = function (_Builder) {
		(0, _inherits2.default)(StringBuilder, _Builder);

		function StringBuilder() {
		var _this;

		var defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
		(0, _classCallCheck2.default)(this, StringBuilder);
		_this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(StringBuilder).call(this, 'string', defaultValue));
		(0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "allowEmpty", false);

		if ("production" !== process.env.NODE_ENV) {
		_this.addCheck(_this.checkNotEmpty);
		var StringBuilder = /** @class */ (function (_super) {
		__extends(StringBuilder, _super);
		function StringBuilder(defaultValue) {
		if (defaultValue === void 0) { defaultValue = ''; }
		var _this = _super.call(this, 'string', defaultValue) \|\| this;
		_this.allowEmpty = false;
		// Not empty by default
		if (__DEV__) {
		_this.addCheck(_this.checkNotEmpty);
		}
		return _this;
		}

		return _this;
		}

		(0, _createClass2.default)(StringBuilder, [{
		key: "contains",
		value: function contains(token) {
		var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(isString(token), 'Contains requires a non-empty string.');
		}

		return this.addCheck(this.checkContains, token, index);
		}
		}, {
		key: "checkContains",
		value: function checkContains(path, value, token) {
		var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;

		if ("production" !== process.env.NODE_ENV) {
		this.invariant(value.indexOf(token, index) >= 0, "String does not include \"".concat(token, "\"."), path);
		}
		}
		}, {
		key: "match",
		value: function match(pattern) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(pattern instanceof RegExp, 'Match requires a regular expression to match against.');
		}

		return this.addCheck(this.checkMatch, pattern);
		}
		}, {
		key: "checkMatch",
		value: function checkMatch(path, value, pattern) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(value.match(pattern), "String does not match pattern \"".concat(pattern.source, "\"."), path);
		}
		}
		}, {
		key: "empty",
		value: function empty() {
		if ("production" !== process.env.NODE_ENV) {
		this.allowEmpty = true;
		}

		return this;
		}
		}, {
		key: "checkNotEmpty",
		value: function checkNotEmpty(path, value) {
		if ("production" !== process.env.NODE_ENV) {
		if (!this.allowEmpty) {
		this.invariant(isString(value), 'String cannot be empty.', path);
		StringBuilder.prototype.contains = function (token, index) {
		if (index === void 0) { index = 0; }
		if (__DEV__) {
		this.invariant(isString(token), 'Contains requires a non-empty string.');
		}
		}
		}
		}, {
		key: "oneOf",
		value: function oneOf(list) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(Array.isArray(list) && list.length > 0 && list.every(function (item) {
		return isString(item);
		}), 'One of requires a non-empty array of strings.');
		}

		return this.addCheck(this.checkOneOf, list);
		}
		}, {
		key: "checkOneOf",
		value: function checkOneOf(path, value, list) {
		if ("production" !== process.env.NODE_ENV) {
		this.invariant(list.indexOf(value) >= 0, "String must be one of: ".concat(list.join(', ')), path);
		}
		}
		}]);
		return StringBuilder;
		}(_Builder2.default);

		return this.addCheck(this.checkContains, token, index);
		};
		StringBuilder.prototype.checkContains = function (path, value, token, index) {
		if (index === void 0) { index = 0; }
		if (__DEV__) {
		this.invariant(value.indexOf(token, index) >= 0, "String does not include \"" + token + "\".", path);
		}
		};
		StringBuilder.prototype.match = function (pattern) {
		if (__DEV__) {
		this.invariant(pattern instanceof RegExp, 'Match requires a regular expression to match against.');
		}
		return this.addCheck(this.checkMatch, pattern);
		};
		StringBuilder.prototype.checkMatch = function (path, value, pattern) {
		if (__DEV__) {
		this.invariant(value.match(pattern), "String does not match pattern \"" + pattern.source + "\".", path);
		}
		};
		StringBuilder.prototype.empty = function () {
		if (__DEV__) {
		this.allowEmpty = true;
		}
		return this;
		};
		StringBuilder.prototype.checkNotEmpty = function (path, value) {
		if (__DEV__) {
		if (!this.allowEmpty) {
		this.invariant(isString(value), 'String cannot be empty.', path);
		}
		}
		};
		StringBuilder.prototype.oneOf = function (list) {
		if (__DEV__) {
		this.invariant(Array.isArray(list) && list.length > 0 && list.every(function (item) { return isString(item); }), 'One of requires a non-empty array of strings.');
		}
		return this.addCheck(this.checkOneOf, list);
		};
		StringBuilder.prototype.checkOneOf = function (path, value, list) {
		if (__DEV__) {
		this.invariant(list.indexOf(value) >= 0, "String must be one of: " + list.join(', '), path);
		}
		};
		return StringBuilder;
		}(Builder_1.default));
		exports.default = StringBuilder;

		function string() {
		var defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
		return new StringBuilder(defaultValue);
		}
		function string(defaultValue) {
		if (defaultValue === void 0) { defaultValue = ''; }
		return new StringBuilder(defaultValue);
		}
		exports.string = string;

lib/typeOf.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = typeOf;

		var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

		var _isObject = _interopRequireDefault(require("./isObject"));

		/**
		@@ -18,23 +6,26 @@ * @copyright 2017, Miles Johnson
		*/
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var isObject_1 = __importDefault(require("./isObject"));
		// Not supported: Shape, Custom
		function typeOf(value) {
		if (Array.isArray(value)) {
		return value.every(function (item) {
		return (0, _typeof2.default)(item) === (0, _typeof2.default)(value[0]);
		}) ? 'array' : 'union';
		}

		if ((0, _isObject.default)(value)) {
		return value.constructor === Object ? 'object' : 'instance';
		}

		switch ((0, _typeof2.default)(value)) {
		case 'boolean':
		case 'function':
		case 'number':
		case 'string':
		return (0, _typeof2.default)(value);

		default:
		return 'unknown';
		}
		}
		if (Array.isArray(value)) {
		return value.every(function (item) { return typeof item === typeof value[0]; }) ? 'array' : 'union';
		}
		if (isObject_1.default(value)) {
		return value.constructor === Object ? 'object' : 'instance';
		}
		switch (typeof value) {
		case 'boolean':
		case 'function':
		case 'number':
		case 'string':
		// @ts-ignore
		return typeof value;
		default:
		return 'unknown';
		}
		}
		exports.default = typeOf;

lib/types.js

		@@ -1,1 +0,6 @@
		"use strict";
		"use strict";
		/**
		* @copyright 2017, Miles Johnson
		* @license https://opensource.org/licenses/MIT
		*/
		Object.defineProperty(exports, "__esModule", { value: true });

177

lib/UnionBuilder.js

		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.union = union;
		exports.default = void 0;

		var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

		var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

		var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

		var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

		var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

		var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

		var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

		var _Builder2 = _interopRequireDefault(require("./Builder"));

		var _typeOf = _interopRequireDefault(require("./typeOf"));

		/**
		@@ -33,76 +6,84 @@ * @copyright 2017, Miles Johnson
		*/
		var UnionBuilder = function (_Builder) {
		(0, _inherits2.default)(UnionBuilder, _Builder);

		function UnionBuilder(builders) {
		var _this;

		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
		(0, _classCallCheck2.default)(this, UnionBuilder);
		_this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(UnionBuilder).call(this, 'union', defaultValue));
		(0, _defineProperty2.default)((0, _assertThisInitialized2.default)((0, _assertThisInitialized2.default)(_this)), "builders", []);

		if ("production" !== process.env.NODE_ENV) {
		_this.invariant(Array.isArray(builders) && builders.length > 0 && builders.every(function (builder) {
		return builder instanceof _Builder2.default;
		}), 'A non-empty array of blueprints are required for a union.');

		_this.builders = builders;

		_this.addCheck(_this.checkUnions, builders);
		var __extends = (this && this.__extends) \|\| (function () {
		var extendStatics = function (d, b) {
		extendStatics = Object.setPrototypeOf \|\|
		({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) \|\|
		function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
		return extendStatics(d, b);
		}

		return _this;
		}

		(0, _createClass2.default)(UnionBuilder, [{
		key: "checkUnions",
		value: function checkUnions(path, value, builders) {
		var _this2 = this;

		if ("production" !== process.env.NODE_ENV) {
		var usage = {};
		var keys = [];
		var type = (0, _typeOf.default)(value);
		builders.forEach(function (builder) {
		if (usage[builder.type]) {
		_this2.invariant(false, "Multiple instances of \"".concat(builder.type, "\" are not supported."), path);
		} else if (builder.type === 'union') {
		_this2.invariant(false, 'Nested unions are not supported.', path);
		} else {
		usage[builder.type] = true;
		keys.push(builder.typeAlias());
		}
		});

		if (usage.shape && usage.object) {
		this.invariant(false, 'Objects and shapes within the same union are not supported.', path);
		return function (d, b) {
		extendStatics(d, b);
		function __() { this.constructor = d; }
		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
		})();
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		var Builder_1 = __importDefault(require("./Builder"));
		var typeOf_1 = __importDefault(require("./typeOf"));
		var UnionBuilder = /** @class */ (function (_super) {
		__extends(UnionBuilder, _super);
		function UnionBuilder(builders, defaultValue) {
		if (defaultValue === void 0) { defaultValue = null; }
		var _this = _super.call(this, 'union', defaultValue) \|\| this;
		_this.builders = [];
		if (__DEV__) {
		_this.invariant(Array.isArray(builders) &&
		builders.length > 0 &&
		builders.every(function (builder) { return builder instanceof Builder_1.default; }), 'A non-empty array of blueprints are required for a union.');
		_this.builders = builders;
		_this.addCheck(_this.checkUnions, builders);
		}

		var checked = false;
		builders.forEach(function (builder) {
		if (type === builder.type \|\| type === 'object' && builder.type === 'shape' \|\| builder.type === 'custom') {
		checked = true;
		builder.runChecks(path, value, _this2.currentStruct, _this2.options);
		}
		});
		this.invariant(checked, "Type must be one of: ".concat(keys.join(', ')), path);
		}
		return _this;
		}
		}, {
		key: "typeAlias",
		value: function typeAlias() {
		return this.builders.map(function (builder) {
		return builder.typeAlias();
		}).join(' \| ');
		}
		}]);
		return UnionBuilder;
		}(_Builder2.default);

		UnionBuilder.prototype.checkUnions = function (path, value, builders) {
		var _this = this;
		if (__DEV__) {
		var usage_1 = {};
		var keys_1 = [];
		var type_1 = typeOf_1.default(value);
		// Verify structure and usage
		builders.forEach(function (builder) {
		if (usage_1[builder.type]) {
		_this.invariant(false, "Multiple instances of \"" + builder.type + "\" are not supported.", path);
		}
		else if (builder.type === 'union') {
		_this.invariant(false, 'Nested unions are not supported.', path);
		}
		else {
		usage_1[builder.type] = true;
		keys_1.push(builder.typeAlias());
		}
		});
		if (usage_1.shape && usage_1.object) {
		this.invariant(false, 'Objects and shapes within the same union are not supported.', path);
		}
		// Run checks on value
		var checked_1 = false;
		builders.forEach(function (builder) {
		if (type_1 === builder.type \|\|
		(type_1 === 'object' && builder.type === 'shape') \|\|
		builder.type === 'custom') {
		checked_1 = true;
		builder.runChecks(path, value, _this.currentStruct, _this.options);
		}
		});
		this.invariant(checked_1, "Type must be one of: " + keys_1.join(', '), path);
		}
		};
		/**
		* Return the type name using generics syntax.
		*/
		UnionBuilder.prototype.typeAlias = function () {
		return this.builders.map(function (builder) { return builder.typeAlias(); }).join(' \| ');
		};
		return UnionBuilder;
		}(Builder_1.default));
		exports.default = UnionBuilder;

		function union(builders) {
		var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
		return new UnionBuilder(builders, defaultValue);
		}
		function union(builders, defaultValue) {
		if (defaultValue === void 0) { defaultValue = null; }
		return new UnionBuilder(builders, defaultValue);
		}
		exports.union = union;

package.json

		{
		"name": "optimal",
		"version": "1.1.1",
		"version": "1.1.2",
		"description": "A system for building and validating defined object structures.",
		@@ -8,7 +8,4 @@ "main": "./lib/index.js",
		"scripts": {
		"build": "beemo babel && beemo typescript --emitDeclarationOnly --no-clean",
		"build": "beemo typescript",
		"coverage": "yarn run jest --coverage",
		"docs": "gitbook build --debug",
		"docs:serve": "gitbook serve",
		"docs:install": "gitbook install",
		"eslint": "beemo eslint",
		@@ -48,4 +45,7 @@ "jest": "beemo jest",
		"homepage": "https://github.com/milesj/optimal#readme",
		"dependencies": {
		"@babel/runtime": "^7.1.2"
		},
		"devDependencies": {
		"@milesj/build-tools": "^0.0.9"
		"@milesj/build-tools": "^0.3.0"
		},
		@@ -64,6 +64,3 @@ "beemo": {
		"ie 11"
		],
		"dependencies": {
		"@babel/runtime": "^7.0.0"
		}
		]
		}

.gitbook.yaml

.vscode/settings.json

types/global.d.ts

yarn.lock

optimal - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes