@vitest/expect 4.0.0-beta.8 → 4.0.0

package/dist/index.d.ts

@@ -1,18 +1,20 @@
 import { MockInstance } from '@vitest/spy';
-import { stringify, Constructable } from '@vitest/utils';
+import { Constructable } from '@vitest/utils';
 import { Formatter } from 'tinyrainbow';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { diff, printDiffOrStringify } from '@vitest/utils/diff';
 export { DiffOptions } from '@vitest/utils/diff';
+import { stringify } from '@vitest/utils/display';
+import * as chai from 'chai';
+export { chai };
 
 declare const MATCHERS_OBJECT: unique symbol;
 declare const JEST_MATCHERS_OBJECT: unique symbol;
 declare const GLOBAL_EXPECT: unique symbol;
 declare const ASYMMETRIC_MATCHERS_OBJECT: unique symbol;
 
-/* eslint-disable unicorn/no-instanceof-builtins -- we check both */
-
 interface AsymmetricMatcherInterface {
-	asymmetricMatch: (other: unknown) => boolean;
+	asymmetricMatch: (other: unknown, customTesters?: Array<Tester>) => boolean;
 	toString: () => string;
 	getExpectedType?: () => string;
 	toAsymmetricMatcher?: () => string;
@@ -23,11 +25,10 @@ declare abstract class AsymmetricMatcher<
 > implements AsymmetricMatcherInterface {
 	protected sample: T;
 	protected inverse: boolean;
-	// should have "jest" to be compatible with its ecosystem
 	$$typeof: symbol;
 	constructor(sample: T, inverse?: boolean);
 	protected getMatcherContext(expect?: Chai.ExpectStatic): State;
-	abstract asymmetricMatch(other: unknown): boolean;
+	abstract asymmetricMatch(other: unknown, customTesters?: Array<Tester>): boolean;
 	abstract toString(): string;
 	getExpectedType?(): string;
 	toAsymmetricMatcher?(): string;
@@ -48,13 +49,13 @@ declare class ObjectContaining extends AsymmetricMatcher<Record<string | symbol
 	getPrototype(obj: object): any;
 	hasProperty(obj: object | null, property: string | symbol): boolean;
 	getProperties(obj: object): (string | symbol)[];
-	asymmetricMatch(other: any): boolean;
+	asymmetricMatch(other: any, customTesters?: Array<Tester>): boolean;
 	toString(): string;
 	getExpectedType(): string;
 }
 declare class ArrayContaining<T = unknown> extends AsymmetricMatcher<Array<T>> {
 	constructor(sample: Array<T>, inverse?: boolean);
-	asymmetricMatch(other: Array<T>): boolean;
+	asymmetricMatch(other: Array<T>, customTesters?: Array<Tester>): boolean;
 	toString(): string;
 	getExpectedType(): string;
 }
@@ -72,6 +73,14 @@ declare class StringMatching extends AsymmetricMatcher<RegExp> {
 	toString(): string;
 	getExpectedType(): string;
 }
+declare class SchemaMatching extends AsymmetricMatcher<StandardSchemaV1<unknown, unknown>> {
+	private result;
+	constructor(sample: StandardSchemaV1<unknown, unknown>, inverse?: boolean);
+	asymmetricMatch(other: unknown): boolean;
+	toString(): string;
+	getExpectedType(): string;
+	toAsymmetricMatcher(): string;
+}
 declare const JestAsymmetricMatchers: ChaiPlugin;
 
 declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
@@ -130,9 +139,7 @@ interface MatcherState {
 	isExpectingAssertions?: boolean;
 	isExpectingAssertionsError?: Error | null;
 	isNot: boolean;
-	// environment: VitestEnvironment
 	promise: string;
-	// snapshotState: SnapshotState
 	suppressedErrors: Array<Error>;
 	testPath?: string;
 	utils: ReturnType<typeof getMatcherUtils> & {
@@ -158,9 +165,6 @@ interface RawMatcherFn<
 > {
 	(this: T, received: any, ...expected: E): ExpectationResult;
 }
-// Allow unused `T` to preserve its name for extensions.
-// Type parameter names must be identical when extending those types.
-// eslint-disable-next-line
 interface Matchers<T = any> {}
 type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>> & ThisType<T> & { [K in keyof Matchers<T>]? : RawMatcherFn<T, Parameters<Matchers<T>[K]>> };
 interface ExpectStatic extends Chai.ExpectStatic, Matchers, AsymmetricMatchersContaining {
@@ -235,6 +239,16 @@ interface AsymmetricMatchersContaining extends CustomMatcher {
 	* expect(5.11).toEqual(expect.closeTo(5.12)); // with default precision
 	*/
 	closeTo: (expected: number, precision?: number) => any;
+	/**
+	* Matches if the received value validates against a Standard Schema.
+	*
+	* @param schema - A Standard Schema V1 compatible schema object
+	*
+	* @example
+	* expect(user).toEqual(expect.schemaMatching(z.object({ name: z.string() })))
+	* expect(['hello', 'world']).toEqual([expect.schemaMatching(z.string()), expect.schemaMatching(z.string())])
+	*/
+	schemaMatching: (schema: unknown) => any;
 }
 type WithAsymmetricMatcher<T> = T | AsymmetricMatcher<unknown>;
 type DeeplyAllowMatchers<T> = T extends Array<infer Element> ? WithAsymmetricMatcher<T> | DeeplyAllowMatchers<Element>[] : T extends object ? WithAsymmetricMatcher<T> | { [K in keyof T] : DeeplyAllowMatchers<T[K]> } : WithAsymmetricMatcher<T>;
@@ -744,52 +758,22 @@ interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAss
 	rejects: PromisifyAssertion<T>;
 }
 declare global {
-	// support augmenting jest.Matchers by other libraries
-	// eslint-disable-next-line ts/no-namespace
 	namespace jest {
-		// eslint-disable-next-line unused-imports/no-unused-vars, ts/no-empty-object-type
-interface Matchers<
+		interface Matchers<
 			R,
 			T = {}
 		> {}
 	}
 }
 
-// selectively ported from https://github.com/jest-community/jest-extended
 declare const customMatchers: MatchersObject;
 
-// Jest Expect Compact
 declare const JestChaiExpect: ChaiPlugin;
 
 declare const JestExtend: ChaiPlugin;
 
-/*
-Copyright (c) 2008-2016 Pivotal Labs
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-
-// Extracted out of jasmine 2.5.2
 declare function equals(a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean): boolean;
-declare function isAsymmetric(obj: any): boolean;
+declare function isAsymmetric(obj: any): obj is AsymmetricMatcher<any>;
 declare function hasAsymmetric(obj: any, seen?: Set<any>): boolean;
 declare function isA(typeName: string, value: unknown): boolean;
 declare function fnNameFor(func: Function): string;
@@ -808,9 +792,13 @@ declare function getObjectSubset(object: any, subset: any, customTesters: Array<
 	subset: any;
 	stripped: number;
 };
+/**
+* Detects if an object is a Standard Schema V1 compatible schema
+*/
+declare function isStandardSchema(obj: any): obj is StandardSchemaV1;
 
 declare function getState<State extends MatcherState = MatcherState>(expect: ExpectStatic): State;
 declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: ExpectStatic): void;
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
 export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };

package/dist/index.js

@@ -1,9 +1,12 @@
-import { getType, stringify, isObject, noop, assertTypes } from '@vitest/utils';
 import { printDiffOrStringify, diff } from '@vitest/utils/diff';
+import { stringify } from '@vitest/utils/display';
+import { getType, isObject, noop, assertTypes } from '@vitest/utils/helpers';
 import c from 'tinyrainbow';
 import { isMockFunction } from '@vitest/spy';
 import { processError } from '@vitest/utils/error';
 import { use, util } from 'chai';
+import * as chai from 'chai';
+export { chai };
 
 const MATCHERS_OBJECT = Symbol.for("matchers-object");
 const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
@@ -178,24 +181,24 @@ function hasAsymmetric(obj, seen = new Set()) {
 	}
 	return false;
 }
-function asymmetricMatch(a, b) {
+function asymmetricMatch(a, b, customTesters) {
 	const asymmetricA = isAsymmetric(a);
 	const asymmetricB = isAsymmetric(b);
 	if (asymmetricA && asymmetricB) {
 		return undefined;
 	}
 	if (asymmetricA) {
-		return a.asymmetricMatch(b);
+		return a.asymmetricMatch(b, customTesters);
 	}
 	if (asymmetricB) {
-		return b.asymmetricMatch(a);
+		return b.asymmetricMatch(a, customTesters);
 	}
 }
 // Equality function lovingly adapted from isEqual in
 //   [Underscore](http://underscorejs.org)
 function eq(a, b, aStack, bStack, customTesters, hasKey) {
 	let result = true;
-	const asymmetricResult = asymmetricMatch(a, b);
+	const asymmetricResult = asymmetricMatch(a, b, customTesters);
 	if (asymmetricResult !== undefined) {
 		return asymmetricResult;
 	}
@@ -339,7 +342,7 @@ function hasDefinedKey(obj, key) {
 	return hasKey(obj, key) && obj[key] !== undefined;
 }
 function hasKey(obj, key) {
-	return Object.prototype.hasOwnProperty.call(obj, key);
+	return Object.hasOwn(obj, key);
 }
 function isA(typeName, value) {
 	return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
@@ -367,7 +370,7 @@ function hasProperty(obj, property) {
 	if (!obj) {
 		return false;
 	}
-	if (Object.prototype.hasOwnProperty.call(obj, property)) {
+	if (Object.hasOwn(obj, property)) {
 		return true;
 	}
 	return hasProperty(getPrototype(obj), property);
@@ -514,7 +517,7 @@ function hasPropertyInObject(object, key) {
 	if (shouldTerminate) {
 		return false;
 	}
-	return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
+	return Object.hasOwn(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
 }
 function isObjectWithKeys(a) {
 	return isObject(a) && !(a instanceof Error) && !Array.isArray(a) && !(a instanceof Date);
@@ -657,8 +660,14 @@ function getObjectSubset(object, subset, customTesters) {
 		stripped
 	};
 }
+/**
+* Detects if an object is a Standard Schema V1 compatible schema
+*/
+function isStandardSchema(obj) {
+	return !!obj && typeof obj === "object" && obj["~standard"] && typeof obj["~standard"].validate === "function";
+}
 
-if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
+if (!Object.hasOwn(globalThis, MATCHERS_OBJECT)) {
 	const globalState = new WeakMap();
 	const matchers = Object.create(null);
 	const customEqualityTesters = [];
@@ -780,12 +789,11 @@ class ObjectContaining extends AsymmetricMatcher {
 			return (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(obj, s)) === null || _Object$getOwnPropert === void 0 ? void 0 : _Object$getOwnPropert.enumerable;
 		})];
 	}
-	asymmetricMatch(other) {
+	asymmetricMatch(other, customTesters) {
 		if (typeof this.sample !== "object") {
 			throw new TypeError(`You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`);
 		}
 		let result = true;
-		const matcherContext = this.getMatcherContext();
 		const properties = this.getProperties(this.sample);
 		for (const property of properties) {
 			var _Object$getOwnPropert2, _Object$getOwnPropert3;
@@ -795,7 +803,7 @@ class ObjectContaining extends AsymmetricMatcher {
 			}
 			const value = ((_Object$getOwnPropert2 = Object.getOwnPropertyDescriptor(this.sample, property)) === null || _Object$getOwnPropert2 === void 0 ? void 0 : _Object$getOwnPropert2.value) ?? this.sample[property];
 			const otherValue = ((_Object$getOwnPropert3 = Object.getOwnPropertyDescriptor(other, property)) === null || _Object$getOwnPropert3 === void 0 ? void 0 : _Object$getOwnPropert3.value) ?? other[property];
-			if (!equals(value, otherValue, matcherContext.customTesters)) {
+			if (!equals(value, otherValue, customTesters)) {
 				result = false;
 				break;
 			}
@@ -813,12 +821,11 @@ class ArrayContaining extends AsymmetricMatcher {
 	constructor(sample, inverse = false) {
 		super(sample, inverse);
 	}
-	asymmetricMatch(other) {
+	asymmetricMatch(other, customTesters) {
 		if (!Array.isArray(this.sample)) {
 			throw new TypeError(`You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`);
 		}
-		const matcherContext = this.getMatcherContext();
-		const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every((item) => other.some((another) => equals(item, another, matcherContext.customTesters)));
+		const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every((item) => other.some((another) => equals(item, another, customTesters)));
 		return this.inverse ? !result : result;
 	}
 	toString() {
@@ -951,6 +958,40 @@ class CloseTo extends AsymmetricMatcher {
 		].join(" ");
 	}
 }
+class SchemaMatching extends AsymmetricMatcher {
+	result;
+	constructor(sample, inverse = false) {
+		if (!isStandardSchema(sample)) {
+			throw new TypeError("SchemaMatching expected to receive a Standard Schema.");
+		}
+		super(sample, inverse);
+	}
+	asymmetricMatch(other) {
+		const result = this.sample["~standard"].validate(other);
+		// Check if the result is a Promise (async validation)
+		if (result instanceof Promise) {
+			throw new TypeError("Async schema validation is not supported in asymmetric matchers.");
+		}
+		this.result = result;
+		const pass = !this.result.issues || this.result.issues.length === 0;
+		return this.inverse ? !pass : pass;
+	}
+	toString() {
+		return `Schema${this.inverse ? "Not" : ""}Matching`;
+	}
+	getExpectedType() {
+		return "object";
+	}
+	toAsymmetricMatcher() {
+		var _this$result;
+		const { utils } = this.getMatcherContext();
+		const issues = ((_this$result = this.result) === null || _this$result === void 0 ? void 0 : _this$result.issues) || [];
+		if (issues.length > 0) {
+			return `${this.toString()} ${utils.stringify(this.result, undefined, { printBasicPrototype: false })}`;
+		}
+		return this.toString();
+	}
+}
 const JestAsymmetricMatchers = (chai, utils) => {
 	utils.addMethod(chai.expect, "anything", () => new Anything());
 	utils.addMethod(chai.expect, "any", (expected) => new Any(expected));
@@ -959,13 +1000,15 @@ const JestAsymmetricMatchers = (chai, utils) => {
 	utils.addMethod(chai.expect, "arrayContaining", (expected) => new ArrayContaining(expected));
 	utils.addMethod(chai.expect, "stringMatching", (expected) => new StringMatching(expected));
 	utils.addMethod(chai.expect, "closeTo", (expected, precision) => new CloseTo(expected, precision));
+	utils.addMethod(chai.expect, "schemaMatching", (expected) => new SchemaMatching(expected));
 	// defineProperty does not work
 	chai.expect.not = {
 		stringContaining: (expected) => new StringContaining(expected, true),
 		objectContaining: (expected) => new ObjectContaining(expected, true),
 		arrayContaining: (expected) => new ArrayContaining(expected, true),
 		stringMatching: (expected) => new StringMatching(expected, true),
-		closeTo: (expected, precision) => new CloseTo(expected, precision, true)
+		closeTo: (expected, precision) => new CloseTo(expected, precision, true),
+		schemaMatching: (expected) => new SchemaMatching(expected, true)
 	};
 };
 
@@ -1282,7 +1325,7 @@ const JestChaiExpect = (chai, utils) => {
 		const actual = this._obj;
 		const [propertyName, expected] = args;
 		const getValue = () => {
-			const hasOwn = Object.prototype.hasOwnProperty.call(actual, propertyName);
+			const hasOwn = Object.hasOwn(actual, propertyName);
 			if (hasOwn) {
 				return {
 					value: actual[propertyName],
@@ -1401,7 +1444,7 @@ const JestChaiExpect = (chai, utils) => {
 	def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
 		const spy = getSpy(this);
 		const spyName = spy.getMockName();
-		const lastCall = spy.mock.calls[spy.mock.calls.length - 1];
+		const lastCall = spy.mock.calls.at(-1);
 		this.assert(lastCall && equalsArgumentArray(lastCall, args), `expected last "${spyName}" call to have been called with #{exp}`, `expected last "${spyName}" call to not have been called with #{exp}`, args, lastCall);
 	});
 	/**
@@ -1540,22 +1583,22 @@ const JestChaiExpect = (chai, utils) => {
 	[{
 		name: "toHaveLastResolvedWith",
 		condition: (spy, value) => {
-			const result = spy.mock.settledResults[spy.mock.settledResults.length - 1];
-			return result && result.type === "fulfilled" && equals(result.value, value);
+			const result = spy.mock.settledResults.at(-1);
+			return Boolean(result && result.type === "fulfilled" && equals(result.value, value));
 		},
 		action: "resolve"
 	}, {
 		name: ["toHaveLastReturnedWith", "lastReturnedWith"],
 		condition: (spy, value) => {
-			const result = spy.mock.results[spy.mock.results.length - 1];
-			return result && result.type === "return" && equals(result.value, value);
+			const result = spy.mock.results.at(-1);
+			return Boolean(result && result.type === "return" && equals(result.value, value));
 		},
 		action: "return"
 	}].forEach(({ name, condition, action }) => {
 		def(name, function(value) {
 			const spy = getSpy(this);
 			const results = action === "return" ? spy.mock.results : spy.mock.settledResults;
-			const result = results[results.length - 1];
+			const result = results.at(-1);
 			const spyName = spy.getMockName();
 			this.assert(condition(spy, value), `expected last "${spyName}" call to ${action} #{exp}`, `expected last "${spyName}" call to not ${action} #{exp}`, value, result === null || result === void 0 ? void 0 : result.value);
 		});
@@ -1713,6 +1756,7 @@ function getMatcherState(assertion, expect) {
 	const obj = assertion._obj;
 	const isNot = util.flag(assertion, "negate");
 	const promise = util.flag(assertion, "promise") || "";
+	const customMessage = util.flag(assertion, "message");
 	const jestUtils = {
 		...getMatcherUtils(),
 		diff,
@@ -1734,7 +1778,8 @@ function getMatcherState(assertion, expect) {
 	return {
 		state: matcherState,
 		isNot,
-		obj
+		obj,
+		customMessage
 	};
 }
 class JestExtendError extends Error {
@@ -1748,19 +1793,21 @@ function JestExtendPlugin(c, expect, matchers) {
 	return (_, utils) => {
 		Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
 			function expectWrapper(...args) {
-				const { state, isNot, obj } = getMatcherState(this, expect);
+				const { state, isNot, obj, customMessage } = getMatcherState(this, expect);
 				const result = expectAssertion.call(state, obj, ...args);
 				if (result && typeof result === "object" && typeof result.then === "function") {
 					const thenable = result;
 					return thenable.then(({ pass, message, actual, expected }) => {
 						if (pass && isNot || !pass && !isNot) {
-							throw new JestExtendError(message(), actual, expected);
+							const errorMessage = customMessage != null ? customMessage : message();
+							throw new JestExtendError(errorMessage, actual, expected);
 						}
 					});
 				}
 				const { pass, message, actual, expected } = result;
 				if (pass && isNot || !pass && !isNot) {
-					throw new JestExtendError(message(), actual, expected);
+					const errorMessage = customMessage != null ? customMessage : message();
+					throw new JestExtendError(errorMessage, actual, expected);
 				}
 			}
 			const softWrapper = wrapAssertion(utils, expectAssertionName, expectWrapper);
@@ -1814,4 +1861,4 @@ const JestExtend = (chai, utils) => {
 	});
 };
 
-export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };
+export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, setState, sparseArrayEquality, subsetEquality, typeEquality };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "4.0.0-beta.8",
+  "version": "4.0.0",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -29,18 +29,18 @@
     "dist"
   ],
   "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
     "@types/chai": "^5.2.2",
-    "chai": "^5.2.1",
-    "tinyrainbow": "^2.0.0",
-    "@vitest/spy": "4.0.0-beta.8",
-    "@vitest/utils": "4.0.0-beta.8"
+    "chai": "^6.0.1",
+    "tinyrainbow": "^3.0.3",
+    "@vitest/utils": "4.0.0",
+    "@vitest/spy": "4.0.0"
   },
   "devDependencies": {
-    "rollup-plugin-copy": "^3.5.0",
-    "@vitest/runner": "4.0.0-beta.8"
+    "@vitest/runner": "4.0.0"
   },
   "scripts": {
-    "build": "rimraf dist && rollup -c",
+    "build": "premove dist && rollup -c",
     "dev": "rollup -c --watch"
   }
 }