"use strict";
/*
Copyright 2022 Salehen Shovon Rahman

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
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 __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validate = exports.fallback = exports.intersection = exports.chain = exports.replaceError = exports.predicate = exports.transform = exports.TransformError = exports.lazy = exports.unknown = exports.any = exports.object = exports.keyOf = exports.KeyNotExistError = exports.ValueIsNullError = exports.ValueIsUndefinedError = exports.objectOf = exports.BadObjectError = exports.arrayOf = exports.ArrayOfInvalidValuesError = exports.boolean = exports.number = exports.exact = exports.string = exports.UnexpectedTypeofError = exports.except = exports.UnexpectedValueError = exports.tuple = exports.exclude = exports.ExcludeError = exports.either = exports.UnexpectedArrayLengthError = exports.NotAnArrayError = exports.TupleError = exports.EitherError = exports.ValidationError = void 0;
/**
 * A base abstract class that represents a generic validation error.
 */
var ValidationError = /** @class */ (function (_super) {
    __extends(ValidationError, _super);
    /**
     *
     * @param type A string representing what type of validation error that the
     *   error represents
     * @param errorMessage Some detail regarding the nature of the error
     * @param value The original value that triggered the validation error
     */
    function ValidationError(type, errorMessage, value) {
        var _this = _super.call(this, errorMessage) || this;
        _this.type = type;
        _this.errorMessage = errorMessage;
        _this.value = value;
        return _this;
    }
    return ValidationError;
}(Error));
exports.ValidationError = ValidationError;
var EitherError = /** @class */ (function (_super) {
    __extends(EitherError, _super);
    function EitherError(value, validationResults) {
        var _this = _super.call(this, "Either error", "The provided value does not match any of the possible validators", value) || this;
        _this.validationResults = validationResults;
        return _this;
    }
    return EitherError;
}(ValidationError));
exports.EitherError = EitherError;
var TupleError = /** @class */ (function (_super) {
    __extends(TupleError, _super);
    function TupleError(value, validationResults) {
        var _this = _super.call(this, "Tuple error", "The supplied tuple had ".concat(validationResults.filter(function (validation) { return !validation.isValid; }), " issues"), value) || this;
        _this.validationResults = validationResults;
        return _this;
    }
    return TupleError;
}(ValidationError));
exports.TupleError = TupleError;
var NotAnArrayError = /** @class */ (function (_super) {
    __extends(NotAnArrayError, _super);
    function NotAnArrayError(value) {
        return _super.call(this, "Not an array error", "Expected an array, but instead got something else", value) || this;
    }
    return NotAnArrayError;
}(ValidationError));
exports.NotAnArrayError = NotAnArrayError;
var UnexpectedArrayLengthError = /** @class */ (function (_super) {
    __extends(UnexpectedArrayLengthError, _super);
    function UnexpectedArrayLengthError(value, expectedLength) {
        var _this = _super.call(this, "Unexpected array length error", "Expected an array of length ".concat(expectedLength, " but instead got ").concat(value.length), value) || this;
        _this.expectedLength = expectedLength;
        return _this;
    }
    return UnexpectedArrayLengthError;
}(ValidationError));
exports.UnexpectedArrayLengthError = UnexpectedArrayLengthError;
/**
 * A validator for validating objects against a list of validators.
 *
 * This is especially useful if a possible object has more than one possible
 * valid type.
 *
 * ## Usage
 *
 * ```typescript
 * const alts = alternatives(string(), number());
 *
 * const num = 10;
 * const str = "hello";
 * const bool = true;
 *
 * console.log(alts.validate(num).valid); // Should be true
 * console.log(alts.validate(str).valid); // Should be true
 * console.log(alts.validate(bool).valid); // Should be false
 * ```
 * @param alts A list of validators that are to be run
 * @returns A validator to validate an object against a set of validators
 */
function either() {
    var alts = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        alts[_i] = arguments[_i];
    }
    return {
        validate: function (value) {
            var validations = alts.map(function (validator) { return validator.validate(value); });
            return validations.some(function (validation) { return validation.isValid; })
                ? {
                    isValid: true,
                    value: validations.filter(function (v) { return v.isValid; })[0].value,
                }
                : {
                    isValid: false,
                    error: new EitherError(value, validations),
                };
        },
    };
}
exports.either = either;
var ExcludeError = /** @class */ (function (_super) {
    __extends(ExcludeError, _super);
    function ExcludeError(value, validationResults) {
        var _this = _super.call(this, "Exclude error", "Value includes a value that it shouldn't", value) || this;
        _this.validationResults = validationResults;
        return _this;
    }
    return ExcludeError;
}(ValidationError));
exports.ExcludeError = ExcludeError;
/**
 * A validator that validates if a value does not validate against another
 * validator.
 *
 * Similar to TypeScript's `Exclude` utility type.
 * @param a The validation to include
 * @param b The validation to exclude
 * @returns A validator where it validates if value validates with `a` but does
 *   not validate against `b`.
 */
function exclude(a, b) {
    return {
        validate: function (value) {
            var aValidation = a.validate(value);
            var bValidation = b.validate(value);
            if (aValidation.isValid && !bValidation.isValid) {
                return {
                    isValid: true,
                    value: aValidation.value,
                };
            }
            return {
                isValid: false,
                error: new ExcludeError("Exclude error", value),
            };
        },
    };
}
exports.exclude = exclude;
/**
 * Used to validate a tuple against the individual values in an array.
 *
 * ## Usage
 *
 * ```typescript
 * const tup = tuple(string(), number());
 *
 * alts.validate(["a", 1]).isValid // will be true
 * alts.validate([1, "a"]).isValid // will be false
 * alts.validate([1]).isValid // will be false
 * ```
 * @param t The tuple of validators to validate a tuple against
 * @returns A validator to validate tuples
 */
function tuple(t) {
    return {
        validate: function (value) {
            if (!Array.isArray(value)) {
                return {
                    isValid: false,
                    error: new NotAnArrayError(value),
                };
            }
            if (t.length !== value.length) {
                return {
                    isValid: false,
                    error: new UnexpectedArrayLengthError(value, t.length),
                };
            }
            var validations = t.map(function (validator, i) { return validator.validate(value[i]); });
            return validations.every(function (validation) { return validation.isValid; })
                ? {
                    isValid: true,
                    value: validations.map(function (v) { return v.isValid && v.value; }),
                }
                : {
                    isValid: false,
                    error: new TupleError(value, validations.filter(function (validation) { return !validation.isValid; })),
                };
        },
    };
}
exports.tuple = tuple;
var UnexpectedValueError = /** @class */ (function (_super) {
    __extends(UnexpectedValueError, _super);
    function UnexpectedValueError(value) {
        return _super.call(this, "Unexpected value error", "The supplied value is not allowed", value) || this;
    }
    return UnexpectedValueError;
}(ValidationError));
exports.UnexpectedValueError = UnexpectedValueError;
/**
 * Creates a validator for an object that rejects all values that passes the
 * invalidator.
 *
 * This validator is especially useful for cases where a value can be a string,
 * except for specific strings.
 *
 * For example:
 *
 * ```
 *const everythingButValidator = except(string(), exact("but"));
 *
 * everythingButValidator.validate("apples").isValid; // ✅
 * everythingButValidator.validate("bananas").isValid; // ✅
 * everythingButValidator.validate("cherries").isValid; // ✅
 * everythingButValidator.validate("but").isValid; // ❌
 * ```
 * @param validator The validator for which to validate the value against
 * @param invalidator The validator for which if is valid, the value will be
 *   rejected
 * @returns A Validator that will reject all values for which the invalidator
 *   validates the object
 */
function except(validator, invalidator) {
    return {
        validate: function (value) {
            var validation = validator.validate(value);
            if (validation.isValid === false) {
                return { isValid: false, error: validation.error };
            }
            return validation.isValid && !invalidator.validate(value).isValid
                ? { isValid: true, value: validation.value }
                : { isValid: false, error: new UnexpectedValueError(value) };
        },
    };
}
exports.except = except;
function _v(v) {
    return typeof v;
}
var _s = _v({});
var UnexpectedTypeofError = /** @class */ (function (_super) {
    __extends(UnexpectedTypeofError, _super);
    function UnexpectedTypeofError(value, expectedType) {
        var _this = _super.call(this, "Unexpected typeof", "Expected a value of type ".concat(expectedType, ", but got something else"), value) || this;
        _this.expectedType = expectedType;
        return _this;
    }
    return UnexpectedTypeofError;
}(ValidationError));
exports.UnexpectedTypeofError = UnexpectedTypeofError;
/**
 * Creates a validator that determines if the supplied value is a string.
 * @returns A validator to check if the value is of type string
 */
var string = function () {
    return {
        validate: function (value) {
            return typeof value !== "string"
                ? { isValid: false, error: new UnexpectedTypeofError(value, "string") }
                : { value: value, isValid: true };
        },
    };
};
exports.string = string;
var NotExactValueError = /** @class */ (function (_super) {
    __extends(NotExactValueError, _super);
    function NotExactValueError(value, expectedValue) {
        var _this = _super.call(this, "Incorrect value", "Expected the value to equal exactly ".concat(expectedValue, " but instead got something else"), value) || this;
        _this.expectedValue = expectedValue;
        return _this;
    }
    return NotExactValueError;
}(ValidationError));
/**
 * Creates a validator that validates values that match the expected value
 * exactly.
 * @param expected The exact value to be expected
 * @returns A validator that will only validate values that match exactly the
 *   expected value
 */
function exact(expected) {
    return {
        validate: function (value) {
            return Object.is(value, expected)
                ? { value: value, isValid: true }
                : { isValid: false, error: new NotExactValueError(value, expected) };
        },
    };
}
exports.exact = exact;
/**
 * Creates a validator that determines if the supplied value is a number.
 * @returns A validator to check if the value is of type number
 */
var number = function () { return ({
    validate: function (value) {
        return typeof value !== "number"
            ? { isValid: false, error: new UnexpectedTypeofError(value, "number") }
            : { value: value, isValid: true };
    },
}); };
exports.number = number;
/**
 * Creates a validator that determines if the supplied value is a boolean.
 * @returns A validator to check if the value is of type boolean
 */
var boolean = function () { return ({
    validate: function (value) {
        return typeof value !== "boolean"
            ? { isValid: false, error: new UnexpectedTypeofError(value, "boolean") }
            : { value: value, isValid: true };
    },
}); };
exports.boolean = boolean;
var ArrayOfInvalidValuesError = /** @class */ (function (_super) {
    __extends(ArrayOfInvalidValuesError, _super);
    function ArrayOfInvalidValuesError(value, errors) {
        var _this = _super.call(this, "Array of invalid values", "".concat(errors.length, " of the ").concat(value.length, " are invalid"), value) || this;
        _this.badValues = errors;
        return _this;
    }
    return ArrayOfInvalidValuesError;
}(ValidationError));
exports.ArrayOfInvalidValuesError = ArrayOfInvalidValuesError;
/**
 * Creates a validator that determines if the supplied value is an array of the
 * specified validator.
 * @param validator The validator to validate the individual array values
 *   against
 * @returns A validator to check if the value is an array of the specified
 *   validator
 */
function arrayOf(validator) {
    return {
        validate: function (value) {
            if (!Array.isArray(value)) {
                return { isValid: false, error: new NotAnArrayError(value) };
            }
            var validations = value.map(function (v) { return validator.validate(v); });
            return validations.every(function (_a) {
                var isValid = _a.isValid;
                return isValid;
            })
                ? {
                    value: validations.map(function (validation) { return validation.value; }),
                    isValid: true,
                }
                : {
                    isValid: false,
                    error: new ArrayOfInvalidValuesError(value, validations
                        .map(function (v, i) { return ({ index: i, validation: v }); })
                        .filter(function (_a) {
                        var validation = _a.validation;
                        return !validation.isValid;
                    })),
                };
        },
    };
}
exports.arrayOf = arrayOf;
var BadObjectError = /** @class */ (function (_super) {
    __extends(BadObjectError, _super);
    function BadObjectError(value, faultyFields) {
        var _this = _super.call(this, "Bad object", "The supplied object had fields that failed to validate", value) || this;
        _this.faultyFields = faultyFields;
        return _this;
    }
    return BadObjectError;
}(ValidationError));
exports.BadObjectError = BadObjectError;
function mergeObjects(objects) {
    var e_1, _a, e_2, _b;
    var result = {};
    try {
        for (var objects_1 = __values(objects), objects_1_1 = objects_1.next(); !objects_1_1.done; objects_1_1 = objects_1.next()) {
            var object_1 = objects_1_1.value;
            try {
                for (var _c = (e_2 = void 0, __values(Object.entries(object_1))), _d = _c.next(); !_d.done; _d = _c.next()) {
                    var _e = __read(_d.value, 2), key = _e[0], value = _e[1];
                    result[key] = value;
                }
            }
            catch (e_2_1) { e_2 = { error: e_2_1 }; }
            finally {
                try {
                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
                }
                finally { if (e_2) throw e_2.error; }
            }
        }
    }
    catch (e_1_1) { e_1 = { error: e_1_1 }; }
    finally {
        try {
            if (objects_1_1 && !objects_1_1.done && (_a = objects_1.return)) _a.call(objects_1);
        }
        finally { if (e_1) throw e_1.error; }
    }
    return result;
}
/**
 * Creates a validator that determines if the supplied value is an object, whose
 * fields contains are of nothing but types as defined by the specified
 * validator.
 * @param validator The validator to validate the individual fields in the
 *   object
 * @returns A validator that determines if the supplied value is an object,
 *   whose fields contains are of nothing but types as defined by the specified
 *   validator.
 */
function objectOf(validator) {
    return {
        validate: function (value) {
            if (value === undefined) {
                return { isValid: false, error: new ValueIsUndefinedError() };
            }
            if (value === null) {
                return { isValid: false, error: new ValueIsNullError() };
            }
            if (typeof value !== "object") {
                return {
                    isValid: false,
                    error: new UnexpectedTypeofError(value, "object"),
                };
            }
            var fields = Object.keys(value).map(function (key) { return ({
                key: key,
                validation: validator.validate(value[key]),
            }); });
            return fields.every(function (_a) {
                var validation = _a.validation;
                return validation.isValid;
            })
                ? {
                    value: fields
                        .map(function (_a) {
                        var _b;
                        var key = _a.key, validation = _a.validation;
                        return (_b = {},
                            _b[key] = validation.value,
                            _b);
                    })
                        .reduce(function (prev, next) { return Object.assign(prev, next); }, {}),
                    isValid: true,
                }
                : {
                    isValid: false,
                    error: new BadObjectError(value, mergeObjects(fields
                        .filter(function (_a) {
                        var validation = _a.validation;
                        return !validation.isValid;
                    })
                        .map(function (_a) {
                        var _b;
                        var key = _a.key, validation = _a.validation;
                        return (_b = {}, _b[key] = validation, _b);
                    }))),
                };
        },
    };
}
exports.objectOf = objectOf;
var ValueIsUndefinedError = /** @class */ (function (_super) {
    __extends(ValueIsUndefinedError, _super);
    function ValueIsUndefinedError() {
        return _super.call(this, "Value is undefined", "The supplied value is undefined, when it should have been something else", undefined) || this;
    }
    return ValueIsUndefinedError;
}(ValidationError));
exports.ValueIsUndefinedError = ValueIsUndefinedError;
var ValueIsNullError = /** @class */ (function (_super) {
    __extends(ValueIsNullError, _super);
    function ValueIsNullError() {
        return _super.call(this, "Value is null", "The supplied value is null, when it should have been something else", null) || this;
    }
    return ValueIsNullError;
}(ValidationError));
exports.ValueIsNullError = ValueIsNullError;
function objectEntries(o) {
    return Object.entries(o);
}
var KeyNotExistError = /** @class */ (function (_super) {
    __extends(KeyNotExistError, _super);
    function KeyNotExistError(key) {
        var _this = _super.call(this, "Key does not exist in object", "The supplied key ".concat(key, " does not exist in the supplied object"), undefined) || this;
        _this.key = key;
        return _this;
    }
    return KeyNotExistError;
}(ValidationError));
exports.KeyNotExistError = KeyNotExistError;
function keyOf(o) {
    return {
        validate: function (value) {
            if (typeof o !== "object" || o === null) {
                return {
                    isValid: false,
                    error: new UnexpectedTypeofError(o, "object"),
                };
            }
            if (!Object.keys(o).includes(value)) {
                return {
                    isValid: false,
                    error: new KeyNotExistError(value),
                };
            }
            return {
                isValid: true,
                value: value
            };
        },
    };
}
exports.keyOf = keyOf;
/**
 * Creates a validator for an object, specified by the "schema".
 *
 * Each field in the "schema" is a validator, and each of them will validate
 * values against objects in concern.
 * @param shape An object containing fields of nothing but validators, each of
 *   which will be used to validate the value's respective fields
 * @returns A validator that will validate an object against the `schema`
 */
function object(shape) {
    return {
        validate: function (value) {
            if (value === undefined) {
                return { isValid: false, error: new ValueIsUndefinedError() };
            }
            if (value === null) {
                return { isValid: false, error: new ValueIsNullError() };
            }
            if (typeof value !== "object") {
                return {
                    isValid: false,
                    error: new UnexpectedTypeofError(value, "object"),
                };
            }
            var fields = Object.keys(shape).map(function (key) { return ({
                key: key,
                validation: shape[key].validate(value[key]),
            }); });
            return fields.every(function (_a) {
                var validation = _a.validation;
                return validation.isValid;
            })
                ? {
                    value: Object.assign(__assign({}, value), fields
                        .filter(function (_a) {
                        var validation = _a.validation;
                        return !!validation.value;
                    })
                        .map(function (_a) {
                        var _b;
                        var key = _a.key, validation = _a.validation;
                        return (_b = {},
                            _b[key] = validation.value,
                            _b);
                    })
                        .reduce(function (prev, next) { return Object.assign(prev, next); }, {})),
                    isValid: true,
                }
                : {
                    isValid: false,
                    error: new BadObjectError(value, mergeObjects(fields
                        .filter(function (_a) {
                        var validation = _a.validation;
                        return !validation.isValid;
                    })
                        .map(function (_a) {
                        var _b;
                        var key = _a.key, validation = _a.validation;
                        return (_b = {}, _b[key] = validation, _b);
                    }))),
                };
        },
        get partial() {
            var e_3, _a;
            var partialSchema = {};
            try {
                for (var _b = __values(objectEntries(shape)), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var _d = __read(_c.value, 2), key = _d[0], validator = _d[1];
                    partialSchema[key] = either(validator, exact(undefined));
                }
            }
            catch (e_3_1) { e_3 = { error: e_3_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_3) throw e_3.error; }
            }
            return object(partialSchema);
        },
        shape: shape,
        omit: function () { return object(shape); },
        pick: function () { return object(shape); },
        get required() {
            var e_4, _a;
            var requiredSchema = {};
            try {
                for (var _b = __values(Object.entries(shape)), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var _d = __read(_c.value, 2), key = _d[0], validator = _d[1];
                    var k = key;
                    requiredSchema[k] = exclude(validator, either(exact(undefined), exact(null)));
                }
            }
            catch (e_4_1) { e_4 = { error: e_4_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_4) throw e_4.error; }
            }
            return object(requiredSchema);
        },
    };
}
exports.object = object;
/**
 * Creates a validator that where the validation function will never determine
 * that a value is invalid
 * @returns A validator that will validate *all* objects
 */
function any() {
    return {
        validate: function (value) { return ({ isValid: true, value: value }); },
    };
}
exports.any = any;
/**
 * Creates a validator that where the validation function will never determine
 * that a value is invalid
 * @returns A validator that will validate *all* objects
 */
function unknown() {
    return {
        validate: function (value) { return ({ isValid: true, value: value }); },
    };
}
exports.unknown = unknown;
/**
 * Creates a validator that lazily evaluates the callback, at every validation.
 *
 * Useful for recursive types, such as a node for a tree.
 * @param schemaFn A function that returns a validator
 * @returns A validator, effectively just a "forwarding" of the validator
 *   returned by the `schemaFn`
 */
function lazy(schemaFn) {
    return {
        validate: function (value) { return schemaFn().validate(value); },
    };
}
exports.lazy = lazy;
var TransformError = /** @class */ (function (_super) {
    __extends(TransformError, _super);
    function TransformError(value, errorObject) {
        var _this = _super.call(this, "Parsing error", "Failed to parse the value", value) || this;
        _this.errorObject = errorObject;
        return _this;
    }
    return TransformError;
}(ValidationError));
exports.TransformError = TransformError;
/**
 * Creates a validator that will parse the supplied value
 *
 * @param parse The parser function that will parse the supplied value
 * @returns A validator to validate the value against
 */
var transform = function (parse) { return ({
    validate: function (value) {
        try {
            return { isValid: true, value: parse(value) };
        }
        catch (e) {
            return { isValid: false, error: new TransformError(value, e) };
        }
    },
}); };
exports.transform = transform;
var PredicateError = /** @class */ (function (_super) {
    __extends(PredicateError, _super);
    function PredicateError(value) {
        return _super.call(this, "Predicate failure", "The predicate failed to match", value) || this;
    }
    return PredicateError;
}(ValidationError));
/**
 * A validator creator that also accepts a predicate
 * @param validator The validator to run the predicate against
 * @param pred The predicate to run against the value
 * @returns A Validator, where if the predicate were to fail, it will result in
 *   a failed validation
 */
function predicate(validator, pred) {
    return {
        validate: function (value) {
            var validation = validator.validate(value);
            return validation.isValid === false
                ? validation
                : pred(validation.value)
                    ? { isValid: true, value: validation.value }
                    : { isValid: false, error: new PredicateError(value) };
        },
    };
}
exports.predicate = predicate;
/**
 * A Validator creator that substitutes the error from one validator, to another
 * error for that validator.
 * @param validator The validator for which to have the error substituted
 * @param createError An error function that will return the appropriate error
 *   object
 * @returns A validator
 */
function replaceError(validator, createError) {
    return {
        validate: function (value) {
            var validation = validator.validate(value);
            return validation.isValid === false
                ? { isValid: false, error: createError(value, validation.error) }
                : { isValid: true, value: validation.value };
        },
    };
}
exports.replaceError = replaceError;
/**
 * Chains two validators together.
 * @param left the first validator to validate values against
 * @param right the second validator to validate values against
 * @returns a validator that will validate first against the first validator
 *   then the second validator
 */
var chain = function (left, right) { return ({
    validate: function (value) {
        var validation = left.validate(value);
        return validation.isValid === false
            ? { isValid: false, error: validation.error }
            : right.validate(validation.value);
    },
}); };
exports.chain = chain;
/**
 * Gets the intersection of two validators
 * @param a The first validator to validate the object against
 * @param b The second validator to validate the object against
 * @returns A validator that is the intersection of the types represented by
 *   validators a and b
 */
var intersection = function (a, b) { return ({
    validate: function (value) {
        var validation1 = a.validate(value);
        if (validation1.isValid === false) {
            return { isValid: false, error: validation1.error };
        }
        var validation2 = b.validate(validation1.value);
        return (validation2.isValid === false
            ? { isValid: false, error: validation2.error }
            : { isValid: true, value: validation2.value });
    },
}); };
exports.intersection = intersection;
/**
 * Creates a validator that can fallback to another value.
 * @param validator The validator that, if failed, will need a fallback
 * @param getFallback The function to acquire the fallback value
 * @returns A validator that should never be invalid
 */
var fallback = function (validator, getFallback) { return ({
    validate: function (value) {
        var validation = validator.validate(value);
        return validation.isValid === false
            ? { isValid: true, value: getFallback() }
            : validation;
    },
}); };
exports.fallback = fallback;
/**
 * This function validates and returns the parsed value. If validation failed,
 * it will throw a runtime exception
 * @param validator A validator to run the validation against the supplied value
 * @param value The value to run the validation against
 * @returns The outcome of the validation
 */
var validate = function (validator, value) {
    var result = validator.validate(value);
    if (result.isValid === false) {
        throw result.error;
    }
    return result.value;
};
exports.validate = validate;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lib.js","sourceRoot":"","sources":["../lib.ts"],"names":[],"mappings":"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"}