chore(deps): update dependency expect-type to v1 #977

renovate · 2024-10-05T00:52:55Z

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
expect-type	`^0.15.0` -> `^1.0.0`

Release Notes

mmkal/expect-type (expect-type)

v1! 🎉🎉🎉

After many years being commitment-phobic, expect-type is now in v1.

This release does not add any user facing features on top of v0.20.0 or v1.0.0-rc.0. It's just "making it official". For anyone new to the project, or coming here from vitest or viteconf (👋 ), the usage docs from the readme are pasted below.

For anyone on an old-ish v0 version, here are links to the non-trivial changes that have gone in since v0.15.0:

v0.20.0: Function overloads support (proper support, beyond the default typescript functionality which eliminates all but one overloads by default)
v0.19.0: Beefed up JSDocs thanks to @aryaemami59
v0.18.0: .pick and .omit thanks to @aryaemami59
v0.17.0: massively improved error messages, so (in most cases) when an assertion fails you can see what's wrong, not just that something is wrong
v0.16.0: default to internal typescript implementation of type-identicalness. Introduce the .branded helper for the old behaviour. Also support function this parameters - thank to @trevorade and @papb

Full usage docs below, for newbies (head to the readme to keep up to date):

docs from readme

Installation and usage

npm install expect-type --save-dev

import {expectTypeOf} from 'expect-type'

Documentation

The expectTypeOf method takes a single argument or a generic type parameter. Neither it nor the functions chained off its return value have any meaningful runtime behaviour. The assertions you write will be compile-time errors if they don't hold true.

Features

Check an object's type with .toEqualTypeOf:

expectTypeOf({a: 1}).toEqualTypeOf<{a: number}>()

.toEqualTypeOf can check that two concrete objects have equivalent types (note: when these assertions fail, the error messages can be less informative vs the generic type argument syntax above - see error messages docs):

expectTypeOf({a: 1}).toEqualTypeOf({a: 1})

.toEqualTypeOf succeeds for objects with different values, but the same type:

expectTypeOf({a: 1}).toEqualTypeOf({a: 2})

.toEqualTypeOf fails on excess properties:

// @&#8203;ts-expect-error
expectTypeOf({a: 1, b: 1}).toEqualTypeOf<{a: number}>()

To allow for extra properties, use .toMatchTypeOf. This is roughly equivalent to an extends constraint in a function type argument.:

expectTypeOf({a: 1, b: 1}).toMatchTypeOf<{a: number}>()

.toEqualTypeOf and .toMatchTypeOf both fail on missing properties:

// @&#8203;ts-expect-error
expectTypeOf({a: 1}).toEqualTypeOf<{a: number; b: number}>()
// @&#8203;ts-expect-error
expectTypeOf({a: 1}).toMatchTypeOf<{a: number; b: number}>()

Another example of the difference between .toMatchTypeOf and .toEqualTypeOf, using generics. .toMatchTypeOf can be used for "is-a" relationships:

type Fruit = {type: 'Fruit'; edible: boolean}
type Apple = {type: 'Fruit'; name: 'Apple'; edible: true}

expectTypeOf<Apple>().toMatchTypeOf<Fruit>()

// @&#8203;ts-expect-error
expectTypeOf<Fruit>().toMatchTypeOf<Apple>()

// @&#8203;ts-expect-error
expectTypeOf<Apple>().toEqualTypeOf<Fruit>()

Assertions can be inverted with .not:

expectTypeOf({a: 1}).not.toMatchTypeOf({b: 1})

.not can be easier than relying on // @ts-expect-error:

type Fruit = {type: 'Fruit'; edible: boolean}
type Apple = {type: 'Fruit'; name: 'Apple'; edible: true}

expectTypeOf<Apple>().toMatchTypeOf<Fruit>()

expectTypeOf<Fruit>().not.toMatchTypeOf<Apple>()
expectTypeOf<Apple>().not.toEqualTypeOf<Fruit>()

Catch any/unknown/never types:

expectTypeOf<unknown>().toBeUnknown()
expectTypeOf<any>().toBeAny()
expectTypeOf<never>().toBeNever()

// @&#8203;ts-expect-error
expectTypeOf<never>().toBeNumber()

.toEqualTypeOf distinguishes between deeply-nested any and unknown properties:

expectTypeOf<{deeply: {nested: any}}>().not.toEqualTypeOf<{deeply: {nested: unknown}}>()

You can test for basic JavaScript types:

expectTypeOf(() => 1).toBeFunction()
expectTypeOf({}).toBeObject()
expectTypeOf([]).toBeArray()
expectTypeOf('').toBeString()
expectTypeOf(1).toBeNumber()
expectTypeOf(true).toBeBoolean()
expectTypeOf(() => {}).returns.toBeVoid()
expectTypeOf(Promise.resolve(123)).resolves.toBeNumber()
expectTypeOf(Symbol(1)).toBeSymbol()

.toBe... methods allow for types that extend the expected type:

expectTypeOf<number>().toBeNumber()
expectTypeOf<1>().toBeNumber()

expectTypeOf<any[]>().toBeArray()
expectTypeOf<number[]>().toBeArray()

expectTypeOf<string>().toBeString()
expectTypeOf<'foo'>().toBeString()

expectTypeOf<boolean>().toBeBoolean()
expectTypeOf<true>().toBeBoolean()

.toBe... methods protect against any:

const goodIntParser = (s: string) => Number.parseInt(s, 10)
const badIntParser = (s: string) => JSON.parse(s) // uh-oh - works at runtime if the input is a number, but return 'any'

expectTypeOf(goodIntParser).returns.toBeNumber()
// @&#8203;ts-expect-error - if you write a test like this, `.toBeNumber()` will let you know your implementation returns `any`.
expectTypeOf(badIntParser).returns.toBeNumber()

Nullable types:

expectTypeOf(undefined).toBeUndefined()
expectTypeOf(undefined).toBeNullable()
expectTypeOf(undefined).not.toBeNull()

expectTypeOf(null).toBeNull()
expectTypeOf(null).toBeNullable()
expectTypeOf(null).not.toBeUndefined()

expectTypeOf<1 | undefined>().toBeNullable()
expectTypeOf<1 | null>().toBeNullable()
expectTypeOf<1 | undefined | null>().toBeNullable()

More .not examples:

expectTypeOf(1).not.toBeUnknown()
expectTypeOf(1).not.toBeAny()
expectTypeOf(1).not.toBeNever()
expectTypeOf(1).not.toBeNull()
expectTypeOf(1).not.toBeUndefined()
expectTypeOf(1).not.toBeNullable()

Detect assignability of unioned types:

expectTypeOf<number>().toMatchTypeOf<string | number>()
expectTypeOf<string | number>().not.toMatchTypeOf<number>()

Use .extract and .exclude to narrow down complex union types:

type ResponsiveProp<T> = T | T[] | {xs?: T; sm?: T; md?: T}
const getResponsiveProp = <T>(_props: T): ResponsiveProp<T> => ({})
type CSSProperties = {margin?: string; padding?: string}

const cssProperties: CSSProperties = {margin: '1px', padding: '2px'}

expectTypeOf(getResponsiveProp(cssProperties))
  .exclude<unknown[]>()
  .exclude<{xs?: unknown}>()
  .toEqualTypeOf<CSSProperties>()

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>()
  .toEqualTypeOf<CSSProperties[]>()

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<{xs?: any}>()
  .toEqualTypeOf<{xs?: CSSProperties; sm?: CSSProperties; md?: CSSProperties}>()

expectTypeOf<ResponsiveProp<number>>().exclude<number | number[]>().toHaveProperty('sm')
expectTypeOf<ResponsiveProp<number>>().exclude<number | number[]>().not.toHaveProperty('xxl')

.extract and .exclude return never if no types remain after exclusion:

type Person = {name: string; age: number}
type Customer = Person & {customerId: string}
type Employee = Person & {employeeId: string}

expectTypeOf<Customer | Employee>().extract<{foo: string}>().toBeNever()
expectTypeOf<Customer | Employee>().exclude<{name: string}>().toBeNever()

Use .pick to pick a set of properties from an object:

type Person = {name: string; age: number}

expectTypeOf<Person>().pick<'name'>().toEqualTypeOf<{name: string}>()

Use .omit to remove a set of properties from an object:

type Person = {name: string; age: number}

expectTypeOf<Person>().omit<'name'>().toEqualTypeOf<{age: number}>()

Make assertions about object properties:

const obj = {a: 1, b: ''}

// check that properties exist (or don't) with `.toHaveProperty`
expectTypeOf(obj).toHaveProperty('a')
expectTypeOf(obj).not.toHaveProperty('c')

// check types of properties
expectTypeOf(obj).toHaveProperty('a').toBeNumber()
expectTypeOf(obj).toHaveProperty('b').toBeString()
expectTypeOf(obj).toHaveProperty('a').not.toBeString()

.toEqualTypeOf can be used to distinguish between functions:

type NoParam = () => void
type HasParam = (s: string) => void

expectTypeOf<NoParam>().not.toEqualTypeOf<HasParam>()

But often it's preferable to use .parameters or .returns for more specific function assertions:

type NoParam = () => void
type HasParam = (s: string) => void

expectTypeOf<NoParam>().parameters.toEqualTypeOf<[]>()
expectTypeOf<NoParam>().returns.toBeVoid()

expectTypeOf<HasParam>().parameters.toEqualTypeOf<[string]>()
expectTypeOf<HasParam>().returns.toBeVoid()

Up to ten overloads will produce union types for .parameters and .returns:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[number] | [bigint]>()
expectTypeOf<Factorize>().returns.toEqualTypeOf<number[] | bigint[]>()

expectTypeOf<Factorize>().parameter(0).toEqualTypeOf<number | bigint>()

Note that these aren't exactly like TypeScript's built-in Parameters<...> and ReturnType<...>:

The TypeScript builtins simply choose a single overload (see the Overloaded functions section for more information)

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

// overload using `number` is ignored!
expectTypeOf<Parameters<Factorize>>().toEqualTypeOf<[bigint]>()
expectTypeOf<ReturnType<Factorize>>().toEqualTypeOf<bigint[]>()

More examples of ways to work with functions - parameters using .parameter(n) or .parameters, and return values using .returns:

const f = (a: number) => [a, a]

expectTypeOf(f).toBeFunction()

expectTypeOf(f).toBeCallableWith(1)
expectTypeOf(f).not.toBeAny()
expectTypeOf(f).returns.not.toBeAny()
expectTypeOf(f).returns.toEqualTypeOf([1, 2])
expectTypeOf(f).returns.toEqualTypeOf([1, 2, 3])
expectTypeOf(f).parameter(0).not.toEqualTypeOf('1')
expectTypeOf(f).parameter(0).toEqualTypeOf(1)
expectTypeOf(1).parameter(0).toBeNever()

const twoArgFunc = (a: number, b: string) => ({a, b})

expectTypeOf(twoArgFunc).parameters.toEqualTypeOf<[number, string]>()

.toBeCallableWith allows for overloads. You can also use it to narrow down the return type for given input parameters.:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

expectTypeOf<Factorize>().toBeCallableWith(6)
expectTypeOf<Factorize>().toBeCallableWith(6n)

.toBeCallableWith returns a type that can be used to narrow down the return type for given input parameters.:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}
expectTypeOf<Factorize>().toBeCallableWith(6).returns.toEqualTypeOf<number[]>()
expectTypeOf<Factorize>().toBeCallableWith(6n).returns.toEqualTypeOf<bigint[]>()

.toBeCallableWith can be used to narrow down the parameters of a function:

type Delete = {
  (path: string): void
  (paths: string[], options?: {force: boolean}): void
}

expectTypeOf<Delete>().toBeCallableWith('abc').parameters.toEqualTypeOf<[string]>()
expectTypeOf<Delete>()
  .toBeCallableWith(['abc', 'def'], {force: true})
  .parameters.toEqualTypeOf<[string[], {force: boolean}?]>()

expectTypeOf<Delete>().toBeCallableWith('abc').parameter(0).toBeString()
expectTypeOf<Delete>().toBeCallableWith('abc').parameter(1).toBeUndefined()

expectTypeOf<Delete>()
  .toBeCallableWith(['abc', 'def', 'ghi'])
  .parameter(0)
  .toEqualTypeOf<string[]>()

expectTypeOf<Delete>()
  .toBeCallableWith(['abc', 'def', 'ghi'])
  .parameter(1)
  .toEqualTypeOf<{force: boolean} | undefined>()

You can't use .toBeCallableWith with .not - you need to use ts-expect-error::

const f = (a: number) => [a, a]

// @&#8203;ts-expect-error
expectTypeOf(f).toBeCallableWith('foo')

You can also check type guards & type assertions:

const assertNumber = (v: any): asserts v is number => {
  if (typeof v !== 'number') {
    throw new TypeError('Nope !')
  }
}

expectTypeOf(assertNumber).asserts.toBeNumber()

const isString = (v: any): v is string => typeof v === 'string'
expectTypeOf(isString).guards.toBeString()

Assert on constructor parameters:

expectTypeOf(Date).toBeConstructibleWith('1970')
expectTypeOf(Date).toBeConstructibleWith(0)
expectTypeOf(Date).toBeConstructibleWith(new Date())
expectTypeOf(Date).toBeConstructibleWith()

expectTypeOf(Date).constructorParameters.toEqualTypeOf<
  | []
  | [value: string | number]
  | [value: string | number | Date]
  | [
      year: number,
      monthIndex: number,
      date?: number | undefined,
      hours?: number | undefined,
      minutes?: number | undefined,
      seconds?: number | undefined,
      ms?: number | undefined,
    ]
>()

Constructor overloads:

class DBConnection {
  constructor()
  constructor(connectionString: string)
  constructor(options: {host: string; port: number})
  constructor(..._: unknown[]) {}
}

expectTypeOf(DBConnection).toBeConstructibleWith()
expectTypeOf(DBConnection).toBeConstructibleWith('localhost')
expectTypeOf(DBConnection).toBeConstructibleWith({host: 'localhost', port: 1234})
// @&#8203;ts-expect-error - as when calling `new DBConnection(...)` you can't actually use the `(...args: unknown[])` overlaod, it's purely for the implementation.
expectTypeOf(DBConnection).toBeConstructibleWith(1, 2)

Check function this parameters:

function greet(this: {name: string}, message: string) {
  return `Hello ${this.name}, here's your message: ${message}`
}

expectTypeOf(greet).thisParameter.toEqualTypeOf<{name: string}>()

Distinguish between functions with different this parameters:

function greetFormal(this: {title: string; name: string}, message: string) {
  return `Dear ${this.title} ${this.name}, here's your message: ${message}`
}

function greetCasual(this: {name: string}, message: string) {
  return `Hi ${this.name}, here's your message: ${message}`
}

expectTypeOf(greetFormal).not.toEqualTypeOf(greetCasual)

Class instance types:

expectTypeOf(Date).instance.toHaveProperty('toISOString')

Promise resolution types can be checked with .resolves:

const asyncFunc = async () => 123

expectTypeOf(asyncFunc).returns.resolves.toBeNumber()

Array items can be checked with .items:

expectTypeOf([1, 2, 3]).items.toBeNumber()
expectTypeOf([1, 2, 3]).items.not.toBeString()

You can also compare arrays directly:

expectTypeOf<any[]>().not.toEqualTypeOf<number[]>()

Check that functions never return:

const thrower = () => {
  throw new Error('oh no')
}

expectTypeOf(thrower).returns.toBeNever()

Generics can be used rather than references:

expectTypeOf<{a: string}>().not.toEqualTypeOf<{a: number}>()

Distinguish between missing/null/optional properties:

expectTypeOf<{a?: number}>().not.toEqualTypeOf<{}>()
expectTypeOf<{a?: number}>().not.toEqualTypeOf<{a: number}>()
expectTypeOf<{a?: number}>().not.toEqualTypeOf<{a: number | undefined}>()
expectTypeOf<{a?: number | null}>().not.toEqualTypeOf<{a: number | null}>()
expectTypeOf<{a: {b?: number}}>().not.toEqualTypeOf<{a: {}}>()

Detect the difference between regular and readonly properties:

type A1 = {readonly a: string; b: string}
type E1 = {a: string; b: string}

expectTypeOf<A1>().toMatchTypeOf<E1>()
expectTypeOf<A1>().not.toEqualTypeOf<E1>()

type A2 = {a: string; b: {readonly c: string}}
type E2 = {a: string; b: {c: string}}

expectTypeOf<A2>().toMatchTypeOf<E2>()
expectTypeOf<A2>().not.toEqualTypeOf<E2>()

Distinguish between classes with different constructors:

class A {
  value: number
  constructor(a: 1) {
    this.value = a
  }
}
class B {
  value: number
  constructor(b: 2) {
    this.value = b
  }
}

expectTypeOf<typeof A>().not.toEqualTypeOf<typeof B>()

class C {
  value: number
  constructor(c: 1) {
    this.value = c
  }
}

expectTypeOf<typeof A>().toEqualTypeOf<typeof C>()

Known limitation: Intersection types can cause issues with toEqualTypeOf:

// @&#8203;ts-expect-error the following line doesn't compile, even though the types are arguably the same.
// See https://github.com/mmkal/expect-type/pull/21
expectTypeOf<{a: 1} & {b: 2}>().toEqualTypeOf<{a: 1; b: 2}>()

To workaround for simple cases, you can use a mapped type:

type Simplify<T> = {[K in keyof T]: T[K]}

expectTypeOf<Simplify<{a: 1} & {b: 2}>>().toEqualTypeOf<{a: 1; b: 2}>()

But this won't work if the nesting is deeper in the type. For these situations, you can use the .branded helper. Note that this comes at a performance cost, and can cause the compiler to 'give up' if used with excessively deep types, so use sparingly. This helper is under .branded because it deeply transforms the Actual and Expected types into a pseudo-AST:

// @&#8203;ts-expect-error
expectTypeOf<{a: {b: 1} & {c: 1}}>().toEqualTypeOf<{a: {b: 1; c: 1}}>()

expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.toEqualTypeOf<{a: {b: 1; c: 1}}>()

Be careful with .branded for very deep or complex types, though. If possible you should find a way to simplify your test to avoid needing to use it:

// This *should* result in an error, but the "branding" mechanism produces too large a type and TypeScript just gives up! https://github.com/microsoft/TypeScript/issues/50670
expectTypeOf<() => () => () => () => 1>().branded.toEqualTypeOf<() => () => () => () => 2>()

// @&#8203;ts-expect-error the non-branded implementation catches the error as expected.
expectTypeOf<() => () => () => () => 1>().toEqualTypeOf<() => () => () => () => 2>()

So, if you have an extremely deep type that ALSO has an intersection in it, you're out of luck and this library won't be able to test your type properly:

// @&#8203;ts-expect-error this fails, but it should succeed.
expectTypeOf<() => () => () => () => {a: 1} & {b: 2}>().toEqualTypeOf<
  () => () => () => () => {a: 1; b: 2}
>()

// this succeeds, but it should fail.
expectTypeOf<() => () => () => () => {a: 1} & {b: 2}>().branded.toEqualTypeOf<
  () => () => () => () => {a: 1; c: 2}
>()

Another limitation: passing this references to expectTypeOf results in errors.:

class B {
  b = 'b'

  foo() {
    // @&#8203;ts-expect-error
    expectTypeOf(this).toEqualTypeOf(this)
    // @&#8203;ts-expect-error
    expectTypeOf(this).toMatchTypeOf(this)
  }
}

// Instead of the above, try something like this:
expectTypeOf(B).instance.toEqualTypeOf<{b: string; foo: () => void}>()

Overloads limitation for TypeScript <5.3: Due to a TypeScript bug fixed in 5.3, overloaded functions which include an overload resembling (...args: unknown[]) => unknown will exclude unknown[] from .parameters and exclude unknown from .returns:

type Factorize = {
  (...args: unknown[]): unknown
  (input: number): number[]
  (input: bigint): bigint[]
}

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[number] | [bigint]>()
expectTypeOf<Factorize>().returns.toEqualTypeOf<number[] | bigint[]>()

This overload, however, allows any input and returns an unknown output anyway, so it's not very useful. If you are worried about this for some reason, you'll have to update TypeScript to 5.3+.

Why is my assertion failing?

For complex types, an assertion might fail when it should if the Actual type contains a deeply-nested intersection type but the Expected doesn't. In these cases you can use .branded as described above:

// @&#8203;ts-expect-error this unfortunately fails - a TypeScript limitation prevents making this pass without a big perf hit
expectTypeOf<{a: {b: 1} & {c: 1}}>().toEqualTypeOf<{a: {b: 1; c: 1}}>()

expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.toEqualTypeOf<{a: {b: 1; c: 1}}>()

Where is `.toExtend`?

A few people have asked for a method like toExtend - this is essentially what toMatchTypeOf is. There are some cases where it doesn't precisely match the extends operator in TypeScript, but for most practical use cases, you can think of this as the same thing.

Internal type helpers

🚧 This library also exports some helper types for performing boolean operations on types, checking extension/equality in various ways, branding types, and checking for various special types like never, any, unknown. Use at your own risk! Nothing is stopping you from using these beyond this warning:

All internal types that are not documented here are not part of the supported API surface, and may be renamed, modified, or removed, without warning or documentation in release notes.

For a dedicated internal type library, feel free to look at the source code for inspiration - or better, use a library like type-fest.

Error messages

When types don't match, .toEqualTypeOf and .toMatchTypeOf use a special helper type to produce error messages that are as actionable as possible. But there's a bit of a nuance to understanding them. Since the assertions are written "fluently", the failure should be on the "expected" type, not the "actual" type (expect<Actual>().toEqualTypeOf<Expected>()). This means that type errors can be a little confusing - so this library produces a MismatchInfo type to try to make explicit what the expectation is. For example:

expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

Is an assertion that will fail, since {a: 1} has type {a: number} and not {a: string}. The error message in this case will read something like this:

test/test.ts:999:999 - error TS2344: Type '{ a: string; }' does not satisfy the constraint '{ a: \\"Expected: string, Actual: number\\"; }'.
  Types of property 'a' are incompatible.
    Type 'string' is not assignable to type '\\"Expected: string, Actual: number\\"'.

999 expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

Note that the type constraint reported is a human-readable messaging specifying both the "expected" and "actual" types. Rather than taking the sentence Types of property 'a' are incompatible // Type 'string' is not assignable to type "Expected: string, Actual: number" literally - just look at the property name ('a') and the message: Expected: string, Actual: number. This will tell you what's wrong, in most cases. Extremely complex types will, of course, be more effort to debug, and may require some experimentation. Please raise an issue if the error messages are misleading.

The toBe... methods (like toBeString, toBeNumber, toBeVoid, etc.) fail by resolving to a non-callable type when the Actual type under test doesn't match up. For example, the failure for an assertion like expectTypeOf(1).toBeString() will look something like this:

test/test.ts:999:999 - error TS2349: This expression is not callable.
  Type 'ExpectString<number>' has no call signatures.

999 expectTypeOf(1).toBeString()
                    ~~~~~~~~~~

The This expression is not callable part isn't all that helpful - the meaningful error is the next line, Type 'ExpectString<number> has no call signatures. This essentially means you passed a number but asserted it should be a string.

If TypeScript added support for "throw" types these error messages could be improved. Until then they will take a certain amount of squinting.

Concrete "expected" objects vs type arguments

Error messages for an assertion like this:

expectTypeOf({a: 1}).toEqualTypeOf({a: ''})

Will be less helpful than for an assertion like this:

expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

This is because the TypeScript compiler needs to infer the type argument for the .toEqualTypeOf({a: ''}) style and this library can only mark it as a failure by comparing it against a generic Mismatch type. So, where possible, use a type argument rather than a concrete type for .toEqualTypeOf and toMatchTypeOf. If it's much more convenient to compare two concrete types, you can use typeof:

const one = valueFromFunctionOne({some: {complex: inputs}})
const two = valueFromFunctionTwo({some: {other: inputs}})

expectTypeOf(one).toEqualTypeof<typeof two>()

Overloaded functions

Due to a TypeScript design limitation, the native TypeScript Parameters<...> and ReturnType<...> helpers only return types from one variant of an overloaded function. This limitation doesn't apply to expect-type, since it is not used to author TypeScript code, only to assert on existing types. So, we use a workaround for this TypeScript behaviour to assert on all overloads as a union (actually, not necessarily all - we cap out at 10 overloads).

Within test frameworks

Vitest

expectTypeOf is built in to vitest, so you can import expectTypeOf from the vitest library directly if you prefer. Note that there is no set release cadence, at time of writing, so vitest may not always be using the very latest version.

import {expectTypeOf} from 'vitest'
import {mount} from './mount.js'

test('my types work properly', () => {
  expectTypeOf(mount).toBeFunction()
  expectTypeOf(mount).parameter(0).toMatchTypeOf<{name: string}>()

  expectTypeOf(mount({name: 42})).toBeString()
})

Limitations

A summary of some of the limitations of this library. Some of these are documented more fully elsewhere.

Intersection types can result in failures when the expected and actual types are not identically defined, even when they are effectively identical. See Why is my assertion failing for details. TL;DR: use .brand in these cases - and accept the performance hit that it comes with.
toBeCallableWith will likely fail if you try to use it with a generic function or an overload. See this issue for an example and how to work around it.
(For now) overloaded functions might trip up the .parameter and .parameters helpers. This matches how the built-in TypeScript helper Parameters<...> works. This may be improved in the future though (see related issue).
expectTypeOf(this).toEqualTypeOf(this) inside class methods does not work.

Similar projects

Other projects with similar goals:

tsd is a CLI that runs the TypeScript type checker over assertions
ts-expect exports several generic helper types to perform type assertions
dtslint does type checks via comment directives and tslint
type-plus comes with various type and runtime TypeScript assertions
static-type-assert type assertion functions

Comparison

The key differences in this project are:

a fluent, jest-inspired API, making the difference between actual and expected clear. This is helpful with complex types and assertions.
inverting assertions intuitively and easily via expectTypeOf(...).not
checks generics properly and strictly (tsd doesn't)
first-class support for:
- any (as well as unknown and never) (see issues outstanding at time of writing in tsd for never and any).
  - This can be especially useful in combination with not, to protect against functions returning too-permissive types. For example, const parseFile = (filename: string) => JSON.parse(readFileSync(filename).toString()) returns any, which could lead to errors. After giving it a proper return-type, you can add a test for this with expect(parseFile).returns.not.toBeAny()
- object properties
- function parameters
- function return values
- constructor parameters
- class instances
- array item values
- nullable types
assertions on types "matching" rather than exact type equality, for "is-a" relationships e.g. expectTypeOf(square).toMatchTypeOf<Shape>()
built into existing tooling. No extra build step, cli tool, IDE extension, or lint plugin is needed. Just import the function and start writing tests. Failures will be at compile time - they'll appear in your IDE and when you run tsc.
small implementation with no dependencies. Take a look! (tsd, for comparison, is 2.6MB because it ships a patched version of TypeScript).

Thanks to everyone who has helped with this over the years!

Full Changelog: mmkal/expect-type@v0.20.0...v1.0.0

`v0.20.0`

Compare Source

Breaking changes

improve overloads support, attempt 2 by @mmkal in https://github.com/mmkal/expect-type/pull/83

This change updates how overloaded functions are treated. Now, .parameters gives you a union of the parameter-tuples that a function can take. For example, given the following type:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

Behvaiour before:

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[bigint]>()

Behaviour now:

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[number] | [bigint]>()

There were similar changes for .returns, .parameter(...), and .toBeCallableWith. Also, overloaded functions are now differentiated properly when using .branded.toEqualTypeOf (this was a bug that it seems nobody found).

See #83 for more details or look at the updated docs (including a new section called "Overloaded functions", which has more info on how this behaviour differs for TypeScript versions before 5.3).

What's Changed

Fix rendering issue in readme by @mrazauskas in https://github.com/mmkal/expect-type/pull/69
Fix minor issues in docs by @aryaemami59 in https://github.com/mmkal/expect-type/pull/91
create utils file by @mmkal in https://github.com/mmkal/expect-type/pull/93
branding.ts and messages.ts by @mmkal in https://github.com/mmkal/expect-type/pull/95
improve overloads support, attempt 2 by @mmkal in https://github.com/mmkal/expect-type/pull/83
Extends: explain myself 1e37116
Mark internal APIs with @internal JSDoc tag (#104) 4c40b07
Re-export everything in overloads.ts file (#107) 5ee0181
JSDoc improvements (#100) 0bbeffa

Full Changelog: mmkal/expect-type@v0.19.0...v0.20.0

`v0.19.0`

Compare Source

What's Changed

Fix .omit() to work similarly to Omit by @aryaemami59 in https://github.com/mmkal/expect-type/pull/54
Add JSDocs to everything by @aryaemami59 in https://github.com/mmkal/expect-type/pull/56
Remove test import in README.md by @aryaemami59 in https://github.com/mmkal/expect-type/pull/65

Full Changelog: mmkal/expect-type@0.18.0...0.19.0

`v0.18.0`

Compare Source

What's Changed

Add .pick and .omit by @aryaemami59 in https://github.com/mmkal/expect-type/pull/51

New Contributors

@aryaemami59 made their first contribution in https://github.com/mmkal/expect-type/pull/51

Full Changelog: mmkal/expect-type@v0.17.3...0.18.0

`v0.17.3`

Compare Source

docs: why-is-my-assertion-failing 907b8aa
I think the previous build was out of date somehow too, so see https://github.com/mmkal/expect-type/releases/v0.17.2

`v0.17.2`

Compare Source

Improve tuple errors (#40) 4b38117

Diff(truncated - scroll right!):

test('toEqualTypeOf with tuples', () => {
  const assertion = `expectTypeOf<[[number], [1], []]>().toEqualTypeOf<[[number], [2], []]>()`
  expect(tsErrors(assertion)).toMatchInlineSnapshot(`
-    "test/test.ts:999:999 - error TS2344: Type '[[number], [2], []]' does not satisfy the constraint '{ [x: number]: { [x: number]: number; [iterator]: (() => IterableIterator<1>) | (() => IterableIterator<number>) | (() => IterableIterator<never>); [unscopables]: (() => { copyWithin: boolean; entries: boolean; fill: boolean; find: boolean; findIndex: boolean; keys: boolean; values: boolean; }) | (() => { copyWithin: boolean; entries: boolean; fill: boolean; find: boolean; findIndex: boolean; keys: boolean; values: boolean; }) | (() => { copyWithin: boolean; entries: boolean; fill: boolean; find: boolean; findIndex: boolean; keys: boolean; values: boolean; }); length: 0 | 1; toString:  ... truncated!!!!'.
-      Types of property 'sort' are incompatible.
-        Type '(compareFn?: ((a: [] | [number] | [2], b: [] | [number] | [2]) => number) | undefined) => [[number], [2], []]' is not assignable to type '\\"Expected: function, Actual: function\\"'.
+    "test/test.ts:999:999 - error TS2344: Type '[[number], [2], []]' does not satisfy the constraint '{ 0: { 0: number; }; 1: { 0: \\"Expected: literal number: 2, Actual: literal number: 1\\"; }; 2: {}; }'.
+      The types of '1[0]' are incompatible between these types.
+        Type '2' is not assignable to type '\\"Expected: literal number: 2, Actual: literal number: 1\\"'.
    999 expectTypeOf<[[number], [1], []]>().toEqualTypeOf<[[number], [2], []]>()
                                                          ~~~~~~~~~~~~~~~~~~~"
  `)
})

`v0.17.1`

Compare Source

disallow .not and .branded together cf38918

(this was actually documented in the v0.17.0 release but really it was only pushed here)

`v0.17.0`

Compare Source

#16 went in to - hopefully - significantly improve the error messages produce on failing assertions. Here's an example of how vitest's failing tests were improved:

Before:

After:

Docs copied from the readme about how to interpret these error messages

Error messages

When types don't match, .toEqualTypeOf and .toMatchTypeOf use a special helper type to produce error messages that are as actionable as possible. But there's a bit of an nuance to understanding them. Since the assertions are written "fluently", the failure should be on the "expected" type, not the "actual" type (expect<Actual>().toEqualTypeOf<Expected>()). This means that type errors can be a little confusing - so this library produces a MismatchInfo type to try to make explicit what the expectation is. For example:

expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

Is an assertion that will fail, since {a: 1} has type {a: number} and not {a: string}. The error message in this case will read something like this:

test/test.ts:999:999 - error TS2344: Type '{ a: string; }' does not satisfy the constraint '{ a: \\"Expected: string, Actual: number\\"; }'.
  Types of property 'a' are incompatible.
    Type 'string' is not assignable to type '\\"Expected: string, Actual: number\\"'.

999 expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

Note that the type constraint reported is a human-readable messaging specifying both the "expected" and "actual" types. Rather than taking the sentence Types of property 'a' are incompatible // Type 'string' is not assignable to type "Expected: string, Actual: number" literally - just look at the property name ('a') and the message: Expected: string, Actual: number. This will tell you what's wrong, in most cases. Extremely complex types will of course be more effort to debug, and may require some experimentation. Please raise an issue if the error messages are actually misleading.

The toBe... methods (like toBeString, toBeNumber, toBeVoid etc.) fail by resolving to a non-callable type when the Actual type under test doesn't match up. For example, the failure for an assertion like expectTypeOf(1).toBeString() will look something like this:

test/test.ts:999:999 - error TS2349: This expression is not callable.
  Type 'ExpectString<number>' has no call signatures.

999 expectTypeOf(1).toBeString()
                    ~~~~~~~~~~

The This expression is not callable part isn't all that helpful - the meaningful error is the next line, Type 'ExpectString<number> has no call signatures. This essentially means you passed a number but asserted it should be a string.

If TypeScript added support for "throw" types these error messagess could be improved. Until then they will take a certain amount of squinting.

Concrete "expected" objects vs typeargs

Error messages for an assertion like this:

expectTypeOf({a: 1}).toEqualTypeOf({a: ''})

Will be less helpful than for an assertion like this:

expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

This is because the TypeScript compiler needs to infer the typearg for the .toEqualTypeOf({a: ''}) style, and this library can only mark it as a failure by comparing it against a generic Mismatch type. So, where possible, use a typearg rather than a concrete type for .toEqualTypeOf and toMatchTypeOf. If it's much more convenient to compare two concrete types, you can use typeof:

const one = valueFromFunctionOne({some: {complex: inputs}})
const two = valueFromFunctionTwo({some: {other: inputs}})

expectTypeOf(one).toEqualTypeof<typeof two>()

Kinda-breaking changes: essentially none, but technically, .branded no longer returns a "full" ExpectTypeOf instance at compile-time. Previously you could do this:

expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.not.toEqualTypeOf<{a: {b: 1; c: ''}}>()
expectTypeOf<{a: {b: 1} & {c: 1}}>().not.branded.toEqualTypeOf<{a: {b: 1; c: ''}}>()

Now that won't work (and it was always slightly nonsensical), so you'd have to use // @ts-expect-error instead of not if you have a negated case where you need branded:

// @&#8203;ts-expect-error
expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.not.toEqualTypeOf<{a: {b: 1; c: ''}}>()

What's Changed

Improve CLI error messages by @mmkal in https://github.com/mmkal/expect-type/pull/16
expect-type is usually a dev dependency by @SerkanSipahi in https://github.com/mmkal/expect-type/pull/39

New Contributors

@SerkanSipahi made their first contribution in https://github.com/mmkal/expect-type/pull/39

Full Changelog: mmkal/expect-type@v0.16.0...v0.17.0

`v0.16.0`

Compare Source

What's Changed

support functions with this parameters by @mmkal and @papb in https://github.com/mmkal/expect-type/pull/15
Prevent the .not modifier from being chained by @trevorade in https://github.com/mmkal/expect-type/pull/20
Rewrite Equal to use the equality check from ReadonlyEquivalent exclusively by @trevorade in https://github.com/mmkal/expect-type/pull/21

Note that #21 has affected behavior for intersection types, which can result in (arguably) false errors:

// @&#8203;ts-expect-error the following line doesn't compile, even though the types are arguably the same.
// See https://github.com/mmkal/expect-type/pull/21
expectTypeOf<{a: 1} & {b: 2}>().toEqualTypeOf<{a: 1; b: 2}>()

Full Changelog: mmkal/expect-type@v0.15.0...v16.0.0

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

renovate bot force-pushed the renovate/expect-type-1.x branch from f9f6720 to 7496730 Compare October 18, 2024 10:08

renovate bot force-pushed the renovate/expect-type-1.x branch 2 times, most recently from c88df18 to 9b362fa Compare October 30, 2024 06:36

chore(deps): update dependency expect-type to v1

6b3f6c5

renovate bot force-pushed the renovate/expect-type-1.x branch from 9b362fa to 6b3f6c5 Compare October 30, 2024 06:39

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

chore(deps): update dependency expect-type to v1 #977

chore(deps): update dependency expect-type to v1 #977

renovate bot commented Oct 5, 2024 •

edited

Loading

chore(deps): update dependency expect-type to v1 #977

Are you sure you want to change the base?

chore(deps): update dependency expect-type to v1 #977

Conversation

renovate bot commented Oct 5, 2024 • edited Loading

Release Notes

What's Changed

v1! 🎉🎉🎉

Installation and usage

Documentation

Features

Why is my assertion failing?

Where is .toExtend?

Internal type helpers

Error messages

Concrete "expected" objects vs type arguments

Overloaded functions

Within test frameworks

Vitest

Limitations

Similar projects

Comparison

Breaking changes

What's Changed

What's Changed

What's Changed

New Contributors

Error messages

Concrete "expected" objects vs typeargs

What's Changed

New Contributors

What's Changed

Configuration

renovate bot commented Oct 5, 2024 •

edited

Loading

Where is `.toExtend`?