@darkwolf/validator/src/index.mjs

Validator

import Helper from '@darkwolf/helper'
import Constants, { Protocol } from './constants/index.mjs'

export {
  Constants,
  Protocol
}

export default class Validator {
  static isArray = Array.isArray
  static isBuffer = Buffer.isBuffer
  static isFinite = Number.isFinite
  static isFloat = Number.isFinite
  static isInteger = Number.isInteger
  static isSafeInteger = Number.isSafeInteger
  static isNaN = Number.isNaN
  static Constants = Constants
  static Protocol = Protocol

  static isEqual(value, other) {
    return value === other
  }

  static isType(value, type) {
    return typeof value === type
  }

  static isTag(value, tag) {
    return Helper.getTag(value) === tag
  }

  static isInstance(value, constructor) {
    return value instanceof constructor
  }

  static isUndefined(value) {
    return value === undefined
  }

  static isPrimitive(value) {
    return (
      typeof value !== 'object' &&
      typeof value !== 'function'
    ) || value === null
  }

  static isNull(value) {
    return value === null
  }

  static isNil(value) {
    return value == null
  }

  static isObject(value) {
    return typeof value === 'object' && value !== null
  }

  static isObjectLike(value) {
    return (
      typeof value === 'object' ||
      typeof value === 'function'
    ) && value !== null
  }

  static isPlainObject(value) {
    return Validator.isTag(value, '[object Object]')
  }

  static isFunction(value) {
    return typeof value === 'function'
  }

  static isAsyncFunction(value) {
    return Validator.isTag(value, '[object AsyncFunction]')
  }

  static isBoolean(value) {
    return typeof value === 'boolean' || value instanceof Boolean
  }

  static isNumber(value) {
    return typeof value === 'number' || value instanceof Number
  }

  static isString(value) {
    return typeof value === 'string' || value instanceof String
  }

  static isSymbol(value) {
    return typeof value === 'symbol'
  }

  static isRegExp(value) {
    return value instanceof RegExp
  }

  static isSet(value) {
    return value instanceof Set
  }

  static isMap(value) {
    return value instanceof Map
  }

  static isWeakSet(value) {
    return value instanceof WeakSet
  }

  static isWeakMap(value) {
    return value instanceof WeakMap
  }

  static isPromise(value) {
    return value instanceof Promise
  }

  static isDate(value) {
    return value instanceof Date
  }

  static isError(value) {
    return value instanceof Error
  }

  static isInfinity(value) {
    return Math.abs(value) === Infinity
  }

  static isDecimal(value) {
    return Number.isFinite(value) && !!(value % 1)
  }

  static isPositive(value) {
    return value > 0
  }

  static isNegative(value) {
    return value < 0
  }

  static isNonNegative(value) {
    return value >= 0
  }

  static isNonPositive(value) {
    return value <= 0
  }

  static isNatural(value) {
    return Number.isInteger(value) && value > 0
  }

  static isWhole(value) {
    return Number.isInteger(value) && value >= 0
  }

  static isEmpty(value) {
    return !value.length
  }

  static exists(value, path) {
    return !Validator.isNil(path ? Helper.get(value, path) : value)
  }

  static has(obj, path) {
    return Helper.getPathParts(path)
      .reduce((obj, key, i, arr) => {
        const index = key.length && key.startsWith('[') ?
          parseInt(key.slice(1, -1)) : key
        const prop = index < 0 && Number.isInteger(index) && Array.isArray(obj) ?
          Math.max(0, obj.length + index) : index
        if (obj && obj.hasOwnProperty(prop) && i < arr.length - 1) {
          return obj[prop]
        }
        return obj ? obj.hasOwnProperty(prop) : false
      }, obj)
  }

  static isTimestamp(value) {
    return new RegExp(Constants.TIMESTAMP_PATTERN).test(value)
  }

  static isUnixTimestamp(value) {
    return new RegExp(Constants.UNIX_TIMESTAMP_PATTERN).test(value)
  }

  static isMillisUnixTimestamp(value) {
    return new RegExp(Constants.MILLIS_UNIX_TIMESTAMP_PATTERN).test(value)
  }

  static isUUID(value) {
    return new RegExp(Constants.UUID_PATTERN).test(value)
  }

  static isJSON(value) {
    try {
      JSON.parse(value)
      return true
    } catch (e) {
      return false
    }
  }

  static isProtocol(value) {
    return new RegExp(Constants.PROTOCOL_PATTERN).test(value)
  }

  static isDNS(value) {
    return new RegExp(Constants.DNS_PATTERN).test(value)
  }

  static isIPv4(value) {
    return new RegExp(Constants.IPV4_PATTERN).test(value)
  }

  static isHostname(value) {
    return new RegExp(Constants.HOSTNAME_PATTERN).test(value)
  }

  static isPort(value) {
    return new RegExp(Constants.PORT_PATTERN).test(value)
  }

  static isHost(value) {
    return new RegExp(Constants.HOST_PATTERN).test(value)
  }

  static isOrigin(value) {
    return new RegExp(Constants.ORIGIN_PATTERN).test(value)
  }

  static isUrl(value) {
    return new RegExp(Constants.URL_PATTERN).test(value)
  }

  static isEmail(value) {
    return new RegExp(Constants.EMAIL_PATTERN).test(value)
  }

  static isPhoneNumber(value) {
    return new RegExp(Constants.PHONE_NUMBER_PATTERN).test(value)
  }

  static isASCII(value) {
    return new RegExp(Constants.ASCII_PATTERN).test(value)
  }

  static isBase64(value) {
    return new RegExp(Constants.BASE64_PATTERN).test(value)
  }

  static isBase64Url(value) {
    return new RegExp(Constants.BASE64URL_PATTERN).test(value)
  }

  static isBase58(value) {
    return new RegExp(Constants.BASE58_PATTERN).test(value)
  }

  static isJWT(value) {
    return new RegExp(Constants.JWT_PATTERN).test(value)
  }

  static isHash(value) {
    return new RegExp(Constants.HASH_PATTERN).test(value)
  }

  static isUid(value) {
    return new RegExp(Constants.UID_PATTERN).test(value)
  }

  static define(name, validator) {
    this[name] = validator
    return this
  }

  define = Validator.define
}