sat-utils/built/cjs/types.js

Utils library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.typesEnum = void 0;
exports.isArray = isArray;
exports.isObject = isObject;
exports.isNull = isNull;
exports.isString = isString;
exports.isSet = isSet;
exports.isMap = isMap;
exports.isUndefined = isUndefined;
exports.isNumber = isNumber;
exports.isPromise = isPromise;
exports.isBoolean = isBoolean;
exports.isSymbol = isSymbol;
exports.isFunction = isFunction;
exports.isRegExp = isRegExp;
exports.isAsyncFunction = isAsyncFunction;
exports.isDate = isDate;
exports.isBuffer = isBuffer;
exports.isArguments = isArguments;
exports.isType = isType;
exports.getType = getType;
exports.isPrimitive = isPrimitive;
exports.canBeProxed = canBeProxed;
exports.isEmptyArray = isEmptyArray;
exports.isEmptyObject = isEmptyObject;
exports.isNotEmptyArray = isNotEmptyArray;
exports.isNotEmptyObject = isNotEmptyObject;
const typesEnum = {
    object: '[object Object]',
    array: '[object Array]',
    set: '[object Set]',
    map: '[object Map]',
    function: '[object Function]',
    asyncFunction: '[object AsyncFunction]',
    promise: '[object Promise]',
    regExp: '[object RegExp]',
    null: '[object Null]',
    string: '[object String]',
    undefined: '[object Undefined]',
    symbol: '[object Symbol]',
    number: '[object Number]',
    boolean: '[object Boolean]',
    arguments: '[object Arguments]',
    buffer: '[object Uint8Array]',
};
exports.typesEnum = typesEnum;
const pritiveTypes = [
    '[object Null]',
    'null',
    '[object String]',
    'string',
    '[object Undefined]',
    'undefined',
    '[object Number]',
    'number',
    '[object Boolean]',
    'boolean',
    '[object Symbol]',
    'symbol',
];
const typesReverseEnum = {
    '[object Object]': 'object',
    '[object Array]': 'array',
    '[object Set]': 'set',
    '[object Function]': 'function',
    '[object AsyncFunction]': 'asyncFunction',
    '[object Promise]': 'promise',
    '[object Map]': 'map',
    '[object RegExp]': 'regExp',
    '[object Symbol]': 'symbol',
    '[object Null]': 'null',
    '[object String]': 'string',
    '[object Undefined]': 'undefined',
    '[object Number]': 'number',
    '[object Boolean]': 'boolean',
};
function isPrimitive(arg) {
    return pritiveTypes.includes(Object.prototype.toString.call(arg));
}
function getType(arg) {
    return typesReverseEnum[Object.prototype.toString.call(arg)];
}
function isObject(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.object;
}
function isArray(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.array;
}
function isNull(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.null;
}
function isString(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.string;
}
function isUndefined(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.undefined;
}
function isSet(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.set;
}
function isMap(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.map;
}
function isSymbol(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.symbol;
}
function isNumber(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.number && !Number.isNaN(arg);
}
function isBoolean(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.boolean;
}
function isBuffer(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.buffer;
}
function isFunction(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.function;
}
function isAsyncFunction(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.asyncFunction;
}
function isPromise(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.promise;
}
function isRegExp(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.regExp;
}
function isDate(arg) {
    return arg instanceof Date;
}
function isArguments(arg) {
    return Object.prototype.toString.call(arg) === typesEnum.arguments;
}
function isType(arg, typeArg) {
    return Object.prototype.toString.call(arg) === typesEnum[typeArg];
}
function canBeProxed(arg) {
    try {
        new Proxy(arg, {});
        return true;
    }
    catch {
        return false;
    }
}
function isEmptyArray(arg) {
    return isArray(arg) && !arg.length;
}
function isNotEmptyArray(arg) {
    return isArray(arg) && !!arg.length;
}
function isEmptyObject(arg) {
    return isObject(arg) && !Object.keys(arg).length;
}
function isNotEmptyObject(arg) {
    return isObject(arg) && !!Object.keys(arg).length;
}
//# sourceMappingURL=types.js.map