export const isSymbol = (value: any): value is symbol => {
  return Boolean(value) && value.constructor === Symbol;
};

export const isArray = Array.isArray;

export const isObject = (value: any): value is object => {
  return Boolean(value) && value.constructor === Object;
};

/**
 * Checks if the given value is primitive.
 *
 * Primitive Types: number , string , boolean , symbol, bigint, undefined, null
 *
 * @param {*} value value to check
 * @returns {boolean} result
 */
export const isPrimitive = (value: any): boolean => {
  return value === undefined || value === null || (typeof value !== 'object' && typeof value !== 'function');
};

export const isFunction = (value: any): value is Function => {
  return Boolean(value && value.constructor && value.call && value.apply);
};

export const isString = (value: any): value is string => {
  return typeof value === 'string' || value instanceof String;
};

export const isNumber = (value: any): value is number => {
  try {
    return Number(value) === value;
  }
  catch {
    return false;
  }
};

export const isInt = (value: any): value is number => {
  return isNumber(value) && value % 1 === 0;
};

export const isFloat = (value: any): value is number => {
  return isNumber(value) && value % 1 !== 0;
};

export const isDate = (value: any): value is Date => {
  return Object.prototype.toString.call(value) === '[object Date]';
};

/**
 * This is really a _best guess_ promise checking. You
 * should probably use Promise.resolve(value) to be 100%
 * sure you're handling it correctly.
 */
export const isPromise = (value: any): value is Promise<any> => {
  if (!value)
    return false;
  if (!value.then)
    return false;
  if (!isFunction(value.then))
    return false;
  return true;
};

export const isEmpty = (value: any) => {
  if (value === true || value === false)
    return true;
  if (value === null || value === undefined)
    return true;
  if (isNumber(value))
    return value === 0;
  if (isDate(value))
    return Number.isNaN(value.getTime());
  if (isFunction(value))
    return false;
  if (isSymbol(value))
    return false;
  const length = (value as any).length;
  if (isNumber(length))
    return length === 0;
  const size = (value as any).size;
  if (isNumber(size))
    return size === 0;
  const keys = Object.keys(value).length;
  return keys === 0;
};

export const isEqual = <TType>(x: TType, y: TType): boolean => {
  if (Object.is(x, y))
    return true;
  if (x instanceof Date && y instanceof Date) {
    return x.getTime() === y.getTime();
  }
  if (x instanceof RegExp && y instanceof RegExp) {
    return x.toString() === y.toString();
  }
  if (typeof x !== 'object' || x === null || typeof y !== 'object' || y === null) {
    return false;
  }
  const keysX = Reflect.ownKeys(x as unknown as object) as (keyof typeof x)[];
  const keysY = Reflect.ownKeys(y as unknown as object);
  if (keysX.length !== keysY.length)
    return false;
  for (let i = 0; i < keysX.length; i += 1) {
    if (!Reflect.has(y as unknown as object, keysX[i]))
      return false;
    if (!isEqual(x[keysX[i]], y[keysX[i]]))
      return false;
  }
  return true;
};

export const isBlankString = (value: unknown | undefined) => {
  return typeof value === 'string' && value === '';
};
Utils

Preview

Installation

Usage
