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

This PR contains the following updates:

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

Release Notes

mmkal/expect-type (expect-type)

### [`v1.0.0`](https://redirect.github.com/mmkal/expect-type/releases/tag/v1.0.0) [Compare Source](https://redirect.github.com/mmkal/expect-type/compare/v0.20.0...v1.0.0) ### v1! 🎉🎉🎉 After many years, 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 (👋 ), 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](https://redirect.github.com/mmkal/expect-type/releases/tag/v0.20.0): Function overloads support (proper support, beyond the default typescript functionality which eliminates all but one overloads by default) - [v0.19.0](https://redirect.github.com/mmkal/expect-type/releases/tag/0.19.0): Beefed up JSDocs thanks to [@aryaemami59](https://redirect.github.com/aryaemami59) - [v0.18.0](https://redirect.github.com/mmkal/expect-type/releases/tag/0.18.0): `.pick` and `.omit` thanks to [@aryaemami59](https://redirect.github.com/aryaemami59) - [v0.17.0](https://redirect.github.com/mmkal/expect-type/releases/tag/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](https://redirect.github.com/mmkal/expect-type/releases/tag/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](https://redirect.github.com/trevorade) and [@papb](https://redirect.github.com/papb) Full usage docs below, for newbies (head to the [readme](https://redirect.github.com/mmkal/expect-type/blob/main/README.md) to keep up to date): *** #### Installation and usage ```cli npm install expect-type --save-dev ``` ```typescript 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`: ```typescript 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](#error-messages)): ```typescript expectTypeOf({a: 1}).toEqualTypeOf({a: 1}) ``` `.toEqualTypeOf` succeeds for objects with different values, but the same type: ```typescript expectTypeOf({a: 1}).toEqualTypeOf({a: 2}) ``` `.toEqualTypeOf` fails on excess properties: ```typescript // @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.: ```typescript expectTypeOf({a: 1, b: 1}).toMatchTypeOf<{a: number}>() ``` `.toEqualTypeOf` and `.toMatchTypeOf` both fail on missing properties: ```typescript // @ts-expect-error expectTypeOf({a: 1}).toEqualTypeOf<{a: number; b: number}>() // @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: ```typescript type Fruit = {type: 'Fruit'; edible: boolean} type Apple = {type: 'Fruit'; name: 'Apple'; edible: true} expectTypeOf().toMatchTypeOf() // @ts-expect-error expectTypeOf().toMatchTypeOf() // @ts-expect-error expectTypeOf().toEqualTypeOf() ``` Assertions can be inverted with `.not`: ```typescript expectTypeOf({a: 1}).not.toMatchTypeOf({b: 1}) ``` `.not` can be easier than relying on `// @ts-expect-error`: ```typescript type Fruit = {type: 'Fruit'; edible: boolean} type Apple = {type: 'Fruit'; name: 'Apple'; edible: true} expectTypeOf().toMatchTypeOf() expectTypeOf().not.toMatchTypeOf() expectTypeOf().not.toEqualTypeOf() ``` Catch any/unknown/never types: ```typescript expectTypeOf().toBeUnknown() expectTypeOf().toBeAny() expectTypeOf().toBeNever() // @ts-expect-error expectTypeOf().toBeNumber() ``` `.toEqualTypeOf` distinguishes between deeply-nested `any` and `unknown` properties: ```typescript expectTypeOf<{deeply: {nested: any}}>().not.toEqualTypeOf<{deeply: {nested: unknown}}>() ``` You can test for basic JavaScript types: ```typescript 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: ```typescript expectTypeOf().toBeNumber() expectTypeOf<1>().toBeNumber() expectTypeOf().toBeArray() expectTypeOf().toBeArray() expectTypeOf().toBeString() expectTypeOf<'foo'>().toBeString() expectTypeOf().toBeBoolean() expectTypeOf().toBeBoolean() ``` `.toBe...` methods protect against `any`: ```typescript 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() // @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: ```typescript 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: ```typescript 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: ```typescript expectTypeOf().toMatchTypeOf() expectTypeOf().not.toMatchTypeOf() ``` Use `.extract` and `.exclude` to narrow down complex union types: ```typescript type ResponsiveProp = T | T[] | {xs?: T; sm?: T; md?: T} const getResponsiveProp = (_props: T): ResponsiveProp => ({}) type CSSProperties = {margin?: string; padding?: string} const cssProperties: CSSProperties = {margin: '1px', padding: '2px'} expectTypeOf(getResponsiveProp(cssProperties)) .exclude() .exclude<{xs?: unknown}>() .toEqualTypeOf() expectTypeOf(getResponsiveProp(cssProperties)) .extract() .toEqualTypeOf() expectTypeOf(getResponsiveProp(cssProperties)) .extract<{xs?: any}>() .toEqualTypeOf<{xs?: CSSProperties; sm?: CSSProperties; md?: CSSProperties}>() expectTypeOf>().exclude().toHaveProperty('sm') expectTypeOf>().exclude().not.toHaveProperty('xxl') ``` `.extract` and `.exclude` return never if no types remain after exclusion: ```typescript type Person = {name: string; age: number} type Customer = Person & {customerId: string} type Employee = Person & {employeeId: string} expectTypeOf().extract<{foo: string}>().toBeNever() expectTypeOf().exclude<{name: string}>().toBeNever() ``` Use `.pick` to pick a set of properties from an object: ```typescript type Person = {name: string; age: number} expectTypeOf().pick<'name'>().toEqualTypeOf<{name: string}>() ``` Use `.omit` to remove a set of properties from an object: ```typescript type Person = {name: string; age: number} expectTypeOf().omit<'name'>().toEqualTypeOf<{age: number}>() ``` Make assertions about object properties: ```typescript 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: ```typescript type NoParam = () => void type HasParam = (s: string) => void expectTypeOf().not.toEqualTypeOf() ``` But often it's preferable to use `.parameters` or `.returns` for more specific function assertions: ```typescript type NoParam = () => void type HasParam = (s: string) => void expectTypeOf().parameters.toEqualTypeOf<[]>() expectTypeOf().returns.toBeVoid() expectTypeOf().parameters.toEqualTypeOf<[string]>() expectTypeOf().returns.toBeVoid() ``` Up to ten overloads will produce union types for `.parameters` and `.returns`: ```typescript type Factorize = { (input: number): number[] (input: bigint): bigint[] } expectTypeOf().parameters.toEqualTypeOf<[number] | [bigint]>() expectTypeOf().returns.toEqualTypeOf() expectTypeOf().parameter(0).toEqualTypeOf() ``` 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](#overloaded-functions) section for more information) ```typescript type Factorize = { (input: number): number[] (input: bigint): bigint[] } // overload using `number` is ignored! expectTypeOf>().toEqualTypeOf<[bigint]>() expectTypeOf>().toEqualTypeOf() ``` More examples of ways to work with functions - parameters using `.parameter(n)` or `.parameters`, and return values using `.returns`: ```typescript 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.: ```typescript type Factorize = { (input: number): number[] (input: bigint): bigint[] } expectTypeOf().toBeCallableWith(6) expectTypeOf().toBeCallableWith(6n) ``` `.toBeCallableWith` returns a type that can be used to narrow down the return type for given input parameters.: ```typescript type Factorize = { (input: number): number[] (input: bigint): bigint[] } expectTypeOf().toBeCallableWith(6).returns.toEqualTypeOf() expectTypeOf().toBeCallableWith(6n).returns.toEqualTypeOf() ``` `.toBeCallableWith` can be used to narrow down the parameters of a function: ```typescript type Delete = { (path: string): void (paths: string[], options?: {force: boolean}): void } expectTypeOf().toBeCallableWith('abc').parameters.toEqualTypeOf<[string]>() expectTypeOf() .toBeCallableWith(['abc', 'def'], {force: true}) .parameters.toEqualTypeOf<[string[], {force: boolean}?]>() expectTypeOf().toBeCallableWith('abc').parameter(0).toBeString() expectTypeOf().toBeCallableWith('abc').parameter(1).toBeUndefined() expectTypeOf() .toBeCallableWith(['abc', 'def', 'ghi']) .parameter(0) .toEqualTypeOf() expectTypeOf() .toBeCallableWith(['abc', 'def', 'ghi']) .parameter(1) .toEqualTypeOf<{force: boolean} | undefined>() ``` You can't use `.toBeCallableWith` with `.not` - you need to use ts-expect-error:: ```typescript const f = (a: number) => [a, a] // @ts-expect-error expectTypeOf(f).toBeCallableWith('foo') ``` You can also check type guards & type assertions: ```typescript 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: ```typescript 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: ```typescript 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}) // @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: ```typescript 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: ```typescript 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: ```typescript expectTypeOf(Date).instance.toHaveProperty('toISOString') ``` Promise resolution types can be checked with `.resolves`: ```typescript const asyncFunc = async () => 123 expectTypeOf(asyncFunc).returns.resolves.toBeNumber() ``` Array items can be checked with `.items`: ```typescript expectTypeOf([1, 2, 3]).items.toBeNumber() expectTypeOf([1, 2, 3]).items.not.toBeString() ``` You can also compare arrays directly: ```typescript expectTypeOf().not.toEqualTypeOf() ``` Check that functions never return: ```typescript const thrower = () => { throw new Error('oh no') } expectTypeOf(thrower).returns.toBeNever() ``` Generics can be used rather than references: ```typescript expectTypeOf<{a: string}>().not.toEqualTypeOf<{a: number}>() ``` Distinguish between missing/null/optional properties: ```typescript 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: ```typescript type A1 = {readonly a: string; b: string} type E1 = {a: string; b: string} expectTypeOf().toMatchTypeOf() expectTypeOf().not.toEqualTypeOf() type A2 = {a: string; b: {readonly c: string}} type E2 = {a: string; b: {c: string}} expectTypeOf().toMatchTypeOf() expectTypeOf().not.toEqualTypeOf() ``` Distinguish between classes with different constructors: ```typescript class A { value: number constructor(a: 1) { this.value = a } } class B { value: number constructor(b: 2) { this.value = b } } expectTypeOf().not.toEqualTypeOf() class C { value: number constructor(c: 1) { this.value = c } } expectTypeOf().toEqualTypeOf() ``` Known limitation: Intersection types can cause issues with `toEqualTypeOf`: ```typescript // @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: ```typescript type Simplify = {[K in keyof T]: T[K]} expectTypeOf>().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: ```typescript // @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: ```typescript // 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>() // @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: ```typescript // @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.: ```typescript class B { b = 'b' foo() { // @ts-expect-error expectTypeOf(this).toEqualTypeOf(this) // @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](https://redirect.github.com/microsoft/TypeScript/issues/28867), overloaded functions which include an overload resembling `(...args: unknown[]) => unknown` will exclude `unknown[]` from `.parameters` and exclude `unknown` from `.returns`: ```typescript type Factorize = { (...args: unknown[]): unknown (input: number): number[] (input: bigint): bigint[] } expectTypeOf().parameters.toEqualTypeOf<[number] | [bigint]>() expectTypeOf().returns.toEqualTypeOf() ``` 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: ```typescript // @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](./src/index.ts) for inspiration - or better, use a library like [type-fest](https://npmjs.com/package/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().toEqualTypeOf()`). 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: ```ts 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](https://redirect.github.com/mmkal/expect-type) 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' 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 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](https://redirect.github.com/microsoft/TypeScript/pull/40468) 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: ```ts expectTypeOf({a: 1}).toEqualTypeOf({a: ''}) ``` Will be less helpful than for an assertion like this: ```ts 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`: ```ts const one = valueFromFunctionOne({some: {complex: inputs}}) const two = valueFromFunctionTwo({some: {other: inputs}}) expectTypeOf(one).toEqualTypeof() ``` ##### Overloaded functions Due to a TypeScript [design limitation](https://redirect.github.com/microsoft/TypeScript/issues/32164#issuecomment-506810756), 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](https://vitest.dev/guide/testing-types), 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. ```ts 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. 1. 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](#why-is-my-assertion-failing) for details. TL;DR: use `.brand` in these cases - and accept the performance hit that it comes with. 2. `toBeCallableWith` will likely fail if you try to use it with a generic function or an overload. See [this issue](https://redirect.github.com/mmkal/expect-type/issues/50) for an example and how to work around it. 3. (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](https://redirect.github.com/mmkal/expect-type/issues/30)). 4. `expectTypeOf(this).toEqualTypeOf(this)` inside class methods does not work. #### Similar projects Other projects with similar goals: - [`tsd`](https://redirect.github.com/SamVerschueren/tsd) is a CLI that runs the TypeScript type checker over assertions - [`ts-expect`](https://redirect.github.com/TypeStrong/ts-expect) exports several generic helper types to perform type assertions - [`dtslint`](https://redirect.github.com/Microsoft/dtslint) does type checks via comment directives and tslint - [`type-plus`](https://redirect.github.com/unional/type-plus) comes with various type and runtime TypeScript assertions - [`static-type-assert`](https://redirect.github.com/ksxnodemodules/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](https://redirect.github.com/SamVerschueren/tsd/issues/142)) - first-class support for: - `any` (as well as `unknown` and `never`) (see issues outstanding at time of writing in tsd for [never](https://redirect.github.com/SamVerschueren/tsd/issues/78) and [any](https://redirect.github.com/SamVerschueren/tsd/issues/82)). - 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()` - 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!](./src/index.ts) (tsd, for comparison, is [2.6MB](https://bundlephobia.com/result?p=tsd@0.13.1) because it ships a patched version of TypeScript). *** Thanks to everyone who has helped with this over the years! **Full Changelog**: https://github.com/mmkal/expect-type/compare/v0.20.0...v1.0.0

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - "before 4am on Monday" (UTC).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, 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.

unjs / magic-regexp

chore(deps): update devdependency expect-type to v1 #413

Release Notes

Configuration

Diagnostics Comparison:

CodSpeed Performance Report

Merging #413 will not alter performance

Summary