123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
import { Struct, Refiner } from '../struct'import { toFailures } from '../utils'
/** * Ensure that a string, array, map, or set is empty. */
export function empty<  T extends string | any[] | Map<any, any> | Set<any>,  S extends any>(struct: Struct<T, S>): Struct<T, S> {  return refine(struct, 'empty', (value) => {    const size = getSize(value)    return (      size === 0 ||      `Expected an empty ${struct.type} but received one with a size of \`${size}\``    )  })}
function getSize(value: string | any[] | Map<any, any> | Set<any>): number {  if (value instanceof Map || value instanceof Set) {    return value.size  } else {    return value.length  }}
/** * Ensure that a number or date is below a threshold. */
export function max<T extends number | Date, S extends any>(  struct: Struct<T, S>,  threshold: T,  options: {    exclusive?: boolean  } = {}): Struct<T, S> {  const { exclusive } = options  return refine(struct, 'max', (value) => {    return exclusive      ? value < threshold      : value <= threshold ||          `Expected a ${struct.type} less than ${            exclusive ? '' : 'or equal to '          }${threshold} but received \`${value}\``  })}
/** * Ensure that a number or date is above a threshold. */
export function min<T extends number | Date, S extends any>(  struct: Struct<T, S>,  threshold: T,  options: {    exclusive?: boolean  } = {}): Struct<T, S> {  const { exclusive } = options  return refine(struct, 'min', (value) => {    return exclusive      ? value > threshold      : value >= threshold ||          `Expected a ${struct.type} greater than ${            exclusive ? '' : 'or equal to '          }${threshold} but received \`${value}\``  })}
/** * Ensure that a string, array, map or set is not empty. */
export function nonempty<  T extends string | any[] | Map<any, any> | Set<any>,  S extends any>(struct: Struct<T, S>): Struct<T, S> {  return refine(struct, 'nonempty', (value) => {    const size = getSize(value)    return (      size > 0 || `Expected a nonempty ${struct.type} but received an empty one`    )  })}
/** * Ensure that a string matches a regular expression. */
export function pattern<T extends string, S extends any>(  struct: Struct<T, S>,  regexp: RegExp): Struct<T, S> {  return refine(struct, 'pattern', (value) => {    return (      regexp.test(value) ||      `Expected a ${struct.type} matching \`/${regexp.source}/\` but received "${value}"`    )  })}
/** * Ensure that a string, array, number, date, map, or set has a size (or length, or time) between `min` and `max`. */
export function size<  T extends string | number | Date | any[] | Map<any, any> | Set<any>,  S extends any>(struct: Struct<T, S>, min: number, max: number = min): Struct<T, S> {  const expected = `Expected a ${struct.type}`  const of = min === max ? `of \`${min}\`` : `between \`${min}\` and \`${max}\``
  return refine(struct, 'size', (value) => {    if (typeof value === 'number' || value instanceof Date) {      return (        (min <= value && value <= max) ||        `${expected} ${of} but received \`${value}\``      )    } else if (value instanceof Map || value instanceof Set) {      const { size } = value      return (        (min <= size && size <= max) ||        `${expected} with a size ${of} but received one with a size of \`${size}\``      )    } else {      const { length } = value as string | any[]      return (        (min <= length && length <= max) ||        `${expected} with a length ${of} but received one with a length of \`${length}\``      )    }  })}
/** * Augment a `Struct` to add an additional refinement to the validation. * * The refiner function is guaranteed to receive a value of the struct's type, * because the struct's existing validation will already have passed. This * allows you to layer additional validation on top of existing structs. */
export function refine<T, S>(  struct: Struct<T, S>,  name: string,  refiner: Refiner<T>): Struct<T, S> {  return new Struct({    ...struct,    *refiner(value, ctx) {      yield* struct.refiner(value, ctx)      const result = refiner(value, ctx)      const failures = toFailures(result, ctx, struct, value)
      for (const failure of failures) {        yield { ...failure, refinement: name }      }    },  })}