n4s/dist/cjs/compounds.development.js

Assertion library for form validations

'use strict';

var n4s = require('n4s');
var vestUtils = require('vest-utils');

function ruleReturn(pass, message) {
    const output = { pass };
    return output;
}
function failing() {
    return ruleReturn(false);
}
function passing() {
    return ruleReturn(true);
}
function defaultToFailing(callback) {
    return vestUtils.defaultTo(callback, failing());
}
function defaultToPassing(callback) {
    return vestUtils.defaultTo(callback, passing());
}

function runLazyRule(lazyRule, currentValue) {
    try {
        return lazyRule.run(currentValue);
    }
    catch (_a) {
        return failing();
    }
}

function allOf(value, ...rules) {
    return defaultToPassing(vestUtils.mapFirst(rules, (rule, breakout) => {
        const res = runLazyRule(rule, value);
        breakout(!res.pass, res);
    }));
}

function anyOf(value, ...rules) {
    return defaultToFailing(vestUtils.mapFirst(rules, (rule, breakout) => {
        const res = runLazyRule(rule, value);
        breakout(res.pass, res);
    }));
}

function noneOf(value, ...rules) {
    return defaultToPassing(vestUtils.mapFirst(rules, (rule, breakout) => {
        const res = runLazyRule(rule, value);
        breakout(res.pass, failing());
    }));
}

function equals(value, arg1) {
    return value === arg1;
}
vestUtils.bindNot(equals);

const REQUIRED_COUNT = 1;
function oneOf(value, ...rules) {
    let passingCount = 0;
    rules.some(rule => {
        const res = runLazyRule(rule, value);
        if (res.pass) {
            passingCount++;
        }
        if (vestUtils.greaterThan(passingCount, REQUIRED_COUNT)) {
            return false;
        }
    });
    return ruleReturn(equals(passingCount, REQUIRED_COUNT));
}

n4s.enforce.extend({ allOf, anyOf, noneOf, oneOf });
//# sourceMappingURL=compounds.development.js.map