@qaflag/core/dist/assertions/assertion.js

Base requirements for the QA Flag library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Assertion = exports.assert = void 0;
const validator_1 = require("validator");
const is_1 = require("@sindresorhus/is");
const levenshtein_1 = require("./utils/levenshtein");
const is_value_interface_1 = require("./utils/is-value-interface");
const assert = (value) => new Assertion(value);
exports.assert = assert;
const toArray = (value) => {
    return Array.isArray(value) ? value : [value];
};
class Assertion {
    constructor(input, opts) {
        var _a, _b, _c;
        this.input = (0, is_value_interface_1.isValueInterface)(input) ? input.$ : input;
        this.isNot = (_a = opts === null || opts === void 0 ? void 0 : opts.isNot) !== null && _a !== void 0 ? _a : false;
        this.evalType = (_b = opts === null || opts === void 0 ? void 0 : opts.evalType) !== null && _b !== void 0 ? _b : 'standard';
        this.howMany = (_c = opts === null || opts === void 0 ? void 0 : opts.howMany) !== null && _c !== void 0 ? _c : 0;
    }
    validator(methodName, opts) {
        const method = validator_1.default[methodName];
        return this.execute(item => method(String(item), opts));
    }
    is(methodName) {
        const method = is_1.default[methodName];
        return this.execute(value => {
            return method(value);
        });
    }
    execute(assertion) {
        const result = (() => {
            if (this.evalType === 'standard')
                return assertion(this.input);
            const thisArray = toArray(this.input);
            if (this.evalType === 'every') {
                return thisArray.every((item) => assertion(item));
            }
            if (this.evalType === 'some') {
                return thisArray.some((item) => assertion(item));
            }
            const count = thisArray.filter((item) => assertion(item)).length;
            if (this.evalType === 'atLeast')
                return count >= this.howMany;
            if (this.evalType === 'atMost')
                return count <= this.howMany;
            return count === this.howMany;
        })();
        return this.isNot ? !result : result;
    }
    equals(value) {
        return this.execute(item => item == value);
    }
    isExactly(value) {
        return this.execute(item => item === value);
    }
    arrayIncludes(value) {
        return this.execute(item => toArray(item).includes(value));
    }
    isInArray(value) {
        return this.execute(thisValue => value.includes(thisValue));
    }
    containedIn(value) {
        return this.execute(thisValue => {
            if (typeof thisValue == 'string') {
                return Array.isArray(value)
                    ? value.some(x => validator_1.default.contains(x, thisValue))
                    : validator_1.default.contains(value, thisValue);
            }
            if (Array.isArray(thisValue)) {
                return thisValue.some(x => value.includes(String(x)));
            }
            return Array.isArray(value)
                ? value.some(x => validator_1.default.contains(String(x), String(thisValue)))
                : validator_1.default.contains(value, String(thisValue));
        });
    }
    contains(value) {
        return this.execute(thisValue => {
            if (typeof thisValue == 'string') {
                return Array.isArray(value)
                    ? value.some(x => validator_1.default.contains(thisValue, x))
                    : validator_1.default.contains(thisValue, value);
            }
            if (Array.isArray(thisValue)) {
                return Array.isArray(value)
                    ? thisValue.some(x => value.includes(x))
                    : thisValue.includes(value);
            }
            return Array.isArray(value)
                ? value.some(x => validator_1.default.contains(String(thisValue), x))
                : validator_1.default.contains(String(thisValue), value);
        });
    }
    exists() {
        return this.execute(value => {
            if (value === null || value === undefined)
                return false;
            if (typeof value == 'number' && value <= 0)
                return false;
            if (Array.isArray(value) && value.length == 0)
                return false;
            if (value === false)
                return false;
            return true;
        });
    }
    isTrue() {
        return this.execute(item => item === true);
    }
    isFalse() {
        return this.execute(item => item === false);
    }
    isNullOrUndefined() {
        return this.is('nullOrUndefined');
    }
    isNull() {
        return this.is('null_');
    }
    isUndefined() {
        return this.is('undefined');
    }
    isBoolean() {
        return this.is('boolean');
    }
    isTruthy() {
        return this.is('truthy');
    }
    isEmpty() {
        if (is_1.default.array(this.input))
            return this.is('emptyArray');
        if (is_1.default.object(this.input))
            return this.is('emptyObject');
        return this.is('emptyString');
    }
    isType(typeName) {
        return this.execute(value => (0, is_1.default)(value).toLocaleLowerCase() == typeName.toLocaleLowerCase());
    }
    isDate() {
        return this.validator('isDate');
    }
    isInteger() {
        return this.validator('isInt');
    }
    isString() {
        return this.is('string');
    }
    isObject() {
        return this.is('plainObject');
    }
    isArray() {
        return this.is('array');
    }
    isNumber() {
        return this.is('number');
    }
    isNumeric() {
        return this.is('numericString');
    }
    isLikeString(value) {
        return this.execute(item => String(item).toLocaleLowerCase().trim() ===
            value.toLocaleLowerCase().trim());
    }
    isSimilarTo(value, maxDistance = 3) {
        return this.execute(item => (0, levenshtein_1.levenshtein)(String(item).toLocaleLowerCase().trim(), value.toLocaleLowerCase().trim()) <= maxDistance);
    }
    startsWith(value) {
        return this.execute(item => {
            const str = String(item);
            return Array.isArray(value)
                ? value.some(x => str.startsWith(String(x)))
                : str.startsWith(String(value));
        });
    }
    endsWith(value) {
        return this.execute(item => {
            const str = String(item);
            return Array.isArray(value)
                ? value.some(x => str.endsWith(String(x)))
                : str.endsWith(String(value));
        });
    }
    matchesPattern(value) {
        return this.execute(item => validator_1.default.matches(String(item), value));
    }
    isEmailAddress() {
        return this.validator('isEmail');
    }
    isCreditCard() {
        return this.validator('isCreditCard');
    }
    isNumericString() {
        return this.is('numericString');
    }
    isIpAddress(version) {
        return this.validator('isIP', version);
    }
    isUrl() {
        return this.is('urlString');
    }
    isJwt() {
        return this.validator('isJWT');
    }
    isMd5() {
        return this.validator('isMD5');
    }
    isPostalCode(countryCode) {
        return this.validator('isPostalCode', countryCode);
    }
    isUuid(version) {
        return this.validator('isUUID', version);
    }
    isUppercase() {
        return this.validator('isUppercase');
    }
    isLowercase() {
        return this.validator('isLowercase');
    }
    isSlug() {
        return this.validator('isSlug');
    }
    isMimeType() {
        return this.validator('isMimeType');
    }
    isEmptyString() {
        return this.is('emptyStringOrWhitespace');
    }
    isFalsy() {
        return this.is('falsy');
    }
    isMongoId() {
        return this.validator('isMongoId');
    }
    isAlphanumeric() {
        return this.execute(item => /^[A-Za-z0-9]+$/.test(String(item)));
    }
    isOnlyLetters() {
        return this.execute(item => /^[A-Za-z]+$/.test(String(item)));
    }
    isOnlyNumbers() {
        return this.execute(item => /^[0-9]+$/.test(String(item)));
    }
    isGreaterThan(value) {
        return this.execute(item => Number(item) > value);
    }
    isGreaterThanOrEquals(value) {
        return this.execute(item => Number(item) >= value);
    }
    isLessThan(value) {
        return this.execute(item => Number(item) < value);
    }
    isLessThanOrEquals(value) {
        return this.execute(item => Number(item) <= value);
    }
    isInRange(valueA, valueB) {
        return this.execute(item => is_1.default.inRange(Number(item), [valueA, valueB]));
    }
    isCloseTo(value, within = 0.01) {
        return this.execute(item => is_1.default.inRange(Number(item), [value - within, value + within]));
    }
    roundsTo(value) {
        return this.execute(item => Math.round(Number(item)) == value);
    }
    roundsUpTo(value) {
        return this.execute(item => Math.ceil(Number(item)) == value);
    }
    roundsDownTo(value) {
        return this.execute(item => Math.floor(Number(item)) == value);
    }
    isZero() {
        return this.execute(value => String(value) === '0');
    }
    isNonZeroNumber() {
        return this.execute(value => is_1.default.number(value) && value != 0);
    }
    isNonZeroInteger() {
        return this.execute(value => is_1.default.integer(value) && value != 0);
    }
    isOddInteger() {
        return this.is('oddInteger');
    }
    isEvenInteger() {
        return this.is('evenInteger');
    }
    isDivisibleBy(n) {
        return this.validator('isDivisibleBy', n);
    }
    isPositiveNumber() {
        return this.execute(item => Number(item) > 0);
    }
    isPositiveInteger() {
        return this.execute(value => is_1.default.integer(value) && Number(value) > 0);
    }
    isNegativeNumber() {
        return this.execute(item => Number(item) < 0);
    }
    isNegativeInteger() {
        return this.execute(value => is_1.default.integer(value) && Number(value) < 0);
    }
    isNan() {
        return this.is('nan');
    }
    hasProperty(propertyName) {
        return this.execute(item => is_1.default.object(item) && item[propertyName] !== undefined);
    }
    hasProperties(propertyNames) {
        return this.execute(item => is_1.default.object(item) &&
            propertyNames.every(prop => item[prop] !== undefined));
    }
    isEmptyObject() {
        return this.is('emptyObject');
    }
    isArrayOf(typeName) {
        return this.execute(value => is_1.default.array(value, is_1.default[typeName]));
    }
    isEmptyArray() {
        return this.is('emptyArray');
    }
    isBeforeDate(date) {
        const dateString = typeof date == 'string' ? date : Date.toString();
        return this.validator('isBefore', dateString);
    }
    isAfterDate(date) {
        const dateString = typeof date == 'string' ? date : Date.toString();
        return this.validator('isAfter', dateString);
    }
    inThePast() {
        return this.validator('isBefore');
    }
    inTheFuture() {
        return this.validator('isAfter');
    }
}
exports.Assertion = Assertion;
//# sourceMappingURL=assertion.js.map