Support bigints

README.md

@@ -7,9 +7,7 @@
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@gucciogucci/contented">
-    <img alt="NPM" src="https://badge.fury.io/js/@gucciogucci%2Fcontented.svg"/>
-  </a>
+  <a href="https://www.npmjs.com/package/@gucciogucci/contented"><img alt="NPM" src="https://badge.fury.io/js/@gucciogucci%2Fcontented.svg"/></a>
   <a href="https://github.com/GuccioGucci/contented/actions/workflows/test.yml"><img alt="Test" src="https://github.com/GuccioGucci/contented/actions/workflows/test.yml/badge.svg"></a>
   <a href="https://bundlephobia.com/package/@gucciogucci/contented"><img alt="Bundlephobia Minified" src="https://img.shields.io/bundlephobia/min/@gucciogucci/contented.svg"></a>
 </p>
@@ -24,6 +22,7 @@
   - [Primitive types](#primitive-types)
     - [`string`](#string)
     - [`number`](#number)
+    - [`bigint`](#bigint)
     - [`boolean`](#boolean)
     - [`null_`](#null\_)
   - [Literal types](#literal-types)
@@ -138,6 +137,20 @@ explain(number, 'hello');
 // { value: 'hello', isNot: 'number' }
 ```
 
+#### `bigint`
+
+A run-time representation of the `bigint` type.
+
+```typescript
+import { bigint, isValid, explain } from '@gucciogucci/contented';
+
+isValid(bigint, 1024n);
+// true
+
+explain(bigint, 'hello');
+// { value: 'hello', isNot: 'bigint' }
+```
+
 #### `boolean`
 
 A run-time representation of the `boolean` type.

src/Type.ts

@@ -17,10 +17,10 @@ export type Schema = PrimitiveSchema | LiteralSchema | ObjectSchema | OneOfSchem
 // ----------------------------------------------------------------------
 // Primitive
 // ----------------------------------------------------------------------
-export type PrimitiveSchema = 'string' | 'boolean' | 'number' | 'null'
+export type PrimitiveSchema = 'string' | 'boolean' | 'number' | 'null' | 'bigint'
 
 export function isPrimitiveSchema(schema: Schema): schema is PrimitiveSchema {
-  return schema === 'string' || schema === 'boolean' || schema === 'number' || schema === 'null'
+  return schema === 'string' || schema === 'boolean' || schema === 'number' || schema === 'null' || schema === 'bigint'
 }
 
 // ----------------------------------------------------------------------

src/bigint.test.ts

@@ -0,0 +1,51 @@
+import { test } from 'uvu'
+import { is, equal } from 'uvu/assert'
+import fc, { assert, property } from 'fast-check'
+import { bigint } from './bigint'
+import { isValid } from './isValid'
+import { explain } from './explain'
+
+test(`bigint accepts bigint values`, function () {
+  assert(
+    property(fc.bigInt(), (value) => {
+      const res = isValid(bigint, value)
+      is(res, true)
+    })
+  )
+})
+
+test(`bigint rejects all but bigint values`, function () {
+  assert(
+    property(notABigint, (value) => {
+      const res = isValid(bigint, value)
+      is(res, false)
+    })
+  )
+})
+
+test(`there is an explanation why a value is not a bigint`, function () {
+  assert(
+    property(notABigint, (value) => {
+      const exp = explain(bigint, value)
+      equal(exp, {
+        value,
+        isNot: 'bigint',
+      })
+    })
+  )
+})
+
+test(`there is no need for an explanation if the value is indeed a bigint`, function () {
+  assert(
+    property(fc.bigInt(), (value) => {
+      const exp = explain(bigint, value)
+      is(exp, undefined)
+    })
+  )
+})
+
+test.run()
+
+const fcSymbol = fc.string().map((str) => Symbol(str))
+const fcNumber = fc.oneof(fc.integer(), fc.float(), fc.double())
+const notABigint = fc.oneof(fcNumber, fc.boolean(), fc.constant(null), fc.constant(undefined), fcSymbol)

src/bigint.ts

@@ -0,0 +1,3 @@
+import { Type } from './Type'
+
+export const bigint: Type<bigint> = { schema: 'bigint' }

src/boolean.test.ts

@@ -48,4 +48,4 @@ test.run()
 
 const fcSymbol = fc.string().map((str) => Symbol(str))
 const fcNumber = fc.oneof(fc.integer(), fc.float(), fc.double())
-const notABoolean = fc.oneof(fcNumber, fc.string(), fc.constant(null), fc.constant(undefined), fcSymbol)
+const notABoolean = fc.oneof(fcNumber, fc.bigInt(), fc.string(), fc.constant(null), fc.constant(undefined), fcSymbol)

src/index.ts

@@ -1,5 +1,6 @@
 export { allOf } from './allOf'
 export { arrayOf } from './arrayOf'
+export { bigint } from './bigint'
 export { boolean } from './boolean'
 export { explain } from './explain'
 export { Infer } from './Type'

src/literal.test.ts

@@ -32,4 +32,14 @@ test(`there is an explanation why a value is not of the expected literal type`,
   })
 })
 
+test('bigint literals are recognized as literals', function () {
+  const ten = literal(10n)
+
+  const res1 = isValid(ten, 10n)
+  const res2 = isValid(ten, 10)
+
+  assert.is(res1, true)
+  assert.is(res2, false)
+})
+
 test.run()

src/literal.ts

@@ -1,6 +1,6 @@
 import { Type } from './Type'
 
-export function literal<R extends string | number | boolean>(value: Narrow<R>): Type<Narrow<R>> {
+export function literal<R extends string | number | boolean | bigint>(value: Narrow<R>): Type<Narrow<R>> {
   return { schema: { literal: value } }
 }
 

src/null.test.ts

@@ -40,4 +40,4 @@ test.run()
 
 const fcSymbol = fc.string().map((str) => Symbol(str))
 const fcNumber = fc.oneof(fc.integer(), fc.float(), fc.double())
-const notNull = fc.oneof(fcNumber, fc.boolean(), fc.string(), fc.constant(undefined), fcSymbol)
+const notNull = fc.oneof(fcNumber, fc.bigInt(), fc.boolean(), fc.string(), fc.constant(undefined), fcSymbol)

src/number.test.ts

@@ -48,4 +48,4 @@ test.run()
 
 const fcSymbol = fc.string().map((str) => Symbol(str))
 const fcNumber = fc.oneof(fc.integer(), fc.float(), fc.double()).filter((x) => !Number.isNaN(x))
-const notANumber = fc.oneof(fc.string(), fc.boolean(), fc.constant(null), fc.constant(undefined), fcSymbol)
+const notANumber = fc.oneof(fc.string(), fc.bigInt(), fc.boolean(), fc.constant(null), fc.constant(undefined), fcSymbol)