chore: minor updates

and tons of tests

chore: wip

Author: chrisbbreuer

src/lib/isEmpty.ts

@@ -10,5 +10,5 @@ import assertString from './util/assertString'
 export default function isEmpty(str: string, options: IsEmptyOptions = {}): boolean {
   assertString(str)
 
-  return (options.ignoreWhitespace ? str.trim().length : str.length) === 0
+  return (options?.ignoreWhitespace ? str.trim().length : str.length) === 0
 }

src/lib/isLength.ts

@@ -14,9 +14,12 @@ export default function isLength(str: string, options: IsLengthOptions): boolean
   let min
   let max
 
-  if (typeof (options) === 'object') {
+  if (typeof (options) === 'object' && options !== null) {
     min = options.min || 0
     max = options.max
+    // Handle NaN values
+    if (Number.isNaN(min))
+      min = 0
   }
   else { // backwards compatibility: isLength(str, min [, max])
     min = arguments[1] || 0
@@ -26,7 +29,7 @@ export default function isLength(str: string, options: IsLengthOptions): boolean
   const presentationSequences = str.match(/(\uFE0F|\uFE0E)/g) || []
   const surrogatePairs = str.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || []
   const len = str.length - presentationSequences.length - surrogatePairs.length
-  const isInsideRange = len >= min && (typeof max === 'undefined' || len <= max)
+  const isInsideRange = len >= min && (typeof max === 'undefined' || Number.isNaN(max) || len <= max)
 
   if (isInsideRange && Array.isArray(options?.discreteLengths)) {
     return options.discreteLengths.includes(len)

src/types/number.ts

@@ -39,4 +39,11 @@ export interface NumberValidatorType extends Validator<number>, LengthValidator<
   custom: (fn: (value: number) => boolean, message: string) => NumberValidator
 }
 
-export interface BigintValidatorType extends NumberValidatorType {}
+export interface BigintValidatorType extends Validator<bigint> {
+  min: (min: bigint) => BigintValidatorType
+  max: (max: bigint) => BigintValidatorType
+  positive: () => BigintValidatorType
+  negative: () => BigintValidatorType
+  divisibleBy: (divisor: bigint) => BigintValidatorType
+  custom: (fn: (value: bigint) => boolean, message: string) => BigintValidatorType
+}

src/types/string.ts

@@ -5,8 +5,8 @@ import type { StringValidator } from '../validators/strings'
 import type { LengthValidator, Validator } from './base'
 
 export interface ContainsOptions {
-  ignoreCase: boolean
-  minOccurrences: number
+  ignoreCase?: boolean
+  minOccurrences?: number
 }
 
 export interface AlphanumericOptions {

src/validators/bigint.ts

@@ -1,7 +1,7 @@
 import type { BigintValidatorType, ValidationNames } from '../types'
-import { NumberValidator } from './numbers'
+import { BaseValidator } from './base'
 
-export class BigintValidator extends NumberValidator implements BigintValidatorType {
+export class BigintValidator extends BaseValidator<bigint> implements BigintValidatorType {
   public name: ValidationNames = 'bigint'
 
   constructor() {
@@ -12,6 +12,57 @@ export class BigintValidator extends NumberValidator implements BigintValidatorT
       message: 'Must be a bigint',
     })
   }
+
+  min(min: bigint): BigintValidatorType {
+    return this.addRule({
+      name: 'min',
+      test: (value: bigint) => value >= min,
+      message: 'Must be at least {min}',
+      params: { min },
+    })
+  }
+
+  max(max: bigint): BigintValidatorType {
+    return this.addRule({
+      name: 'max',
+      test: (value: bigint) => value <= max,
+      message: 'Must be at most {max}',
+      params: { max },
+    })
+  }
+
+  positive(): BigintValidatorType {
+    return this.addRule({
+      name: 'positive',
+      test: (value: bigint) => value > 0n,
+      message: 'Must be a positive bigint',
+    })
+  }
+
+  negative(): BigintValidatorType {
+    return this.addRule({
+      name: 'negative',
+      test: (value: bigint) => value < 0n,
+      message: 'Must be a negative bigint',
+    })
+  }
+
+  divisibleBy(divisor: bigint): BigintValidatorType {
+    return this.addRule({
+      name: 'divisibleBy',
+      test: (value: bigint) => value % divisor === 0n,
+      message: 'Must be divisible by {divisor}',
+      params: { divisor },
+    })
+  }
+
+  custom(fn: (value: bigint) => boolean, message: string): BigintValidatorType {
+    return this.addRule({
+      name: 'custom',
+      test: fn,
+      message,
+    })
+  }
 }
 
 export function bigint(): BigintValidator {