From 2ce6a38b497b0c819e9457afcbd64db7fb83715e Mon Sep 17 00:00:00 2001 From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com> Date: Thu, 5 Jan 2023 21:53:48 +0200 Subject: [PATCH 1/4] fix(types): add vitest support for AsymmetricMatchers --- types/index.d.ts | 895 ++++++++++++++++++++++++----------------------- 1 file changed, 453 insertions(+), 442 deletions(-) diff --git a/types/index.d.ts b/types/index.d.ts index e1eed656..fa1ce76d 100644 --- a/types/index.d.ts +++ b/types/index.d.ts @@ -1,449 +1,452 @@ /* eslint-disable @typescript-eslint/no-explicit-any */ +interface CustomMatchers { + /** + * Note: Currently unimplemented + * Passing assertion + * + * @param {String} message + */ + pass(message: string): R; + + /** + * Note: Currently unimplemented + * Failing assertion + * + * @param {String} message + */ + fail(message: string): never; + + /** + * Use .toBeEmpty when checking if a String '', Array [], Object {} or Iterable (i.e. Map, Set) is empty. + */ + toBeEmpty(): R; + + /** + * Use .toBeOneOf when checking if a value is a member of a given Array. + * @param {Array.<*>} members + */ + toBeOneOf(members: readonly E[]): R; + + /** + * Use `.toBeNil` when checking a value is `null` or `undefined`. + */ + toBeNil(): R; + + /** + * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`. + * @param {Function} predicate + */ + toSatisfy(predicate: (x: E) => boolean): R; + + /** + * Use `.toBeArray` when checking if a value is an `Array`. + */ + toBeArray(): R; + + /** + * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x. + * @param {Number} x + */ + toBeArrayOfSize(x: number): R; + + /** + * Use `.toBeAfter` when checking if a date occurs after `date`. + * @param {Date} date + */ + toBeAfter(date: Date): R; + + /** + * Use `.toBeBefore` when checking if a date occurs before `date`. + * @param {Date} date + */ + toBeBefore(date: Date): R; + + /** + * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set. + * @param {Array.<*>} members + */ + toIncludeAllMembers(members: readonly E[]): R; + + /** + * Use `.toIncludeAllPartialMembers` when checking if an `Array` contains all of the same partial members of a given set. + * @param {Array.<*>} members + */ + toIncludeAllPartialMembers(members: readonly E[]): R; + + /** + * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set. + * @param {Array.<*>} members + */ + toIncludeAnyMembers(members: readonly E[]): R; + + /** + * Use `.toIncludeSameMembers` when checking if two arrays contain equal values, in any order. + * @param {Array.<*>} members + */ + toIncludeSameMembers(members: readonly E[]): R; + + /** + * Use `.toPartiallyContain` when checking if any array value matches the partial member. + * @param {*} member + */ + toPartiallyContain(member: E): R; + + /** + * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array. + * @param {Function} predicate + */ + toSatisfyAll(predicate: (x: E) => boolean): R; + + /** + * Use `.toSatisfyAny` when you want to use a custom matcher by supplying a predicate function that returns `true` for any matching value in an array. + * @param {Function} predicate + */ + toSatisfyAny(predicate: (x: any) => boolean): R; + + /** + * Use `.toBeBoolean` when checking if a value is a `Boolean`. + */ + toBeBoolean(): R; + + /** + * Use `.toBeTrue` when checking a value is equal (===) to `true`. + */ + toBeTrue(): R; + + /** + * Use `.toBeFalse` when checking a value is equal (===) to `false`. + */ + toBeFalse(): R; + + /** + * Use `.toBeDate` when checking if a value is a `Date`. + */ + toBeDate(): R; + + /** + * Use `.toBeValidDate` when checking if a value is a `valid Date`. + */ + toBeValidDate(): R; + + /** + * Use `.toBeFunction` when checking if a value is a `Function`. + */ + toBeFunction(): R; + + /** + * Use `.toBeDateString` when checking if a value is a valid date string. + */ + toBeDateString(): R; + + /** + * Use `.toBeHexadecimal` when checking if a value is a valid HTML hex color. + */ + toBeHexadecimal(): R; + + /** + * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`. + * + * Note: Required Jest version >=23 + * + * @param {Mock} mock + * @param {boolean} [failIfNoSecondInvocation=true] + */ + toHaveBeenCalledBefore(mock: jest.MockInstance, failIfNoSecondInvocation?: boolean): R; + + /** + * Use `.toHaveBeenCalledAfter` when checking if a `Mock` was called after another `Mock`. + * + * Note: Required Jest version >=23 + * + * @param {Mock} mock + * @param {boolean} [failIfNoFirstInvocation=true] + */ + toHaveBeenCalledAfter(mock: jest.MockInstance, failIfNoFirstInvocation?: boolean): R; + + /** + * Use `.toHaveBeenCalledOnce` to check if a `Mock` was called exactly one time. + */ + toHaveBeenCalledOnce(): R; + + /** + * Use `.toHaveBeenCalledOnceWith` to check if a `Mock` was called exactly one time with the expected value. + */ + toHaveBeenCalledOnceWith(arg: unknown): R; + + /** + * Use `.toBeNumber` when checking if a value is a `Number`. + */ + toBeNumber(): R; + + /** + * Use `.toBeNaN` when checking a value is `NaN`. + */ + toBeNaN(): R; + + /** + * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`. + */ + toBeFinite(): R; + + /** + * Use `.toBePositive` when checking if a value is a positive `Number`. + */ + toBePositive(): R; + + /** + * Use `.toBeNegative` when checking if a value is a negative `Number`. + */ + toBeNegative(): R; + + /** + * Use `.toBeEven` when checking if a value is an even `Number`. + */ + toBeEven(): R; + + /** + * Use `.toBeOdd` when checking if a value is an odd `Number`. + */ + toBeOdd(): R; + + /** + * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive). + * + * @param {Number} start + * @param {Number} end + */ + toBeWithin(start: number, end: number): R; + + /** + * Use `.toBeInRange` when checking if an array has elements in range min (inclusive) and max (inclusive). + * + * @param min + * @param max + */ + toBeInRange(min: number, max: number): R; + + /** + * Use `.toBeInteger` when checking if a value is an integer. + */ + toBeInteger(): R; + + /** + * Use `.toBeObject` when checking if a value is an `Object`. + */ + toBeObject(): R; + + /** + * Use `.toContainKey` when checking if an object contains the provided key. + * + * @param {String} key + */ + toContainKey(key: keyof E | string): R; + + /** + * Use `.toContainKeys` when checking if an object has all of the provided keys. + * + * @param {Array.} keys + */ + toContainKeys(keys: readonly (keyof E | string)[]): R; + + /** + * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys. + * + * @param {Array.} keys + */ + toContainAllKeys(keys: readonly (keyof E | string)[]): R; + + /** + * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys. + * + * @param {Array.} keys + */ + toContainAnyKeys(keys: readonly (keyof E | string)[]): R; + + /** + * Use `.toContainValue` when checking if an object contains the provided value. + * + * @param {*} value + */ + toContainValue(value: E): R; + + /** + * Use `.toContainValues` when checking if an object contains all of the provided values. + * + * @param {Array.<*>} values + */ + toContainValues(values: readonly E[]): R; + + /** + * Use `.toContainAllValues` when checking if an object only contains all of the provided values. + * + * @param {Array.<*>} values + */ + toContainAllValues(values: readonly E[]): R; + + /** + * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values. + * + * @param {Array.<*>} values + */ + toContainAnyValues(values: readonly E[]): R; + + /** + * Use `.toContainEntry` when checking if an object contains the provided entry. + * + * @param {Array.} entry + */ + toContainEntry(entry: readonly [keyof E, E[keyof E]]): R; + + /** + * Use `.toContainEntries` when checking if an object contains all of the provided entries. + * + * @param {Array.>} entries + */ + toContainEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; + + /** + * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries. + * + * @param {Array.>} entries + */ + toContainAllEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; + + /** + * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries. + * + * @param {Array.>} entries + */ + toContainAnyEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; + + /** + * Use `.toBeExtensible` when checking if an object is extensible. + */ + toBeExtensible(): R; + + /** + * Use `.toBeFrozen` when checking if an object is frozen. + */ + toBeFrozen(): R; + + /** + * Use `.toBeSealed` when checking if an object is sealed. + */ + toBeSealed(): R; + + /** + * Use `.toResolve` when checking if a promise resolves. + */ + toResolve(): Promise; + + /** + * Use `.toReject` when checking if a promise rejects. + */ + toReject(): Promise; + + /** + * Use `.toBeString` when checking if a value is a `String`. + */ + toBeString(): R; + + /** + * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings. + * + * @param {String} string + */ + toEqualCaseInsensitive(string: string): R; + + /** + * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix. + * + * @param {String} prefix + */ + toStartWith(prefix: string): R; + + /** + * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix. + * + * @param {String} suffix + */ + toEndWith(suffix: string): R; + + /** + * Use `.toInclude` when checking if a `String` includes the given `String` substring. + * + * @param {String} substring + */ + toInclude(substring: string): R; + + /** + * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times. + * + * @param {String} substring + * @param {Number} times + */ + toIncludeRepeated(substring: string, times: number): R; + + /** + * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings. + * + * @param {Array.} substring + */ + toIncludeMultiple(substring: readonly string[]): R; + + /** + * Use `.toThrowWithMessage` when checking if a callback function throws an error of a given type with a given error message. + * + * @param {Function} type + * @param {String | RegExp} message + */ + toThrowWithMessage( + type: + | (new (...args: any[]) => { message: string }) + | (abstract new (...args: any[]) => { message: string }) + | ((...args: any[]) => { message: string }), + message: string | RegExp, + ): R; + + /** + * Use `.toBeEmptyObject` when checking if a value is an empty `Object`. + */ + toBeEmptyObject(): R; + + /** + * Use `.toBeSymbol` when checking if a value is a `Symbol`. + */ + toBeSymbol(): R; + + /** + * Use `.toBeBetween` when checking if a date occurs between `startDate` and `endDate`. + * @param {Date} startDate + * @param {Date} endDate + */ + toBeBetween(startDate: Date, endDate: Date): R; + + /** + * Use `.toBeBeforeOrEqualTo` when checking if a date equals to or occurs before `date`. + * @param {Date} date + */ + toBeBeforeOrEqualTo(date: Date): R; + + /** + * Use `.toBeAfterOrEqualTo` when checking if a date equals to or occurs after `date`. + * @param {Date} date + */ + toBeAfterOrEqualTo(date: Date): R; + + /** + * Use `.toEqualIgnoringWhitespace` when checking if a `String` is equal (===) to given `String` ignoring white-space. + * + * @param {String} string + */ + toEqualIgnoringWhitespace(string: string): R; +} + declare namespace jest { // noinspection JSUnusedGlobalSymbols - interface Matchers { - /** - * Note: Currently unimplemented - * Passing assertion - * - * @param {String} message - */ - pass(message: string): R; - - /** - * Note: Currently unimplemented - * Failing assertion - * - * @param {String} message - */ - fail(message: string): never; - - /** - * Use .toBeEmpty when checking if a String '', Array [], Object {} or Iterable (i.e. Map, Set) is empty. - */ - toBeEmpty(): R; - - /** - * Use .toBeOneOf when checking if a value is a member of a given Array. - * @param {Array.<*>} members - */ - toBeOneOf(members: readonly E[]): R; - - /** - * Use `.toBeNil` when checking a value is `null` or `undefined`. - */ - toBeNil(): R; - - /** - * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`. - * @param {Function} predicate - */ - toSatisfy(predicate: (x: E) => boolean): R; - - /** - * Use `.toBeArray` when checking if a value is an `Array`. - */ - toBeArray(): R; - - /** - * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x. - * @param {Number} x - */ - toBeArrayOfSize(x: number): R; - - /** - * Use `.toBeAfter` when checking if a date occurs after `date`. - * @param {Date} date - */ - toBeAfter(date: Date): R; - - /** - * Use `.toBeBefore` when checking if a date occurs before `date`. - * @param {Date} date - */ - toBeBefore(date: Date): R; - - /** - * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set. - * @param {Array.<*>} members - */ - toIncludeAllMembers(members: readonly E[]): R; - - /** - * Use `.toIncludeAllPartialMembers` when checking if an `Array` contains all of the same partial members of a given set. - * @param {Array.<*>} members - */ - toIncludeAllPartialMembers(members: readonly E[]): R; - - /** - * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set. - * @param {Array.<*>} members - */ - toIncludeAnyMembers(members: readonly E[]): R; - - /** - * Use `.toIncludeSameMembers` when checking if two arrays contain equal values, in any order. - * @param {Array.<*>} members - */ - toIncludeSameMembers(members: readonly E[]): R; - - /** - * Use `.toPartiallyContain` when checking if any array value matches the partial member. - * @param {*} member - */ - toPartiallyContain(member: E): R; - - /** - * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array. - * @param {Function} predicate - */ - toSatisfyAll(predicate: (x: E) => boolean): R; - - /** - * Use `.toSatisfyAny` when you want to use a custom matcher by supplying a predicate function that returns `true` for any matching value in an array. - * @param {Function} predicate - */ - toSatisfyAny(predicate: (x: any) => boolean): R; - - /** - * Use `.toBeBoolean` when checking if a value is a `Boolean`. - */ - toBeBoolean(): R; - - /** - * Use `.toBeTrue` when checking a value is equal (===) to `true`. - */ - toBeTrue(): R; - - /** - * Use `.toBeFalse` when checking a value is equal (===) to `false`. - */ - toBeFalse(): R; - - /** - * Use `.toBeDate` when checking if a value is a `Date`. - */ - toBeDate(): R; - - /** - * Use `.toBeValidDate` when checking if a value is a `valid Date`. - */ - toBeValidDate(): R; - - /** - * Use `.toBeFunction` when checking if a value is a `Function`. - */ - toBeFunction(): R; - - /** - * Use `.toBeDateString` when checking if a value is a valid date string. - */ - toBeDateString(): R; - - /** - * Use `.toBeHexadecimal` when checking if a value is a valid HTML hex color. - */ - toBeHexadecimal(): R; - - /** - * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`. - * - * Note: Required Jest version >=23 - * - * @param {Mock} mock - * @param {boolean} [failIfNoSecondInvocation=true] - */ - toHaveBeenCalledBefore(mock: jest.MockInstance, failIfNoSecondInvocation?: boolean): R; - - /** - * Use `.toHaveBeenCalledAfter` when checking if a `Mock` was called after another `Mock`. - * - * Note: Required Jest version >=23 - * - * @param {Mock} mock - * @param {boolean} [failIfNoFirstInvocation=true] - */ - toHaveBeenCalledAfter(mock: jest.MockInstance, failIfNoFirstInvocation?: boolean): R; - - /** - * Use `.toHaveBeenCalledOnce` to check if a `Mock` was called exactly one time. - */ - toHaveBeenCalledOnce(): R; - - /** - * Use `.toHaveBeenCalledOnceWith` to check if a `Mock` was called exactly one time with the expected value. - */ - toHaveBeenCalledOnceWith(arg: unknown): R; - - /** - * Use `.toBeNumber` when checking if a value is a `Number`. - */ - toBeNumber(): R; - - /** - * Use `.toBeNaN` when checking a value is `NaN`. - */ - toBeNaN(): R; - - /** - * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`. - */ - toBeFinite(): R; - - /** - * Use `.toBePositive` when checking if a value is a positive `Number`. - */ - toBePositive(): R; - - /** - * Use `.toBeNegative` when checking if a value is a negative `Number`. - */ - toBeNegative(): R; - - /** - * Use `.toBeEven` when checking if a value is an even `Number`. - */ - toBeEven(): R; - - /** - * Use `.toBeOdd` when checking if a value is an odd `Number`. - */ - toBeOdd(): R; - - /** - * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive). - * - * @param {Number} start - * @param {Number} end - */ - toBeWithin(start: number, end: number): R; - - /** - * Use `.toBeInRange` when checking if an array has elements in range min (inclusive) and max (inclusive). - * - * @param min - * @param max - */ - toBeInRange(min: number, max: number): R; - - /** - * Use `.toBeInteger` when checking if a value is an integer. - */ - toBeInteger(): R; - - /** - * Use `.toBeObject` when checking if a value is an `Object`. - */ - toBeObject(): R; - - /** - * Use `.toContainKey` when checking if an object contains the provided key. - * - * @param {String} key - */ - toContainKey(key: keyof E | string): R; - - /** - * Use `.toContainKeys` when checking if an object has all of the provided keys. - * - * @param {Array.} keys - */ - toContainKeys(keys: readonly (keyof E | string)[]): R; - - /** - * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys. - * - * @param {Array.} keys - */ - toContainAllKeys(keys: readonly (keyof E | string)[]): R; - - /** - * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys. - * - * @param {Array.} keys - */ - toContainAnyKeys(keys: readonly (keyof E | string)[]): R; - - /** - * Use `.toContainValue` when checking if an object contains the provided value. - * - * @param {*} value - */ - toContainValue(value: E): R; - - /** - * Use `.toContainValues` when checking if an object contains all of the provided values. - * - * @param {Array.<*>} values - */ - toContainValues(values: readonly E[]): R; - - /** - * Use `.toContainAllValues` when checking if an object only contains all of the provided values. - * - * @param {Array.<*>} values - */ - toContainAllValues(values: readonly E[]): R; - - /** - * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values. - * - * @param {Array.<*>} values - */ - toContainAnyValues(values: readonly E[]): R; - - /** - * Use `.toContainEntry` when checking if an object contains the provided entry. - * - * @param {Array.} entry - */ - toContainEntry(entry: readonly [keyof E, E[keyof E]]): R; - - /** - * Use `.toContainEntries` when checking if an object contains all of the provided entries. - * - * @param {Array.>} entries - */ - toContainEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; - - /** - * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries. - * - * @param {Array.>} entries - */ - toContainAllEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; - - /** - * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries. - * - * @param {Array.>} entries - */ - toContainAnyEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; - - /** - * Use `.toBeExtensible` when checking if an object is extensible. - */ - toBeExtensible(): R; - - /** - * Use `.toBeFrozen` when checking if an object is frozen. - */ - toBeFrozen(): R; - - /** - * Use `.toBeSealed` when checking if an object is sealed. - */ - toBeSealed(): R; - - /** - * Use `.toResolve` when checking if a promise resolves. - */ - toResolve(): Promise; - - /** - * Use `.toReject` when checking if a promise rejects. - */ - toReject(): Promise; - - /** - * Use `.toBeString` when checking if a value is a `String`. - */ - toBeString(): R; - - /** - * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings. - * - * @param {String} string - */ - toEqualCaseInsensitive(string: string): R; - - /** - * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix. - * - * @param {String} prefix - */ - toStartWith(prefix: string): R; - - /** - * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix. - * - * @param {String} suffix - */ - toEndWith(suffix: string): R; - - /** - * Use `.toInclude` when checking if a `String` includes the given `String` substring. - * - * @param {String} substring - */ - toInclude(substring: string): R; - - /** - * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times. - * - * @param {String} substring - * @param {Number} times - */ - toIncludeRepeated(substring: string, times: number): R; - - /** - * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings. - * - * @param {Array.} substring - */ - toIncludeMultiple(substring: readonly string[]): R; - - /** - * Use `.toThrowWithMessage` when checking if a callback function throws an error of a given type with a given error message. - * - * @param {Function} type - * @param {String | RegExp} message - */ - toThrowWithMessage( - type: - | (new (...args: any[]) => { message: string }) - | (abstract new (...args: any[]) => { message: string }) - | ((...args: any[]) => { message: string }), - message: string | RegExp, - ): R; - - /** - * Use `.toBeEmptyObject` when checking if a value is an empty `Object`. - */ - toBeEmptyObject(): R; - - /** - * Use `.toBeSymbol` when checking if a value is a `Symbol`. - */ - toBeSymbol(): R; - - /** - * Use `.toBeBetween` when checking if a date occurs between `startDate` and `endDate`. - * @param {Date} startDate - * @param {Date} endDate - */ - toBeBetween(startDate: Date, endDate: Date): R; - - /** - * Use `.toBeBeforeOrEqualTo` when checking if a date equals to or occurs before `date`. - * @param {Date} date - */ - toBeBeforeOrEqualTo(date: Date): R; - - /** - * Use `.toBeAfterOrEqualTo` when checking if a date equals to or occurs after `date`. - * @param {Date} date - */ - toBeAfterOrEqualTo(date: Date): R; - - /** - * Use `.toEqualIgnoringWhitespace` when checking if a `String` is equal (===) to given `String` ignoring white-space. - * - * @param {String} string - */ - toEqualIgnoringWhitespace(string: string): R; - } + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface Matchers extends CustomMatchers {} // noinspection JSUnusedGlobalSymbols interface Expect { @@ -876,3 +879,11 @@ declare namespace jest { // eslint-disable-next-line @typescript-eslint/no-empty-interface interface InverseAsymmetricMatchers extends Expect {} } + +// declare global { +declare namespace Vi { + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface AsymmetricMatchersContaining extends CustomMatchers { + hello(): string; + } +} From 378efb21ac8f870497a0322b24856ded4e27f0df Mon Sep 17 00:00:00 2001 From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com> Date: Thu, 5 Jan 2023 21:58:41 +0200 Subject: [PATCH 2/4] fix(types): remove comment --- types/index.d.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/types/index.d.ts b/types/index.d.ts index fa1ce76d..f1bee48f 100644 --- a/types/index.d.ts +++ b/types/index.d.ts @@ -880,7 +880,6 @@ declare namespace jest { interface InverseAsymmetricMatchers extends Expect {} } -// declare global { declare namespace Vi { // eslint-disable-next-line @typescript-eslint/no-empty-interface interface AsymmetricMatchersContaining extends CustomMatchers { From c7b0c60f7cfab0ceb44fab0d9b4b690b28a29840 Mon Sep 17 00:00:00 2001 From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com> Date: Thu, 5 Jan 2023 21:59:17 +0200 Subject: [PATCH 3/4] fix(types): remove debugging code --- types/index.d.ts | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/types/index.d.ts b/types/index.d.ts index f1bee48f..96ec686d 100644 --- a/types/index.d.ts +++ b/types/index.d.ts @@ -882,7 +882,5 @@ declare namespace jest { declare namespace Vi { // eslint-disable-next-line @typescript-eslint/no-empty-interface - interface AsymmetricMatchersContaining extends CustomMatchers { - hello(): string; - } + interface AsymmetricMatchersContaining extends CustomMatchers {} } From 79ca8fa93b8123a2edf6da589678364f4f442727 Mon Sep 17 00:00:00 2001 From: Raz Luvaton <16746759+rluvaton@users.noreply.github.com> Date: Thu, 5 Jan 2023 22:04:01 +0200 Subject: [PATCH 4/4] fix(types): last update --- types/index.d.ts | 330 +++++++++++++++++++++++------------------------ 1 file changed, 165 insertions(+), 165 deletions(-) diff --git a/types/index.d.ts b/types/index.d.ts index 96ec686d..e2e68121 100644 --- a/types/index.d.ts +++ b/types/index.d.ts @@ -1,13 +1,13 @@ /* eslint-disable @typescript-eslint/no-explicit-any */ -interface CustomMatchers { +interface CustomMatchers { /** * Note: Currently unimplemented * Passing assertion * * @param {String} message */ - pass(message: string): R; + pass(message: string): void; /** * Note: Currently unimplemented @@ -15,134 +15,128 @@ interface CustomMatchers { * * @param {String} message */ - fail(message: string): never; + fail(message: string): void; /** - * Use .toBeEmpty when checking if a String '', Array [], Object {} or Iterable (i.e. Map, Set) is empty. + * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty. */ - toBeEmpty(): R; + toBeEmpty(): void; /** * Use .toBeOneOf when checking if a value is a member of a given Array. * @param {Array.<*>} members */ - toBeOneOf(members: readonly E[]): R; + toBeOneOf(members: readonly E[]): void; /** * Use `.toBeNil` when checking a value is `null` or `undefined`. */ - toBeNil(): R; + toBeNil(): void; /** * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`. * @param {Function} predicate */ - toSatisfy(predicate: (x: E) => boolean): R; + toSatisfy(predicate: (x: E) => boolean): void; /** * Use `.toBeArray` when checking if a value is an `Array`. */ - toBeArray(): R; + toBeArray(): void; /** * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x. * @param {Number} x */ - toBeArrayOfSize(x: number): R; + toBeArrayOfSize(x: number): void; /** * Use `.toBeAfter` when checking if a date occurs after `date`. * @param {Date} date */ - toBeAfter(date: Date): R; + toBeAfter(date: Date): void; /** * Use `.toBeBefore` when checking if a date occurs before `date`. * @param {Date} date */ - toBeBefore(date: Date): R; + toBeBefore(date: Date): void; /** * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set. * @param {Array.<*>} members */ - toIncludeAllMembers(members: readonly E[]): R; - - /** - * Use `.toIncludeAllPartialMembers` when checking if an `Array` contains all of the same partial members of a given set. - * @param {Array.<*>} members - */ - toIncludeAllPartialMembers(members: readonly E[]): R; + toIncludeAllMembers(members: readonly E[]): void; /** * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set. * @param {Array.<*>} members */ - toIncludeAnyMembers(members: readonly E[]): R; + toIncludeAnyMembers(members: readonly E[]): void; /** * Use `.toIncludeSameMembers` when checking if two arrays contain equal values, in any order. * @param {Array.<*>} members */ - toIncludeSameMembers(members: readonly E[]): R; + toIncludeSameMembers(members: readonly E[]): void; /** * Use `.toPartiallyContain` when checking if any array value matches the partial member. * @param {*} member */ - toPartiallyContain(member: E): R; + toPartiallyContain(member: E): void; /** * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array. * @param {Function} predicate */ - toSatisfyAll(predicate: (x: E) => boolean): R; + toSatisfyAll(predicate: (x: E) => boolean): void; /** * Use `.toSatisfyAny` when you want to use a custom matcher by supplying a predicate function that returns `true` for any matching value in an array. * @param {Function} predicate */ - toSatisfyAny(predicate: (x: any) => boolean): R; + toSatisfyAny(predicate: (x: any) => boolean): void; /** * Use `.toBeBoolean` when checking if a value is a `Boolean`. */ - toBeBoolean(): R; + toBeBoolean(): void; /** * Use `.toBeTrue` when checking a value is equal (===) to `true`. */ - toBeTrue(): R; + toBeTrue(): void; /** * Use `.toBeFalse` when checking a value is equal (===) to `false`. */ - toBeFalse(): R; + toBeFalse(): void; /** * Use `.toBeDate` when checking if a value is a `Date`. */ - toBeDate(): R; + toBeDate(): void; /** * Use `.toBeValidDate` when checking if a value is a `valid Date`. */ - toBeValidDate(): R; + toBeValidDate(): void; /** * Use `.toBeFunction` when checking if a value is a `Function`. */ - toBeFunction(): R; + toBeFunction(): void; /** * Use `.toBeDateString` when checking if a value is a valid date string. */ - toBeDateString(): R; + toBeDateString(): void; /** * Use `.toBeHexadecimal` when checking if a value is a valid HTML hex color. */ - toBeHexadecimal(): R; + toBeHexadecimal(): void; /** * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`. @@ -152,7 +146,7 @@ interface CustomMatchers { * @param {Mock} mock * @param {boolean} [failIfNoSecondInvocation=true] */ - toHaveBeenCalledBefore(mock: jest.MockInstance, failIfNoSecondInvocation?: boolean): R; + toHaveBeenCalledBefore(mock: jest.MockInstance, failIfNoSecondInvocation: boolean): void; /** * Use `.toHaveBeenCalledAfter` when checking if a `Mock` was called after another `Mock`. @@ -162,52 +156,52 @@ interface CustomMatchers { * @param {Mock} mock * @param {boolean} [failIfNoFirstInvocation=true] */ - toHaveBeenCalledAfter(mock: jest.MockInstance, failIfNoFirstInvocation?: boolean): R; + toHaveBeenCalledAfter(mock: jest.MockInstance, failIfNoFirstInvocation: boolean): void; /** * Use `.toHaveBeenCalledOnce` to check if a `Mock` was called exactly one time. */ - toHaveBeenCalledOnce(): R; + toHaveBeenCalledOnce(): void; /** * Use `.toHaveBeenCalledOnceWith` to check if a `Mock` was called exactly one time with the expected value. */ - toHaveBeenCalledOnceWith(arg: unknown): R; + toHaveBeenCalledOnceWith(): void; /** * Use `.toBeNumber` when checking if a value is a `Number`. */ - toBeNumber(): R; + toBeNumber(): void; /** * Use `.toBeNaN` when checking a value is `NaN`. */ - toBeNaN(): R; + toBeNaN(): void; /** * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`. */ - toBeFinite(): R; + toBeFinite(): void; /** * Use `.toBePositive` when checking if a value is a positive `Number`. */ - toBePositive(): R; + toBePositive(): void; /** * Use `.toBeNegative` when checking if a value is a negative `Number`. */ - toBeNegative(): R; + toBeNegative(): void; /** * Use `.toBeEven` when checking if a value is an even `Number`. */ - toBeEven(): R; + toBeEven(): void; /** * Use `.toBeOdd` when checking if a value is an odd `Number`. */ - toBeOdd(): R; + toBeOdd(): void; /** * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive). @@ -215,7 +209,7 @@ interface CustomMatchers { * @param {Number} start * @param {Number} end */ - toBeWithin(start: number, end: number): R; + toBeWithin(start: number, end: number): void; /** * Use `.toBeInRange` when checking if an array has elements in range min (inclusive) and max (inclusive). @@ -223,159 +217,154 @@ interface CustomMatchers { * @param min * @param max */ - toBeInRange(min: number, max: number): R; - - /** - * Use `.toBeInteger` when checking if a value is an integer. - */ - toBeInteger(): R; + toBeInRange(min: number, max: number): void; /** * Use `.toBeObject` when checking if a value is an `Object`. */ - toBeObject(): R; + toBeObject(): void; /** * Use `.toContainKey` when checking if an object contains the provided key. * * @param {String} key */ - toContainKey(key: keyof E | string): R; + toContainKey(key: string): void; /** * Use `.toContainKeys` when checking if an object has all of the provided keys. * * @param {Array.} keys */ - toContainKeys(keys: readonly (keyof E | string)[]): R; + toContainKeys(keys: readonly (keyof E | string)[]): void; /** * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys. * * @param {Array.} keys */ - toContainAllKeys(keys: readonly (keyof E | string)[]): R; + toContainAllKeys(keys: readonly (keyof E | string)[]): void; /** * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys. * * @param {Array.} keys */ - toContainAnyKeys(keys: readonly (keyof E | string)[]): R; + toContainAnyKeys(keys: readonly (keyof E | string)[]): void; /** * Use `.toContainValue` when checking if an object contains the provided value. * * @param {*} value */ - toContainValue(value: E): R; + toContainValue(value: E): void; /** * Use `.toContainValues` when checking if an object contains all of the provided values. * * @param {Array.<*>} values */ - toContainValues(values: readonly E[]): R; + toContainValues(values: readonly E[]): void; /** * Use `.toContainAllValues` when checking if an object only contains all of the provided values. * * @param {Array.<*>} values */ - toContainAllValues(values: readonly E[]): R; + toContainAllValues(values: readonly E[]): void; /** * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values. * * @param {Array.<*>} values */ - toContainAnyValues(values: readonly E[]): R; + toContainAnyValues(values: readonly E[]): void; /** * Use `.toContainEntry` when checking if an object contains the provided entry. * - * @param {Array.} entry + * @param {Array.<[keyof E, E[keyof E]>} entry */ - toContainEntry(entry: readonly [keyof E, E[keyof E]]): R; + toContainEntry(entry: readonly [keyof E, E[keyof E]]): void; /** * Use `.toContainEntries` when checking if an object contains all of the provided entries. * * @param {Array.>} entries */ - toContainEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; + toContainEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): void; /** * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries. * * @param {Array.>} entries */ - toContainAllEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; + toContainAllEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): void; /** * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries. * * @param {Array.>} entries */ - toContainAnyEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; + toContainAnyEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): void; /** * Use `.toBeExtensible` when checking if an object is extensible. */ - toBeExtensible(): R; + toBeExtensible(): void; /** * Use `.toBeFrozen` when checking if an object is frozen. */ - toBeFrozen(): R; + toBeFrozen(): void; /** * Use `.toBeSealed` when checking if an object is sealed. */ - toBeSealed(): R; + toBeSealed(): void; /** * Use `.toResolve` when checking if a promise resolves. */ - toResolve(): Promise; + toResolve(): void; /** * Use `.toReject` when checking if a promise rejects. */ - toReject(): Promise; + toReject(): void; /** * Use `.toBeString` when checking if a value is a `String`. */ - toBeString(): R; + toBeString(): void; /** * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings. * * @param {String} string */ - toEqualCaseInsensitive(string: string): R; + toEqualCaseInsensitive(string: string): void; /** * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix. * * @param {String} prefix */ - toStartWith(prefix: string): R; + toStartWith(prefix: string): void; /** * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix. * * @param {String} suffix */ - toEndWith(suffix: string): R; + toEndWith(suffix: string): void; /** * Use `.toInclude` when checking if a `String` includes the given `String` substring. * * @param {String} substring */ - toInclude(substring: string): R; + toInclude(substring: string): void; /** * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times. @@ -383,14 +372,14 @@ interface CustomMatchers { * @param {String} substring * @param {Number} times */ - toIncludeRepeated(substring: string, times: number): R; + toIncludeRepeated(substring: string, times: number): void; /** * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings. * * @param {Array.} substring */ - toIncludeMultiple(substring: readonly string[]): R; + toIncludeMultiple(substring: readonly string[]): void; /** * Use `.toThrowWithMessage` when checking if a callback function throws an error of a given type with a given error message. @@ -398,65 +387,55 @@ interface CustomMatchers { * @param {Function} type * @param {String | RegExp} message */ - toThrowWithMessage( - type: - | (new (...args: any[]) => { message: string }) - | (abstract new (...args: any[]) => { message: string }) - | ((...args: any[]) => { message: string }), - message: string | RegExp, - ): R; + toThrowWithMessage(type: (...args: any[]) => any, message: string | RegExp): void; /** * Use `.toBeEmptyObject` when checking if a value is an empty `Object`. */ - toBeEmptyObject(): R; + toBeEmptyObject(): void; /** * Use `.toBeSymbol` when checking if a value is a `Symbol`. */ - toBeSymbol(): R; + toBeSymbol(): void; /** * Use `.toBeBetween` when checking if a date occurs between `startDate` and `endDate`. * @param {Date} startDate * @param {Date} endDate */ - toBeBetween(startDate: Date, endDate: Date): R; + toBeBetween(startDate: Date, endDate: Date): void; /** * Use `.toBeBeforeOrEqualTo` when checking if a date equals to or occurs before `date`. * @param {Date} date */ - toBeBeforeOrEqualTo(date: Date): R; + toBeBeforeOrEqualTo(date: Date): void; /** * Use `.toBeAfterOrEqualTo` when checking if a date equals to or occurs after `date`. * @param {Date} date */ - toBeAfterOrEqualTo(date: Date): R; + toBeAfterOrEqualTo(date: Date): void; /** * Use `.toEqualIgnoringWhitespace` when checking if a `String` is equal (===) to given `String` ignoring white-space. * * @param {String} string */ - toEqualIgnoringWhitespace(string: string): R; + toEqualIgnoringWhitespace(string: string): void; } declare namespace jest { // noinspection JSUnusedGlobalSymbols - // eslint-disable-next-line @typescript-eslint/no-empty-interface - interface Matchers extends CustomMatchers {} - - // noinspection JSUnusedGlobalSymbols - interface Expect { + interface Matchers { /** * Note: Currently unimplemented * Passing assertion * * @param {String} message */ - pass(message: string): void; + pass(message: string): R; /** * Note: Currently unimplemented @@ -464,128 +443,134 @@ declare namespace jest { * * @param {String} message */ - fail(message: string): void; + fail(message: string): never; /** - * Use .toBeEmpty when checking if a String '', Array [] or Object {} is empty. + * Use .toBeEmpty when checking if a String '', Array [], Object {} or Iterable (i.e. Map, Set) is empty. */ - toBeEmpty(): void; + toBeEmpty(): R; /** * Use .toBeOneOf when checking if a value is a member of a given Array. * @param {Array.<*>} members */ - toBeOneOf(members: readonly E[]): void; + toBeOneOf(members: readonly E[]): R; /** * Use `.toBeNil` when checking a value is `null` or `undefined`. */ - toBeNil(): void; + toBeNil(): R; /** * Use `.toSatisfy` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean`. * @param {Function} predicate */ - toSatisfy(predicate: (x: E) => boolean): void; + toSatisfy(predicate: (x: E) => boolean): R; /** * Use `.toBeArray` when checking if a value is an `Array`. */ - toBeArray(): void; + toBeArray(): R; /** * Use `.toBeArrayOfSize` when checking if a value is an `Array` of size x. * @param {Number} x */ - toBeArrayOfSize(x: number): void; + toBeArrayOfSize(x: number): R; /** * Use `.toBeAfter` when checking if a date occurs after `date`. * @param {Date} date */ - toBeAfter(date: Date): void; + toBeAfter(date: Date): R; /** * Use `.toBeBefore` when checking if a date occurs before `date`. * @param {Date} date */ - toBeBefore(date: Date): void; + toBeBefore(date: Date): R; /** * Use `.toIncludeAllMembers` when checking if an `Array` contains all of the same members of a given set. * @param {Array.<*>} members */ - toIncludeAllMembers(members: readonly E[]): void; + toIncludeAllMembers(members: readonly E[]): R; + + /** + * Use `.toIncludeAllPartialMembers` when checking if an `Array` contains all of the same partial members of a given set. + * @param {Array.<*>} members + */ + toIncludeAllPartialMembers(members: readonly E[]): R; /** * Use `.toIncludeAnyMembers` when checking if an `Array` contains any of the members of a given set. * @param {Array.<*>} members */ - toIncludeAnyMembers(members: readonly E[]): void; + toIncludeAnyMembers(members: readonly E[]): R; /** * Use `.toIncludeSameMembers` when checking if two arrays contain equal values, in any order. * @param {Array.<*>} members */ - toIncludeSameMembers(members: readonly E[]): void; + toIncludeSameMembers(members: readonly E[]): R; /** * Use `.toPartiallyContain` when checking if any array value matches the partial member. * @param {*} member */ - toPartiallyContain(member: E): void; + toPartiallyContain(member: E): R; /** * Use `.toSatisfyAll` when you want to use a custom matcher by supplying a predicate function that returns a `Boolean` for all values in an array. * @param {Function} predicate */ - toSatisfyAll(predicate: (x: E) => boolean): void; + toSatisfyAll(predicate: (x: E) => boolean): R; /** * Use `.toSatisfyAny` when you want to use a custom matcher by supplying a predicate function that returns `true` for any matching value in an array. * @param {Function} predicate */ - toSatisfyAny(predicate: (x: any) => boolean): void; + toSatisfyAny(predicate: (x: any) => boolean): R; /** * Use `.toBeBoolean` when checking if a value is a `Boolean`. */ - toBeBoolean(): void; + toBeBoolean(): R; /** * Use `.toBeTrue` when checking a value is equal (===) to `true`. */ - toBeTrue(): void; + toBeTrue(): R; /** * Use `.toBeFalse` when checking a value is equal (===) to `false`. */ - toBeFalse(): void; + toBeFalse(): R; /** * Use `.toBeDate` when checking if a value is a `Date`. */ - toBeDate(): void; + toBeDate(): R; /** * Use `.toBeValidDate` when checking if a value is a `valid Date`. */ - toBeValidDate(): void; + toBeValidDate(): R; /** * Use `.toBeFunction` when checking if a value is a `Function`. */ - toBeFunction(): void; + toBeFunction(): R; /** * Use `.toBeDateString` when checking if a value is a valid date string. */ - toBeDateString(): void; + toBeDateString(): R; /** * Use `.toBeHexadecimal` when checking if a value is a valid HTML hex color. */ - toBeHexadecimal(): void; + toBeHexadecimal(): R; /** * Use `.toHaveBeenCalledBefore` when checking if a `Mock` was called before another `Mock`. @@ -595,7 +580,7 @@ declare namespace jest { * @param {Mock} mock * @param {boolean} [failIfNoSecondInvocation=true] */ - toHaveBeenCalledBefore(mock: jest.MockInstance, failIfNoSecondInvocation: boolean): void; + toHaveBeenCalledBefore(mock: jest.MockInstance, failIfNoSecondInvocation?: boolean): R; /** * Use `.toHaveBeenCalledAfter` when checking if a `Mock` was called after another `Mock`. @@ -605,52 +590,52 @@ declare namespace jest { * @param {Mock} mock * @param {boolean} [failIfNoFirstInvocation=true] */ - toHaveBeenCalledAfter(mock: jest.MockInstance, failIfNoFirstInvocation: boolean): void; + toHaveBeenCalledAfter(mock: jest.MockInstance, failIfNoFirstInvocation?: boolean): R; /** * Use `.toHaveBeenCalledOnce` to check if a `Mock` was called exactly one time. */ - toHaveBeenCalledOnce(): void; + toHaveBeenCalledOnce(): R; /** * Use `.toHaveBeenCalledOnceWith` to check if a `Mock` was called exactly one time with the expected value. */ - toHaveBeenCalledOnceWith(): void; + toHaveBeenCalledOnceWith(arg: unknown): R; /** * Use `.toBeNumber` when checking if a value is a `Number`. */ - toBeNumber(): void; + toBeNumber(): R; /** * Use `.toBeNaN` when checking a value is `NaN`. */ - toBeNaN(): void; + toBeNaN(): R; /** * Use `.toBeFinite` when checking if a value is a `Number`, not `NaN` or `Infinity`. */ - toBeFinite(): void; + toBeFinite(): R; /** * Use `.toBePositive` when checking if a value is a positive `Number`. */ - toBePositive(): void; + toBePositive(): R; /** * Use `.toBeNegative` when checking if a value is a negative `Number`. */ - toBeNegative(): void; + toBeNegative(): R; /** * Use `.toBeEven` when checking if a value is an even `Number`. */ - toBeEven(): void; + toBeEven(): R; /** * Use `.toBeOdd` when checking if a value is an odd `Number`. */ - toBeOdd(): void; + toBeOdd(): R; /** * Use `.toBeWithin` when checking if a number is in between the given bounds of: start (inclusive) and end (exclusive). @@ -658,7 +643,7 @@ declare namespace jest { * @param {Number} start * @param {Number} end */ - toBeWithin(start: number, end: number): void; + toBeWithin(start: number, end: number): R; /** * Use `.toBeInRange` when checking if an array has elements in range min (inclusive) and max (inclusive). @@ -666,154 +651,159 @@ declare namespace jest { * @param min * @param max */ - toBeInRange(min: number, max: number): void; + toBeInRange(min: number, max: number): R; + + /** + * Use `.toBeInteger` when checking if a value is an integer. + */ + toBeInteger(): R; /** * Use `.toBeObject` when checking if a value is an `Object`. */ - toBeObject(): void; + toBeObject(): R; /** * Use `.toContainKey` when checking if an object contains the provided key. * * @param {String} key */ - toContainKey(key: string): void; + toContainKey(key: keyof E | string): R; /** * Use `.toContainKeys` when checking if an object has all of the provided keys. * * @param {Array.} keys */ - toContainKeys(keys: readonly (keyof E | string)[]): void; + toContainKeys(keys: readonly (keyof E | string)[]): R; /** * Use `.toContainAllKeys` when checking if an object only contains all of the provided keys. * * @param {Array.} keys */ - toContainAllKeys(keys: readonly (keyof E | string)[]): void; + toContainAllKeys(keys: readonly (keyof E | string)[]): R; /** * Use `.toContainAnyKeys` when checking if an object contains at least one of the provided keys. * * @param {Array.} keys */ - toContainAnyKeys(keys: readonly (keyof E | string)[]): void; + toContainAnyKeys(keys: readonly (keyof E | string)[]): R; /** * Use `.toContainValue` when checking if an object contains the provided value. * * @param {*} value */ - toContainValue(value: E): void; + toContainValue(value: E): R; /** * Use `.toContainValues` when checking if an object contains all of the provided values. * * @param {Array.<*>} values */ - toContainValues(values: readonly E[]): void; + toContainValues(values: readonly E[]): R; /** * Use `.toContainAllValues` when checking if an object only contains all of the provided values. * * @param {Array.<*>} values */ - toContainAllValues(values: readonly E[]): void; + toContainAllValues(values: readonly E[]): R; /** * Use `.toContainAnyValues` when checking if an object contains at least one of the provided values. * * @param {Array.<*>} values */ - toContainAnyValues(values: readonly E[]): void; + toContainAnyValues(values: readonly E[]): R; /** * Use `.toContainEntry` when checking if an object contains the provided entry. * - * @param {Array.<[keyof E, E[keyof E]>} entry + * @param {Array.} entry */ - toContainEntry(entry: readonly [keyof E, E[keyof E]]): void; + toContainEntry(entry: readonly [keyof E, E[keyof E]]): R; /** * Use `.toContainEntries` when checking if an object contains all of the provided entries. * * @param {Array.>} entries */ - toContainEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): void; + toContainEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; /** * Use `.toContainAllEntries` when checking if an object only contains all of the provided entries. * * @param {Array.>} entries */ - toContainAllEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): void; + toContainAllEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; /** * Use `.toContainAnyEntries` when checking if an object contains at least one of the provided entries. * * @param {Array.>} entries */ - toContainAnyEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): void; + toContainAnyEntries(entries: readonly (readonly [keyof E, E[keyof E]])[]): R; /** * Use `.toBeExtensible` when checking if an object is extensible. */ - toBeExtensible(): void; + toBeExtensible(): R; /** * Use `.toBeFrozen` when checking if an object is frozen. */ - toBeFrozen(): void; + toBeFrozen(): R; /** * Use `.toBeSealed` when checking if an object is sealed. */ - toBeSealed(): void; + toBeSealed(): R; /** * Use `.toResolve` when checking if a promise resolves. */ - toResolve(): void; + toResolve(): Promise; /** * Use `.toReject` when checking if a promise rejects. */ - toReject(): void; + toReject(): Promise; /** * Use `.toBeString` when checking if a value is a `String`. */ - toBeString(): void; + toBeString(): R; /** * Use `.toEqualCaseInsensitive` when checking if a string is equal (===) to another ignoring the casing of both strings. * * @param {String} string */ - toEqualCaseInsensitive(string: string): void; + toEqualCaseInsensitive(string: string): R; /** * Use `.toStartWith` when checking if a `String` starts with a given `String` prefix. * * @param {String} prefix */ - toStartWith(prefix: string): void; + toStartWith(prefix: string): R; /** * Use `.toEndWith` when checking if a `String` ends with a given `String` suffix. * * @param {String} suffix */ - toEndWith(suffix: string): void; + toEndWith(suffix: string): R; /** * Use `.toInclude` when checking if a `String` includes the given `String` substring. * * @param {String} substring */ - toInclude(substring: string): void; + toInclude(substring: string): R; /** * Use `.toIncludeRepeated` when checking if a `String` includes the given `String` substring the correct number of times. @@ -821,14 +811,14 @@ declare namespace jest { * @param {String} substring * @param {Number} times */ - toIncludeRepeated(substring: string, times: number): void; + toIncludeRepeated(substring: string, times: number): R; /** * Use `.toIncludeMultiple` when checking if a `String` includes all of the given substrings. * * @param {Array.} substring */ - toIncludeMultiple(substring: readonly string[]): void; + toIncludeMultiple(substring: readonly string[]): R; /** * Use `.toThrowWithMessage` when checking if a callback function throws an error of a given type with a given error message. @@ -836,45 +826,55 @@ declare namespace jest { * @param {Function} type * @param {String | RegExp} message */ - toThrowWithMessage(type: (...args: any[]) => any, message: string | RegExp): void; + toThrowWithMessage( + type: + | (new (...args: any[]) => { message: string }) + | (abstract new (...args: any[]) => { message: string }) + | ((...args: any[]) => { message: string }), + message: string | RegExp, + ): R; /** * Use `.toBeEmptyObject` when checking if a value is an empty `Object`. */ - toBeEmptyObject(): void; + toBeEmptyObject(): R; /** * Use `.toBeSymbol` when checking if a value is a `Symbol`. */ - toBeSymbol(): void; + toBeSymbol(): R; /** * Use `.toBeBetween` when checking if a date occurs between `startDate` and `endDate`. * @param {Date} startDate * @param {Date} endDate */ - toBeBetween(startDate: Date, endDate: Date): void; + toBeBetween(startDate: Date, endDate: Date): R; /** * Use `.toBeBeforeOrEqualTo` when checking if a date equals to or occurs before `date`. * @param {Date} date */ - toBeBeforeOrEqualTo(date: Date): void; + toBeBeforeOrEqualTo(date: Date): R; /** * Use `.toBeAfterOrEqualTo` when checking if a date equals to or occurs after `date`. * @param {Date} date */ - toBeAfterOrEqualTo(date: Date): void; + toBeAfterOrEqualTo(date: Date): R; /** * Use `.toEqualIgnoringWhitespace` when checking if a `String` is equal (===) to given `String` ignoring white-space. * * @param {String} string */ - toEqualIgnoringWhitespace(string: string): void; + toEqualIgnoringWhitespace(string: string): R; } + // noinspection JSUnusedGlobalSymbols + // eslint-disable-next-line @typescript-eslint/no-empty-interface + interface Expect extends CustomMatchers {} + // noinspection JSUnusedGlobalSymbols // eslint-disable-next-line @typescript-eslint/no-empty-interface interface InverseAsymmetricMatchers extends Expect {}