index.js

/* eslint no-self-compare: off */

function isNull (a) {
    return a === null;
}

function isUndefined (a) {
    return typeof a === "undefined";
}

function isBoolean (a) {
    return typeof a === "boolean";
}

function isNumber (a) {
    return typeof a === "number";
}

function isFiniteNumber (a) {
    return isNumber(a) && isFinite(a);
}

function isInfiniteNumber (a) {
    return isNumber(a) && !isFinite(a);
}

function isInfinity (a) {
    return isPositiveInfinity(a) || isNegativeInfinity(a);
}

function isPositiveInfinity (a) {
    return a === Number.POSITIVE_INFINITY;
}

function isNegativeInfinity (a) {
    return a === Number.NEGATIVE_INFINITY;
}

function isNaN (a) {
    return a !== a;
}

//
// Checks if a number is an integer. Please note that there's currently no way
// to identify "x.000" and similar as either integer or float in JavaScript because
// those are automatically truncated to "x".
//
function isInteger (n) {
    return isFiniteNumber(n) && n % 1 === 0;
}

function isFloat (n) {
    return isFiniteNumber(n) && n % 1 !== 0;
}

function isString (a) {
    return typeof a === "string";
}

function isChar (a) {
    return isString(a) && a.length === 1;
}

function isCollection (a) {
    return isObject(a) || isArray(a);
}

function isObject (a) {
    return typeof a === "object" && a !== null;
}

function isArray (a) {
    return Array.isArray(a);
}

function isArrayLike (a) {
    return (isArray(a) || isString(a) || (
        isObject(a) && ("length" in a) && isFiniteNumber(a.length) && (
            (a.length > 0 && (a.length - 1) in a) ||
            (a.length === 0)
        )
    ));
}

function isFunction (a) {
    return typeof a === "function";
}

function isPrimitive (a) {
    return isNull(a) || isUndefined(a) || isNumber(a) || isString(a) || isBoolean(a);
}

function isDate (a) {
    return isObject(a) && Object.prototype.toString.call(a) === "[object Date]";
}

function isRegExp (a) {
    return isObject(a) && Object.prototype.toString.call(a) === "[object RegExp]";
}

function isError (a) {
    return isObject(a) && Object.prototype.toString.call(a) === "[object Error]";
}

function isArgumentsObject (a) {
    return isObject(a) && Object.prototype.toString.call(a) === "[object Arguments]";
}

function isMathObject (a) {
    return a === Math;
}

function isType (a) {
    return isDerivable(a) && a.$__type__ === "type" && isFunction(a.$__checker__);
}

function isDerivable (a) {
    return isObject(a) && "$__children__" in a && Array.isArray(a.$__children__);
}

function isMethod (a) {
    return isFunction(a) && a.$__type__ === "method" && isFunction(a.$__default__) &&
        isArray(a.$__implementations__) && isArray(a.$__dispatchers__);
}

module.exports = {
    isArgumentsObject: isArgumentsObject,
    isArray: isArray,
    isArrayLike: isArrayLike,
    isBoolean: isBoolean,
    isChar: isChar,
    isCollection: isCollection,
    isDate: isDate,
    isDerivable: isDerivable,
    isError: isError,
    isFiniteNumber: isFiniteNumber,
    isFloat: isFloat,
    isFunction: isFunction,
    isInfiniteNumber: isInfiniteNumber,
    isInfinity: isInfinity,
    isInteger: isInteger,
    isMathObject: isMathObject,
    isMethod: isMethod,
    isNaN: isNaN,
    isNegativeInfinity: isNegativeInfinity,
    isNull: isNull,
    isNumber: isNumber,
    isPositiveInfinity: isPositiveInfinity,
    isPrimitive: isPrimitive,
    isRegExp: isRegExp,
    isString: isString,
    isType: isType,
    isUndefined: isUndefined
};