simple-body-validator/lib/ecm/utils/general.js

This package is inspired by Laravel validation, and aims to make body validation easier for Javascript developers

'use strict';
import RuleContract from '../rules/ruleContract';
import BaseRule from '../rules/baseRule';
import ImplicitRuleContract from '../rules/implicitRuleContract';
const implicitRues = [
    'accepted', 'accepted_if', 'declined', 'declined_if',
    'filled', 'present', 'required', 'required_if', 'required_unless',
    'required_with', 'required_with_all', 'required_without', 'required_without_all'
];
/**
 * Get the size of a value based on its type
 */
export function getSize(value, hasNumericRule = false) {
    if (typeof value === 'number' || (isNaN(value) === false && hasNumericRule === true)) {
        return Number(value);
    }
    else if (typeof value === 'string' || Array.isArray(value)) {
        return value.length;
    }
    else if (typeof value === 'object' && value !== null) {
        return Object.keys(value).length;
    }
    return -1;
}
;
/**
 * Check if two values are of the same type
 */
export function sameType(value, otherValue) {
    const valueType = Array.isArray(value) ? 'array' : (value === null ? null : typeof value);
    const otherValueType = Array.isArray(otherValue) ? 'array' : (otherValue === null ? null : typeof otherValue);
    return valueType === otherValueType;
}
;
/**
 * Check if Value is an Ineteger
 */
export function isInteger(value) {
    return value !== null && isNaN(value) === false && value % 1 === 0;
}
;
/**
 * Check if the value can be considered as rule
 */
export function isRule(value) {
    return typeof value === 'string' ||
        typeof value === 'function' ||
        value instanceof RuleContract ||
        value instanceof BaseRule;
}
;
/**
 * Check if the array contain any potentiel valid rule
 */
export function isArrayOfRules(values) {
    for (let i = 0; i < values.length; i++) {
        if (isRule(values[i])) {
            return true;
        }
    }
    return false;
}
/**
 * Check if the rule is related to size
 */
export function isSizeRule(rule) {
    const sizeRules = [
        'size', 'between', 'min', 'max', 'gt', 'lt', 'gte', 'lte'
    ];
    return sizeRules.indexOf(rule) !== -1;
}
;
/**
 * Check if rule implies that the field is required
 */
export function isImplicitRule(rule) {
    if (rule instanceof ImplicitRuleContract) {
        return true;
    }
    if (typeof rule === 'string') {
        return implicitRues.indexOf(rule) !== -1;
    }
    return false;
}
;
/**
 * Add a new implicit rule
 */
export function addImplicitRule(rule) {
    implicitRues.push(rule);
}
/**
 * Returns the numeric rules
 */
export function getNumericRules() {
    return ['numeric', 'integer'];
}
;
/**
 * Check if the rule is numeric
 */
export function isNumericRule(rule) {
    const numericRules = getNumericRules();
    return numericRules.indexOf(rule) !== -1;
}
;
/**
 * Determine if a comparison passes between the given values.
 */
export function compare(first, second, operator, strict = false) {
    switch (operator) {
        case '<':
            return first < second;
        case '>':
            return first > second;
        case '<=':
            return first <= second;
        case '>=':
            return first >= second;
        case '=':
            if (strict === true) {
                return first === second;
            }
            return first == second;
        default:
            throw 'Invalid operator parameter';
    }
}
/**
 * Convert the given values to boolean if they are string "true" / "false".
 */
export function convertValuesToBoolean(values) {
    return values.map(value => {
        if (value === 'true') {
            return true;
        }
        else if (value === 'false') {
            return false;
        }
        return value;
    });
}
/**
 * Convert the given values to numbers if they are numbers in a string "1", "2"
 */
export function convertValuesToNumber(values) {
    return values.map(value => {
        if (!isNaN(Number(value))) {
            return Number(value);
        }
        return value;
    });
}
/**
 * Convert the given values to null if they have null values in a string "null", "NULL"
 */
export function convertValuesToNull(values) {
    return values.map(value => {
        if (value.toLowerCase() === 'null') {
            return null;
        }
        return value;
    });
}