@vitest/expect 0.30.1 → 0.31.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { use } from 'chai';
-import { stringify } from '@vitest/utils';
+import { stringify, Constructable } from '@vitest/utils';
 export { setupColors } from '@vitest/utils';
 
 type Formatter = (input: string | number | null | undefined) => string;
@@ -104,6 +104,87 @@ interface RawMatcherFn<T extends MatcherState = MatcherState> {
     (this: T, received: any, expected: any, options?: any): ExpectationResult;
 }
 type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
+interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {
+    <T>(actual: T, message?: string): Assertion<T>;
+    extend(expects: MatchersObject): void;
+    assertions(expected: number): void;
+    hasAssertions(): void;
+    anything(): any;
+    any(constructor: unknown): any;
+    getState(): MatcherState;
+    setState(state: Partial<MatcherState>): void;
+    not: AsymmetricMatchersContaining;
+}
+interface AsymmetricMatchersContaining {
+    stringContaining(expected: string): any;
+    objectContaining<T = any>(expected: T): any;
+    arrayContaining<T = unknown>(expected: Array<T>): any;
+    stringMatching(expected: string | RegExp): any;
+}
+interface JestAssertion<T = any> extends jest.Matchers<void, T> {
+    toEqual<E>(expected: E): void;
+    toStrictEqual<E>(expected: E): void;
+    toBe<E>(expected: E): void;
+    toMatch(expected: string | RegExp): void;
+    toMatchObject<E extends {} | any[]>(expected: E): void;
+    toContain<E>(item: E): void;
+    toContainEqual<E>(item: E): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toBeGreaterThan(num: number | bigint): void;
+    toBeGreaterThanOrEqual(num: number | bigint): void;
+    toBeLessThan(num: number | bigint): void;
+    toBeLessThanOrEqual(num: number | bigint): void;
+    toBeNaN(): void;
+    toBeUndefined(): void;
+    toBeNull(): void;
+    toBeDefined(): void;
+    toBeInstanceOf<E>(expected: E): void;
+    toBeCalledTimes(times: number): void;
+    toHaveLength(length: number): void;
+    toHaveProperty<E>(property: string | (string | number)[], value?: E): void;
+    toBeCloseTo(number: number, numDigits?: number): void;
+    toHaveBeenCalledTimes(times: number): void;
+    toHaveBeenCalled(): void;
+    toBeCalled(): void;
+    toHaveBeenCalledWith<E extends any[]>(...args: E): void;
+    toBeCalledWith<E extends any[]>(...args: E): void;
+    toHaveBeenNthCalledWith<E extends any[]>(n: number, ...args: E): void;
+    nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void;
+    toHaveBeenLastCalledWith<E extends any[]>(...args: E): void;
+    lastCalledWith<E extends any[]>(...args: E): void;
+    toThrow(expected?: string | Constructable | RegExp | Error): void;
+    toThrowError(expected?: string | Constructable | RegExp | Error): void;
+    toReturn(): void;
+    toHaveReturned(): void;
+    toReturnTimes(times: number): void;
+    toHaveReturnedTimes(times: number): void;
+    toReturnWith<E>(value: E): void;
+    toHaveReturnedWith<E>(value: E): void;
+    toHaveLastReturnedWith<E>(value: E): void;
+    lastReturnedWith<E>(value: E): void;
+    toHaveNthReturnedWith<E>(nthCall: number, value: E): void;
+    nthReturnedWith<E>(nthCall: number, value: E): void;
+}
+type VitestAssertion<A, T> = {
+    [K in keyof A]: A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T>;
+} & ((type: string, message?: string) => Assertion);
+type Promisify<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
+};
+interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {
+    toBeTypeOf(expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined'): void;
+    toHaveBeenCalledOnce(): void;
+    toSatisfy<E>(matcher: (value: E) => boolean, message?: string): void;
+    resolves: Promisify<Assertion<T>>;
+    rejects: Promisify<Assertion<T>>;
+}
+declare global {
+    namespace jest {
+        interface Matchers<R, T = {}> {
+        }
+    }
+}
 
 interface AsymmetricMatcherInterface {
     asymmetricMatch(other: unknown): boolean;
@@ -116,7 +197,7 @@ declare abstract class AsymmetricMatcher<T, State extends MatcherState = Matcher
     protected inverse: boolean;
     $$typeof: symbol;
     constructor(sample: T, inverse?: boolean);
-    protected getMatcherContext(expect?: Vi.ExpectStatic): State;
+    protected getMatcherContext(expect?: Chai.ExpectStatic): State;
     abstract asymmetricMatch(other: unknown): boolean;
     abstract toString(): string;
     getExpectedType?(): string;
@@ -182,11 +263,11 @@ declare const MATCHERS_OBJECT: unique symbol;
 declare const JEST_MATCHERS_OBJECT: unique symbol;
 declare const GLOBAL_EXPECT: unique symbol;
 
-declare function getState<State extends MatcherState = MatcherState>(expect: Vi.ExpectStatic): State;
-declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: Vi.ExpectStatic): void;
+declare function getState<State extends MatcherState = MatcherState>(expect: ExpectStatic): State;
+declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: ExpectStatic): void;
 
 declare const JestChaiExpect: ChaiPlugin;
 
 declare const JestExtend: ChaiPlugin;
 
-export { Any, Anything, ArrayContaining, AsymmetricMatcher, AsymmetricMatcherInterface, AsyncExpectationResult, ChaiPlugin, DiffOptions, ExpectationResult, FirstFunctionArgument, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, MatcherHintOptions, MatcherState, MatchersObject, ObjectContaining, RawMatcherFn, StringContaining, StringMatching, SyncExpectationResult, Tester, arrayBufferEquality, equals, fnNameFor, generateToBeMessage, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export { Any, Anything, ArrayContaining, Assertion, AsymmetricMatcher, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiPlugin, DiffOptions, ExpectStatic, ExpectationResult, FirstFunctionArgument, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAssertion, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, MatcherHintOptions, MatcherState, MatchersObject, ObjectContaining, RawMatcherFn, StringContaining, StringMatching, SyncExpectationResult, Tester, arrayBufferEquality, equals, fnNameFor, generateToBeMessage, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, setState, sparseArrayEquality, subsetEquality, typeEquality };

package/dist/index.js

@@ -225,7 +225,7 @@ function isA(typeName, value) {
   return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
 }
 function isDomNode(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string" && typeof obj.isEqualNode === "function";
+  return obj !== null && typeof obj === "object" && "nodeType" in obj && typeof obj.nodeType === "number" && "nodeName" in obj && typeof obj.nodeName === "string" && "isEqualNode" in obj && typeof obj.isEqualNode === "function";
 }
 function fnNameFor(func) {
   if (func.name)
@@ -952,7 +952,7 @@ ${spy.mock.calls.map((callArg, i) => {
 
 `);
       if (actualCall)
-        methodCall += diff(callArg, actualCall, { showLegend: false });
+        methodCall += diff(actualCall, callArg, { showLegend: false });
       else
         methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
       methodCall += "\n";
@@ -973,7 +973,7 @@ ${spy.mock.results.map((callReturn, i) => {
 
 `);
       if (actualReturn)
-        methodCall += diff(callReturn.value, actualReturn, { showLegend: false });
+        methodCall += diff(actualReturn, callReturn.value, { showLegend: false });
       else
         methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
       methodCall += "\n";

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "0.30.1",
+  "version": "0.31.1",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/expect#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vitest-dev/vitest.git",
     "directory": "packages/expect"
   },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
   "sideEffects": false,
   "exports": {
     ".": {
@@ -25,8 +30,8 @@
   ],
   "dependencies": {
     "chai": "^4.3.7",
-    "@vitest/spy": "0.30.1",
-    "@vitest/utils": "0.30.1"
+    "@vitest/utils": "0.31.1",
+    "@vitest/spy": "0.31.1"
   },
   "devDependencies": {
     "picocolors": "^1.0.0"