Numbers

number

number: Decoder<number> (source)

Accepts finite numbers (can be integer or float values). Values NaN, or positive and negative Infinity will get rejected.

// 👍
number.verify(123) === 123;
number.verify(-3.14) === -3.14;

// 👎
number.verify(Infinity);        // throws
number.verify(NaN);             // throws
number.verify('not a number');  // throws

integer

integer: Decoder<number> (source)

Accepts only finite whole numbers.

// 👍
integer.verify(123) === 123;

// 👎
integer.verify(-3.14);           // throws
integer.verify(Infinity);        // throws
integer.verify(NaN);             // throws
integer.verify('not a integer'); // throws

positiveNumber

positiveNumber: Decoder<number> (source)

Accepts only non-negative (zero or positive) finite numbers.

// 👍
positiveNumber.verify(123) === 123;
positiveNumber.verify(3.14) === 3.14;
positiveNumber.verify(0) === 0;

// 👎
positiveNumber.verify(-42);             // throws
positiveNumber.verify(Infinity);        // throws
positiveNumber.verify(NaN);             // throws
positiveNumber.verify('not a number');  // throws
positiveNumber.verify(-0);              // throws

positiveInteger

positiveInteger: Decoder<number> (source)

Accepts only non-negative (zero or positive) finite whole numbers.

// 👍
positiveInteger.verify(123) === 123;
positiveInteger.verify(0) === 0;

// 👎
positiveInteger.verify(-3);              // throws
positiveInteger.verify(3.14);            // throws
positiveInteger.verify(Infinity);        // throws
positiveInteger.verify(NaN);             // throws
positiveInteger.verify('not a number');  // throws
positiveInteger.verify(-0);              // throws

anyNumber

anyNumber: Decoder<number> (source)

Accepts any valid number value.

This also accepts special values like NaN and Infinity. Unless you want to deliberately accept those, you'll likely want to use the number decoder instead.

// 👍
anyNumber.verify(123) === 123;
anyNumber.verify(-3.14) === -3.14;
anyNumber.verify(Infinity) === Infinity;
anyNumber.verify(NaN) === NaN;

// 👎
anyNumber.verify('not a number');  // throws

bigint

bigint: Decoder<bigint> (source)

Accepts any valid bigint value.

// 👍
bigint.verify(123n) === 123n;
bigint.verify(-4543000000n) === -4543000000n;

// 👎
bigint.verify(123);             // throws
bigint.verify(-3.14);           // throws
bigint.verify(Infinity);        // throws
bigint.verify(NaN);             // throws
bigint.verify('not a number');  // throws