feat: add instanceOf

Author: jedwards1211

README.md

@@ -34,6 +34,7 @@ The validation errors are detailed. Adapted from the brilliant work in `flow-run
     - [`t.simpleObject({ foo: t.string() })`](#tsimpleobject-foo-tstring-)
     - [`t.object`](#tobject)
     - [`t.record(t.string(), t.number())`](#trecordtstring-tnumber)
+    - [`t.instanceof(Date)`](#tinstanceofdate)
     - [`t.tuple(t.string(), t.number())`](#ttupletstring-tnumber)
     - [`t.allOf(A, B)`](#tallofa-b)
     - [`t.oneOf(t.string(), t.number())`](#toneoftstring-tnumber)
@@ -259,6 +260,10 @@ You can also use the `t.optionalNullOr(t.string())` as a shorthand for
 
 A validator that requires the value to be `Record<string, number>`.
 
+### `t.instanceOf(Date)`
+
+A validator that requires the value to be an instance of `Date`.
+
 ### `t.tuple(t.string(), t.number())`
 
 A validator that requires the value to be `[string, number]`.

src/errorReporting/typeOf.ts

@@ -3,8 +3,10 @@ import { keyToString } from './keyToString'
 export default function typeOf(value: any): string {
   if (value == null) return String(value)
   if (typeof value !== 'object') return typeof value
-  if (value.constructor && value.constructor !== Object)
-    return value.constructor.name
+  const constructor = value.prototype
+    ? value.prototype.constructor
+    : value.constructor
+  if (constructor && constructor !== Object) return constructor.name
   return `{\n${Object.keys(value)
     .map(key => `  ${keyToString(key)}: ${typeOf(value[key])}`)
     .join(',\n')}\n}`

src/index.ts

@@ -3,6 +3,7 @@ import AnyType from './types/AnyType'
 import ArrayType from './types/ArrayType'
 import BooleanLiteralType from './types/BooleanLiteralType'
 import BooleanType from './types/BooleanType'
+import InstanceOfType from './types/InstanceOfType'
 import IntersectionType from './types/IntersectionType'
 import NullLiteralType from './types/NullLiteralType'
 import UndefinedLiteralType from './types/UndefinedLiteralType'
@@ -28,6 +29,7 @@ export {
   ArrayType,
   BooleanLiteralType,
   BooleanType,
+  InstanceOfType,
   IntersectionType,
   NullLiteralType,
   UndefinedLiteralType,
@@ -171,6 +173,10 @@ export const record = <K extends string | number | symbol, V>(
   value: Type<V>
 ): RecordType<K, V> => new RecordType(key, value)
 
+export const instanceOf = <T extends { new (...args: any[]): any }>(
+  classType: T
+): Type<T> => new InstanceOfType(classType)
+
 export const tuple = <T extends Type<any>[]>(
   ...types: T
 ): Type<{ [Index in keyof T]: T[Index] extends Type<infer E> ? E : never }> =>

src/instanceOf.spec.ts

@@ -0,0 +1,40 @@
+import * as t from './'
+import { expect } from 'chai'
+import dedent from 'dedent-js'
+
+class Foo {}
+
+describe(`t.instanceOf`, function() {
+  it(`accepts instances of class type`, function() {
+    t.instanceOf(Date).assert(new Date())
+    t.instanceOf(Foo).assert(new Foo())
+    expect(t.instanceOf(Date).accepts(new Date())).to.be.true
+    expect(t.instanceOf(Foo).accepts(new Foo())).to.be.true
+  })
+  it(`rejects not instances of class type`, function() {
+    expect(() => t.instanceOf(Date).assert({})).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+        Value must be an instance of Date
+        
+        Expected: Date
+        
+        Actual Value: {}
+        
+        Actual Type: {
+
+        }`
+    )
+    expect(t.instanceOf(Date).accepts(new Foo())).to.be.false
+    expect(() => t.instanceOf(Date).assert(new Foo())).to.throw(
+      t.RuntimeTypeError,
+      dedent`
+        Value must be an instance of Date
+        
+        Expected: Date
+        
+        Actual: Foo`
+    )
+    expect(t.instanceOf(Date).accepts(new Foo())).to.be.false
+  })
+})

src/types/InstanceOfType.ts

@@ -0,0 +1,38 @@
+import Type from './Type'
+
+import getErrorMessage from '../getErrorMessage'
+import Validation, { ErrorTuple, IdentifierPath } from '../Validation'
+
+export default class InstanceOfType<
+  T extends { new (...args: any[]): any }
+> extends Type<T> {
+  typeName = 'InstanceOfType'
+  classType: T
+
+  constructor(classType: T) {
+    super()
+    this.classType = classType
+  }
+
+  *errors(
+    validation: Validation<any>,
+    path: IdentifierPath,
+    input: any
+  ): Generator<ErrorTuple, void, void> {
+    if (!(input instanceof this.classType)) {
+      yield [
+        path,
+        getErrorMessage('ERR_EXPECT_INSTANCEOF', this.toString()),
+        this,
+      ]
+    }
+  }
+
+  accepts(input: any): boolean {
+    return input instanceof this.classType
+  }
+
+  toString(): string {
+    return this.classType.prototype.constructor.name
+  }
+}