knight-validation 2.0.0 → 2.0.3

package/lib/lib/Validator.js

@@ -8,432 +8,133 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Constraint_1 = require("./Constraint");
-var QuickConstraint_1 = require("./constraints/QuickConstraint");
-var fieldsEqual_1 = require("./fieldsEqual");
-var Validator = /** @class */ (function () {
-    function Validator(options) {
-        this.fieldConstraints = [];
+exports.Validator = void 0;
+const Constraint_1 = require("./Constraint");
+const QuickConstraint_1 = require("./QuickConstraint");
+class Validator {
+    constructor(options) {
+        this.entries = [];
         this.options = options;
     }
-    Validator.prototype.add = function (arg0, arg1, arg2, arg3) {
-        if (arg0 instanceof Validator) {
-            var validator = arg0;
-            for (var _i = 0, _a = validator.fieldConstraints; _i < _a.length; _i++) {
-                var fieldConstraint = _a[_i];
-                this.fieldConstraints.push(fieldConstraint);
+    add(...args) {
+        if (args[0] instanceof Validator) {
+            let validator = args[0];
+            for (let propertyConstraint of validator.entries) {
+                this.entries.push(propertyConstraint);
             }
         }
         else {
-            var field = arg0;
-            var constraint = void 0;
-            var condition = void 0;
-            if (typeof arg1 == 'string') {
-                constraint = new QuickConstraint_1.default(arg1, arg2);
-                condition = arg3;
-            }
-            else if (arg1 instanceof Constraint_1.default) {
-                constraint = arg1;
-                condition = arg2;
-            }
-            else if (arg1 instanceof Validator) {
-                constraint = arg1;
-                condition = arg2;
+            let properties = typeof args[0] == 'string' ? [args[0]] : args[0];
+            let constraint = undefined;
+            let validator = undefined;
+            let condition;
+            if (typeof args[1] == 'string') {
+                constraint = new QuickConstraint_1.QuickConstraint(args[1], args[2]);
+                condition = args.length > 3 ? args[3] : undefined;
+            }
+            else if (args[1] instanceof Constraint_1.Constraint) {
+                constraint = args[1];
+                condition = args.length > 2 ? args[2] : undefined;
+            }
+            else if (args[1] instanceof Validator) {
+                validator = args[1];
+                condition = args.length > 2 ? args[2] : undefined;
             }
             else {
                 throw new Error('Wrong parameters');
             }
-            this.fieldConstraints.push(new FieldConstraint(field, constraint, condition));
+            this.entries.push({
+                properties: properties,
+                constraint: constraint,
+                validator: validator,
+                condition: condition
+            });
         }
-    };
-    Object.defineProperty(Validator.prototype, "fields", {
-        get: function () {
-            var fields = [];
-            for (var _i = 0, _a = this.fieldConstraints; _i < _a.length; _i++) {
-                var fieldConstraint = _a[_i];
-                if (fieldConstraint.field != undefined) {
-                    fields.push(fieldConstraint.field);
-                }
-                else if (fieldConstraint.fields != undefined) {
-                    fields.push(fieldConstraint.fields);
-                }
-            }
-            return fields;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Validator.prototype, "singleFields", {
-        get: function () {
-            var fields = [];
-            for (var _i = 0, _a = this.fieldConstraints; _i < _a.length; _i++) {
-                var fieldConstraint = _a[_i];
-                if (fieldConstraint.field != undefined && fields.indexOf(fieldConstraint.field) == -1) {
-                    fields.push(fieldConstraint.field);
+    }
+    validate(object, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            options = options || this.options;
+            let misfits = [];
+            let misfittingProperties = [];
+            for (let entry of this.entries) {
+                let propertyAlreadyHasAMisfit = false;
+                for (let property of entry.properties) {
+                    if (misfittingProperties.indexOf(property) > -1) {
+                        propertyAlreadyHasAMisfit = true;
+                        break;
+                    }
                 }
-            }
-            return fields;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Validator.prototype, "combinedFields", {
-        get: function () {
-            var fields = [];
-            var _loop_1 = function (fieldConstraint) {
-                if (fieldConstraint.fields != undefined && !fields.some(function (fields) { return fieldsEqual_1.default(fields, fieldConstraint.fields); })) {
-                    fields.push(fieldConstraint.fields);
+                if (propertyAlreadyHasAMisfit) {
+                    continue;
                 }
-            };
-            for (var _i = 0, _a = this.fieldConstraints; _i < _a.length; _i++) {
-                var fieldConstraint = _a[_i];
-                _loop_1(fieldConstraint);
-            }
-            return fields;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Validator.prototype.constraints = function (field) {
-        var fieldConstraints = [];
-        for (var _i = 0, _a = this.fieldConstraints; _i < _a.length; _i++) {
-            var fieldConstraint = _a[_i];
-            if (field === fieldConstraint.field) {
-                fieldConstraints.push(fieldConstraint);
-            }
-            else if (field instanceof Array && fieldConstraint.fields && fieldsEqual_1.default(field, fieldConstraint.fields)) {
-                fieldConstraints.push(fieldConstraint);
-            }
-        }
-        return fieldConstraints;
-    };
-    Validator.prototype.validate = function (object, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var misfits, misfittingFields, _i, _a, field, constraints, _b, constraints_1, constraint, _c, misfit, fieldValue, subMisfits, _d, subMisfits_1, misfit, _e, _f, fields, oneOfTheFieldsAlreadyHasAMisfit, _g, fields_1, field, atLeastOneOfTheFieldsMissingInObject, _h, fields_2, field, constraints, _j, constraints_2, constraint, _k, misfit;
-            return __generator(this, function (_l) {
-                switch (_l.label) {
-                    case 0:
-                        options = options || this.options;
-                        misfits = [];
-                        misfittingFields = [];
-                        _i = 0, _a = this.singleFields;
-                        _l.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 10];
-                        field = _a[_i];
-                        if (options && options.include instanceof Array && !containsField(options.include, field)) {
-                            return [3 /*break*/, 9];
-                        }
-                        if (options && options.exclude instanceof Array && containsFieldWithoutConstraints(options.exclude, field)) {
-                            return [3 /*break*/, 9];
-                        }
-                        if (object[field] === undefined && options && options.checkOnlyWhatIsThere) {
-                            return [3 /*break*/, 9];
-                        }
-                        constraints = this.constraints(field);
-                        _b = 0, constraints_1 = constraints;
-                        _l.label = 2;
-                    case 2:
-                        if (!(_b < constraints_1.length)) return [3 /*break*/, 9];
-                        constraint = constraints_1[_b];
-                        if (options && options.include instanceof Array && !(containsFieldWithoutConstraints(options.include, field) || containsFieldAndConstraint(options.include, field, constraint))) {
-                            return [3 /*break*/, 8];
-                        }
-                        if (options && options.exclude instanceof Array && containsFieldAndConstraint(options.exclude, field, constraint)) {
-                            return [3 /*break*/, 8];
-                        }
-                        _c = constraint.condition != undefined;
-                        if (!_c) return [3 /*break*/, 4];
-                        return [4 /*yield*/, constraint.condition(object)];
-                    case 3:
-                        _c = !(_l.sent());
-                        _l.label = 4;
-                    case 4:
-                        if (_c) {
-                            return [3 /*break*/, 8];
-                        }
-                        if (!(constraint.constraint != undefined)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, constraint.validateConstraint(object, field)];
-                    case 5:
-                        misfit = _l.sent();
-                        if (misfit) {
-                            misfit.field = field;
-                            if (misfit.constraint === undefined) {
-                                misfit.constraint = constraint.constraint.name;
-                            }
-                            misfittingFields.push(field);
-                            misfits.push(misfit);
-                            return [3 /*break*/, 9];
-                        }
-                        return [3 /*break*/, 8];
-                    case 6:
-                        if (!(constraint.validator != undefined)) return [3 /*break*/, 8];
-                        fieldValue = object[field];
-                        if (fieldValue == undefined) {
-                            return [3 /*break*/, 8];
-                        }
-                        return [4 /*yield*/, constraint.validateValidator(fieldValue)];
-                    case 7:
-                        subMisfits = _l.sent();
-                        for (_d = 0, subMisfits_1 = subMisfits; _d < subMisfits_1.length; _d++) {
-                            misfit = subMisfits_1[_d];
-                            misfit.field = field + '.' + misfit.field;
-                        }
-                        misfits.push.apply(misfits, subMisfits);
-                        _l.label = 8;
-                    case 8:
-                        _b++;
-                        return [3 /*break*/, 2];
-                    case 9:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 10:
-                        _e = 0, _f = this.combinedFields;
-                        _l.label = 11;
-                    case 11:
-                        if (!(_e < _f.length)) return [3 /*break*/, 18];
-                        fields = _f[_e];
-                        if (options && options.include instanceof Array && !containsField(options.include, fields)) {
-                            return [3 /*break*/, 17];
-                        }
-                        if (options && options.exclude instanceof Array && containsFieldWithoutConstraints(options.exclude, fields)) {
-                            return [3 /*break*/, 17];
-                        }
-                        oneOfTheFieldsAlreadyHasAMisfit = false;
-                        for (_g = 0, fields_1 = fields; _g < fields_1.length; _g++) {
-                            field = fields_1[_g];
-                            if (misfittingFields.indexOf(field) > -1) {
-                                oneOfTheFieldsAlreadyHasAMisfit = true;
-                                break;
-                            }
-                        }
-                        if (oneOfTheFieldsAlreadyHasAMisfit) {
-                            return [3 /*break*/, 17];
-                        }
-                        atLeastOneOfTheFieldsMissingInObject = false;
-                        for (_h = 0, fields_2 = fields; _h < fields_2.length; _h++) {
-                            field = fields_2[_h];
-                            if (object[field] === undefined) {
-                                atLeastOneOfTheFieldsMissingInObject = true;
-                                break;
-                            }
-                        }
-                        if (atLeastOneOfTheFieldsMissingInObject && options && options.checkOnlyWhatIsThere) {
-                            return [3 /*break*/, 17];
-                        }
-                        constraints = this.constraints(fields);
-                        _j = 0, constraints_2 = constraints;
-                        _l.label = 12;
-                    case 12:
-                        if (!(_j < constraints_2.length)) return [3 /*break*/, 17];
-                        constraint = constraints_2[_j];
-                        if (options && options.include instanceof Array && !(containsFieldWithoutConstraints(options.include, fields) || containsFieldAndConstraint(options.include, fields, constraint))) {
-                            return [3 /*break*/, 16];
-                        }
-                        if (options && options.exclude instanceof Array && containsFieldAndConstraint(options.exclude, fields, constraint)) {
-                            return [3 /*break*/, 16];
-                        }
-                        _k = constraint.condition != undefined;
-                        if (!_k) return [3 /*break*/, 14];
-                        return [4 /*yield*/, constraint.condition(object)];
-                    case 13:
-                        _k = !(_l.sent());
-                        _l.label = 14;
-                    case 14:
-                        if (_k) {
-                            return [3 /*break*/, 16];
-                        }
-                        if (!(constraint.constraint != undefined)) return [3 /*break*/, 16];
-                        return [4 /*yield*/, constraint.validateConstraint(object, fields)];
-                    case 15:
-                        misfit = _l.sent();
-                        if (misfit) {
-                            misfit.fields = fields;
-                            if (misfit.constraint === undefined) {
-                                misfit.constraint = constraint.constraint.name;
-                            }
-                            misfits.push(misfit);
-                            return [3 /*break*/, 17];
-                        }
-                        _l.label = 16;
-                    case 16:
-                        _j++;
-                        return [3 /*break*/, 12];
-                    case 17:
-                        _e++;
-                        return [3 /*break*/, 11];
-                    case 18: return [2 /*return*/, misfits];
+                if (entry.condition && !(yield entry.condition(object))) {
+                    continue;
                 }
-            });
-        });
-    };
-    return Validator;
-}());
-exports.default = Validator;
-var FieldConstraint = /** @class */ (function () {
-    function FieldConstraint(field, constraintOrValidator, condition) {
-        this.field = typeof field == 'string' ? field : undefined;
-        this.fields = field instanceof Array ? field : undefined;
-        this.constraint = constraintOrValidator instanceof Constraint_1.default ? constraintOrValidator : undefined;
-        this.validator = constraintOrValidator instanceof Validator ? constraintOrValidator : undefined;
-        this.condition = condition;
-    }
-    FieldConstraint.prototype.validateConstraint = function (value, object) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (this.constraint == undefined) {
-                    throw new Error('Could not validate constraint because it is not set');
+                let atLeastOnePropertyExists = false;
+                for (let property of entry.properties) {
+                    if (object[property] !== undefined) {
+                        atLeastOnePropertyExists = true;
+                        break;
+                    }
                 }
-                return [2 /*return*/, this.constraint.validate(value, object)];
-            });
-        });
-    };
-    FieldConstraint.prototype.validateValidator = function (value) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (this.validator == undefined) {
-                    throw new Error('Could not validate with validator because it is not set');
+                if (!atLeastOnePropertyExists && options && options.checkOnlyWhatIsThere) {
+                    continue;
                 }
-                return [2 /*return*/, this.validator.validate(value)];
-            });
-        });
-    };
-    return FieldConstraint;
-}());
-function containsField(fieldsAndConstraints, field) {
-    for (var _i = 0, fieldsAndConstraints_1 = fieldsAndConstraints; _i < fieldsAndConstraints_1.length; _i++) {
-        var fieldAndConstraint = fieldsAndConstraints_1[_i];
-        if (typeof fieldAndConstraint == 'string') {
-            if (fieldAndConstraint == field) {
-                return true;
-            }
-        }
-        else if (fieldAndConstraint instanceof Array) {
-            if (field instanceof Array && fieldsEqual_1.default(fieldAndConstraint, field)) {
-                return true;
-            }
-        }
-        else if (typeof fieldAndConstraint == 'object' && 'field' in fieldAndConstraint) {
-            if (containsField([fieldAndConstraint.field], field)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function containsFieldWithoutConstraints(fieldsAndConstraints, field) {
-    for (var _i = 0, fieldsAndConstraints_2 = fieldsAndConstraints; _i < fieldsAndConstraints_2.length; _i++) {
-        var fieldAndConstraint = fieldsAndConstraints_2[_i];
-        if (typeof fieldAndConstraint == 'string') {
-            if (fieldAndConstraint == field) {
-                return true;
-            }
-        }
-        else if (fieldAndConstraint instanceof Array) {
-            if (field instanceof Array && fieldsEqual_1.default(fieldAndConstraint, field)) {
-                return true;
-            }
-        }
-        else if (typeof fieldAndConstraint == 'object' && 'field' in fieldAndConstraint) {
-            if (containsField([fieldAndConstraint.field], field)) {
-                return fieldAndConstraint.constraint == undefined;
-            }
-        }
-    }
-    return false;
-}
-function containsFieldAndConstraint(fieldsAndConstraints, field, constraint) {
-    for (var _i = 0, fieldsAndConstraints_3 = fieldsAndConstraints; _i < fieldsAndConstraints_3.length; _i++) {
-        var fieldAndConstraint = fieldsAndConstraints_3[_i];
-        if (typeof fieldAndConstraint == 'object' && 'field' in fieldAndConstraint && 'constraint' in fieldAndConstraint) {
-            if (typeof fieldAndConstraint.constraint == 'string') {
-                if (constraintNamesEqual(fieldAndConstraint.constraint, constraint)) {
-                    if (typeof fieldAndConstraint.field == 'string' && fieldAndConstraint.field === field) {
-                        return true;
+                if (entry.constraint != undefined) {
+                    let misfit;
+                    if (entry.properties.length == 1) {
+                        let property = entry.properties[0];
+                        let value = object[property];
+                        misfit = yield entry.constraint.validate(value);
                     }
-                    if (fieldAndConstraint.field instanceof Array && field instanceof Array && fieldsEqual_1.default(fieldAndConstraint.field, field)) {
-                        return true;
+                    else {
+                        misfit = yield entry.constraint.validate(object);
+                    }
+                    if (misfit) {
+                        if (misfit.constraint === undefined) {
+                            misfit.constraint = entry.constraint.name;
+                        }
+                        misfit.properties = entry.properties;
+                        misfittingProperties.push(...entry.properties);
+                        misfits.push(misfit);
                     }
                 }
-            }
-            else if (fieldAndConstraint.constraint instanceof Array) {
-                for (var _a = 0, _b = fieldAndConstraint.constraint; _a < _b.length; _a++) {
-                    var constraintName = _b[_a];
-                    if (constraintNamesEqual(constraintName, constraint)) {
-                        if (typeof fieldAndConstraint.field == 'string' && fieldAndConstraint.field === field) {
-                            return true;
+                else if (entry.validator != undefined) {
+                    if (entry.properties.length != 1) {
+                        throw new Error('Using another validator only works for one property');
+                    }
+                    let property = entry.properties[0];
+                    let value = object[property];
+                    if (typeof value != 'object' || value === null) {
+                        continue;
+                    }
+                    if (value instanceof Array) {
+                        for (let i = 0; i < value.length; i++) {
+                            let subMisfits = yield entry.validator.validate(value[i], options);
+                            if (subMisfits.length > 0) {
+                                for (let misfit of subMisfits) {
+                                    misfit.addPrefix(`${property}[${i}].`);
+                                }
+                                misfittingProperties.push(...entry.properties);
+                                misfits.push(...subMisfits);
+                            }
                         }
-                        if (fieldAndConstraint.field instanceof Array && field instanceof Array && fieldsEqual_1.default(fieldAndConstraint.field, field)) {
-                            return true;
+                    }
+                    else {
+                        let subMisfits = yield entry.validator.validate(value, options);
+                        if (subMisfits.length > 0) {
+                            for (let misfit of subMisfits) {
+                                misfit.addPrefix(property + '.');
+                            }
+                            misfittingProperties.push(...entry.properties);
+                            misfits.push(...subMisfits);
                         }
                     }
                 }
             }
-        }
-    }
-    return false;
-}
-function constraintNamesEqual(constraint1, constraint2) {
-    var _a, _b;
-    if (constraint1 === constraint2) {
-        return true;
-    }
-    if (constraint1 == undefined || constraint2 == undefined) {
-        return false;
-    }
-    var constraintName1;
-    var constraintName2;
-    if (typeof constraint1 == 'string') {
-        constraintName1 = constraint1;
-    }
-    else if (constraint1 instanceof Constraint_1.default) {
-        constraintName1 = constraint1.name;
-    }
-    else if (constraint1 instanceof FieldConstraint) {
-        constraintName1 = (_a = constraint1.constraint) === null || _a === void 0 ? void 0 : _a.name;
-    }
-    else {
-        throw new Error('Unexpected constraint type');
-    }
-    if (typeof constraint2 == 'string') {
-        constraintName2 = constraint2;
-    }
-    else if (constraint2 instanceof Constraint_1.default) {
-        constraintName2 = constraint2.name;
-    }
-    else if (constraint2 instanceof FieldConstraint) {
-        constraintName2 = (_b = constraint2.constraint) === null || _b === void 0 ? void 0 : _b.name;
-    }
-    else {
-        throw new Error('Unexpected constraint type');
+            return misfits;
+        });
     }
-    return constraintName1 === constraintName2;
 }
+exports.Validator = Validator;

package/lib/lib/constraints/Absent.d.ts

@@ -1,5 +1,8 @@
-import Constraint from '../Constraint';
-import Misfit from '../Misfit';
-export default class Absent extends Constraint {
-    validate(obj: any, field: string | string[]): Promise<Misfit | undefined>;
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface AbsentMisfitValues {
+    actual: any;
+}
+export declare class Absent extends Constraint<any, AbsentMisfitValues> {
+    validate(value: any): Promise<Misfit<AbsentMisfitValues> | null>;
 }

package/lib/lib/constraints/Absent.js

@@ -1,17 +1,4 @@
 "use strict";
-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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -21,67 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Constraint_1 = require("../Constraint");
-var Misfit_1 = require("../Misfit");
-var Absent = /** @class */ (function (_super) {
-    __extends(Absent, _super);
-    function Absent() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Absent.prototype.validate = function (obj, field) {
-        return __awaiter(this, void 0, void 0, function () {
-            var value, _i, field_1, fld, value;
-            return __generator(this, function (_a) {
-                if (typeof field == 'string') {
-                    value = obj[field];
-                    if (!Constraint_1.default.absent(value)) {
-                        return [2 /*return*/, new Misfit_1.default];
-                    }
-                }
-                else if (field instanceof Array) {
-                    for (_i = 0, field_1 = field; _i < field_1.length; _i++) {
-                        fld = field_1[_i];
-                        value = obj[fld];
-                        if (!Constraint_1.default.absent(value)) {
-                            return [2 /*return*/, new Misfit_1.default];
-                        }
-                    }
-                }
-                else {
-                    throw new Error('Parameter field was neither of type string nor instance of Array');
-                }
-                return [2 /*return*/];
-            });
+exports.Absent = void 0;
+const Constraint_1 = require("../Constraint");
+const Misfit_1 = require("../Misfit");
+class Absent extends Constraint_1.Constraint {
+    validate(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return value !== undefined ? new Misfit_1.Misfit(this.name, { actual: value }) : null;
         });
-    };
-    return Absent;
-}(Constraint_1.default));
-exports.default = Absent;
+    }
+}
+exports.Absent = Absent;

package/lib/lib/constraints/Bounds.d.ts

@@ -0,0 +1,18 @@
+import { Constraint } from '../Constraint';
+import { Misfit } from '../Misfit';
+export interface BoundsMisfitValues {
+    actual: any;
+    greaterThan?: number;
+    greaterThanEqual?: number;
+    lesserThan?: number;
+    lesserThanEqual?: number;
+}
+export declare class Bounds extends Constraint<any, BoundsMisfitValues> {
+    greaterThan?: number;
+    greaterThanEqual?: number;
+    lesserThan?: number;
+    lesserThanEqual?: number;
+    constructor(constraints: Partial<Bounds>);
+    validate(value: any): Promise<Misfit<BoundsMisfitValues> | null>;
+    private _createMisfit;
+}