vitest 0.0.89 → 0.0.90

package/dist/cli.js

@@ -632,7 +632,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.0.89";
+var version = "0.0.90";
 
 const cli = cac("vitest");
 cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-o, --open", "open Vitest UI").option("--api", "listen to port and serve API").option("--threads", "enabled threads", { default: true }).option("--silent", "silent").option("--global", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment", {

package/dist/entry.js

@@ -714,12 +714,12 @@ function printObjectProperties(val, config, indentation, depth, refs, printer) {
   return result;
 }
 
-var AsymmetricMatcher$2 = {};
+var AsymmetricMatcher$3 = {};
 
-Object.defineProperty(AsymmetricMatcher$2, '__esModule', {
+Object.defineProperty(AsymmetricMatcher$3, '__esModule', {
   value: true
 });
-AsymmetricMatcher$2.default = AsymmetricMatcher$2.test = AsymmetricMatcher$2.serialize = void 0;
+AsymmetricMatcher$3.default = AsymmetricMatcher$3.test = AsymmetricMatcher$3.serialize = void 0;
 
 var _collections$3 = collections;
 
@@ -820,17 +820,17 @@ const serialize$7 = (val, config, indentation, depth, refs, printer) => {
   return val.toAsymmetricMatcher();
 };
 
-AsymmetricMatcher$2.serialize = serialize$7;
+AsymmetricMatcher$3.serialize = serialize$7;
 
 const test$6 = val => val && val.$$typeof === asymmetricMatcher;
 
-AsymmetricMatcher$2.test = test$6;
+AsymmetricMatcher$3.test = test$6;
 const plugin$6 = {
   serialize: serialize$7,
   test: test$6
 };
 var _default$7 = plugin$6;
-AsymmetricMatcher$2.default = _default$7;
+AsymmetricMatcher$3.default = _default$7;
 
 var ConvertAnsi = {};
 
@@ -2073,7 +2073,7 @@ var _ansiStyles = _interopRequireDefault(ansiStyles.exports);
 var _collections = collections;
 
 var _AsymmetricMatcher = _interopRequireDefault(
-  AsymmetricMatcher$2
+  AsymmetricMatcher$3
 );
 
 var _ConvertAnsi = _interopRequireDefault(ConvertAnsi);
@@ -2663,7 +2663,7 @@ const {
   Immutable: Immutable$1,
   ReactElement: ReactElement$1,
   ReactTestComponent: ReactTestComponent$1,
-  AsymmetricMatcher: AsymmetricMatcher$1
+  AsymmetricMatcher: AsymmetricMatcher$2
 } = plugins_1;
 let PLUGINS$1 = [
   ReactTestComponent$1,
@@ -2671,7 +2671,7 @@ let PLUGINS$1 = [
   DOMElement$1,
   DOMCollection$1,
   Immutable$1,
-  AsymmetricMatcher$1
+  AsymmetricMatcher$2
 ];
 const getSerializers = () => PLUGINS$1;
 
@@ -2976,20 +2976,18 @@ function getSnapshotClient() {
     _client = new SnapshotClient();
   return _client;
 }
-function SnapshotPlugin() {
-  return function(chai, utils) {
-    for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-      utils.addMethod(chai.Assertion.prototype, key, function(message) {
-        const expected = utils.flag(this, "object");
-        getSnapshotClient().assert(expected, message);
-      });
-    }
-    utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function(inlineSnapshot, message) {
+const SnapshotPlugin = (chai, utils) => {
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+    utils.addMethod(chai.Assertion.prototype, key, function(message) {
       const expected = utils.flag(this, "object");
-      getSnapshotClient().assert(expected, message, inlineSnapshot);
+      getSnapshotClient().assert(expected, message);
     });
-  };
-}
+  }
+  utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function(inlineSnapshot, message) {
+    const expected = utils.flag(this, "object");
+    getSnapshotClient().assert(expected, message, inlineSnapshot);
+  });
+};
 
 const EXPECTED_COLOR = c$1.green;
 const RECEIVED_COLOR = c$1.red;
@@ -2997,7 +2995,7 @@ const INVERTED_COLOR = c$1.inverse;
 const BOLD_WEIGHT = c$1.bold;
 const DIM_COLOR = c$1.dim;
 const {
-  AsymmetricMatcher,
+  AsymmetricMatcher: AsymmetricMatcher$1,
   DOMCollection,
   DOMElement,
   Immutable,
@@ -3010,7 +3008,7 @@ const PLUGINS = [
   DOMElement,
   DOMCollection,
   Immutable,
-  AsymmetricMatcher
+  AsymmetricMatcher$1
 ];
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
   const {
@@ -3106,6 +3104,20 @@ function equals(a, b, customTesters, strictCheck) {
 function isAsymmetric(obj) {
   return !!obj && isA("Function", obj.asymmetricMatch);
 }
+function hasAsymmetric(obj, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(obj))
+    return false;
+  seen.add(obj);
+  if (isAsymmetric(obj))
+    return true;
+  if (Array.isArray(obj))
+    return obj.some((i) => hasAsymmetric(i, seen));
+  if (obj instanceof Set)
+    return Array.from(obj).some((i) => hasAsymmetric(i, seen));
+  if (isObject(obj))
+    return Object.values(obj).some((v) => hasAsymmetric(v, seen));
+  return false;
+}
 function asymmetricMatch(a, b) {
   const asymmetricA = isAsymmetric(a);
   const asymmetricB = isAsymmetric(b);
@@ -3377,201 +3389,258 @@ function JestExtendPlugin(expects) {
     });
   };
 }
-function JestExtend() {
-  return (chai2, utils) => {
-    utils.addMethod(chai2.expect, "extend", (expects) => {
-      chai2.use(JestExtendPlugin(expects));
-    });
-  };
-}
+const JestExtend = (chai2, utils) => {
+  utils.addMethod(chai2.expect, "extend", (expects) => {
+    chai2.use(JestExtendPlugin(expects));
+  });
+};
 
-function JestChaiExpect() {
-  return (chai, utils) => {
-    function def(name, fn) {
-      const addMethod = (n) => {
-        utils.addMethod(chai.Assertion.prototype, n, fn);
-      };
-      if (Array.isArray(name))
-        name.forEach((n) => addMethod(n));
-      else
-        addMethod(name);
-    }
-    def("toEqual", function(expected) {
-      return this.eql(expected);
-    });
-    def("toStrictEqual", function(expected) {
-      return this.equal(expected);
-    });
-    def("toBe", function(expected) {
-      return this.equal(expected);
-    });
-    def("toMatchObject", function(expected) {
-      return this.containSubset(expected);
-    });
-    def("toMatch", function(expected) {
-      if (typeof expected === "string")
-        return this.include(expected);
-      else
-        return this.match(expected);
-    });
-    def("toContain", function(item) {
-      return this.contain(item);
-    });
-    def("toContainEqual", function(expected) {
-      const obj = utils.flag(this, "object");
-      const index = Array.from(obj).findIndex((item) => {
-        try {
-          chai.assert.deepEqual(item, expected);
-        } catch {
-          return false;
-        }
-        return true;
-      });
-      this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
-    });
-    def("toBeTruthy", function() {
-      const obj = utils.flag(this, "object");
-      this.assert(Boolean(obj), "expected #{this} to be truthy", "expected #{this} to not be truthy", obj);
-    });
-    def("toBeFalsy", function() {
-      const obj = utils.flag(this, "object");
-      this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
-    });
-    def("toBeGreaterThan", function(expected) {
-      return this.to.greaterThan(expected);
-    });
-    def("toBeGreaterThanOrEqual", function(expected) {
-      return this.to.greaterThanOrEqual(expected);
-    });
-    def("toBeLessThan", function(expected) {
-      return this.to.lessThan(expected);
-    });
-    def("toBeLessThanOrEqual", function(expected) {
-      return this.to.lessThanOrEqual(expected);
-    });
-    def("toBeNaN", function() {
-      return this.be.NaN;
-    });
-    def("toBeUndefined", function() {
-      return this.be.undefined;
-    });
-    def("toBeNull", function() {
-      return this.be.null;
-    });
-    def("toBeDefined", function() {
-      return this.not.be.undefined;
-    });
-    def("toBeInstanceOf", function(obj) {
-      return this.instanceOf(obj);
-    });
-    def("toHaveLength", function(length) {
-      return this.have.length(length);
-    });
-    def("toHaveProperty", function(...args) {
-      return this.have.deep.nested.property(...args);
-    });
-    def("toBeCloseTo", function(number, numDigits = 2) {
-      utils.expectTypes(this, ["number"]);
-      return this.closeTo(number, numDigits);
-    });
-    function isSpy(putativeSpy) {
-      return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
-    }
-    const assertIsMock = (assertion) => {
-      if (!isSpy(assertion._obj))
-        throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+const JestChaiExpect = (chai, utils) => {
+  function def(name, fn) {
+    const addMethod = (n) => {
+      utils.addMethod(chai.Assertion.prototype, n, fn);
     };
-    const getSpy = (assertion) => {
-      assertIsMock(assertion);
-      return assertion._obj;
+    if (Array.isArray(name))
+      name.forEach((n) => addMethod(n));
+    else
+      addMethod(name);
+  }
+  const chaiEqual = chai.Assertion.prototype.equal;
+  def("chaiEqual", function(...args) {
+    return chaiEqual.apply(this, args);
+  });
+  utils.overwriteMethod(chai.Assertion.prototype, "equal", (_super) => {
+    return function(...args) {
+      const expected = args[0];
+      const actual = utils.flag(this, "object");
+      if (hasAsymmetric(expected)) {
+        this.assert(equals(actual, expected, void 0, true), "not match with #{this}", "should not match with #{this}", true);
+      } else {
+        _super.apply(this, args);
+      }
     };
-    def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
-      const spy = getSpy(this);
-      return this.assert(spy.callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number, spy.callCount);
-    });
-    def("toHaveBeenCalledOnce", function() {
-      const spy = getSpy(this);
-      return this.assert(spy.callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1, spy.callCount);
-    });
-    def(["toHaveBeenCalled", "toBeCalled"], function() {
-      const spy = getSpy(this);
-      return this.assert(spy.called, "expected spy to be called at least once", "expected spy to not be called at all", true, spy.called);
-    });
-    def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
-      const spy = getSpy(this);
-      const pass = spy.calls.some((callArg) => equals(callArg, args));
-      return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
-    });
-    const ordinalOf = (i) => {
-      const j = i % 10;
-      const k = i % 100;
-      if (j === 1 && k !== 11)
-        return `${i}st`;
-      if (j === 2 && k !== 12)
-        return `${i}nd`;
-      if (j === 3 && k !== 13)
-        return `${i}rd`;
-      return `${i}th`;
+  });
+  utils.overwriteMethod(chai.Assertion.prototype, "eql", (_super) => {
+    return function(...args) {
+      const expected = args[0];
+      const actual = utils.flag(this, "object");
+      if (hasAsymmetric(expected)) {
+        this.assert(equals(actual, expected), "not match with #{this}", "should not match with #{this}", true);
+      } else {
+        _super.apply(this, args);
+      }
     };
-    def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-      const spy = getSpy(this);
-      const nthCall = spy.calls[times - 1];
-      this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
-    });
-    def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-      const spy = getSpy(this);
-      const lastCall = spy.calls.at(-1);
-      this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
-    });
-    def(["toThrow", "toThrowError"], function(expected) {
-      const negate = utils.flag(this, "negate");
-      if (negate)
-        this.not.to.throw(expected);
-      else
-        this.to.throw(expected);
-    });
-    def(["toHaveReturned", "toReturn"], function() {
-      const spy = getSpy(this);
-      const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
-      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
-    });
-    def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-      const spy = getSpy(this);
-      const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
-      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
-    });
-    def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-      const spy = getSpy(this);
-      const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
-      this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
-    });
-    def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-      const spy = getSpy(this);
-      const lastResult = spy.returns.at(-1);
-      const pass = equals(lastResult, value);
-      this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
-    });
-    def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-      const spy = getSpy(this);
-      const isNot = utils.flag(this, "negate");
-      const [callType, callResult] = spy.results[nthCall - 1];
-      const ordinalCall = `${ordinalOf(nthCall)} call`;
-      if (!isNot && callType === "error")
-        chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-      const nthCallReturn = equals(callResult, value);
-      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
+  });
+  def("toEqual", function(expected) {
+    return this.eql(expected);
+  });
+  def("toStrictEqual", function(expected) {
+    return this.chaiEqual(expected);
+  });
+  def("toBe", function(expected) {
+    return this.chaiEqual(expected);
+  });
+  def("toMatchObject", function(expected) {
+    return this.containSubset(expected);
+  });
+  def("toMatch", function(expected) {
+    if (typeof expected === "string")
+      return this.include(expected);
+    else
+      return this.match(expected);
+  });
+  def("toContain", function(item) {
+    return this.contain(item);
+  });
+  def("toContainEqual", function(expected) {
+    const obj = utils.flag(this, "object");
+    const index = Array.from(obj).findIndex((item) => {
+      try {
+        chai.assert.deepEqual(item, expected);
+      } catch {
+        return false;
+      }
+      return true;
     });
+    this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
+  });
+  def("toBeTruthy", function() {
+    const obj = utils.flag(this, "object");
+    this.assert(Boolean(obj), "expected #{this} to be truthy", "expected #{this} to not be truthy", obj);
+  });
+  def("toBeFalsy", function() {
+    const obj = utils.flag(this, "object");
+    this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
+  });
+  def("toBeGreaterThan", function(expected) {
+    return this.to.greaterThan(expected);
+  });
+  def("toBeGreaterThanOrEqual", function(expected) {
+    return this.to.greaterThanOrEqual(expected);
+  });
+  def("toBeLessThan", function(expected) {
+    return this.to.lessThan(expected);
+  });
+  def("toBeLessThanOrEqual", function(expected) {
+    return this.to.lessThanOrEqual(expected);
+  });
+  def("toBeNaN", function() {
+    return this.be.NaN;
+  });
+  def("toBeUndefined", function() {
+    return this.be.undefined;
+  });
+  def("toBeNull", function() {
+    return this.be.null;
+  });
+  def("toBeDefined", function() {
+    return this.not.be.undefined;
+  });
+  def("toBeInstanceOf", function(obj) {
+    return this.instanceOf(obj);
+  });
+  def("toHaveLength", function(length) {
+    return this.have.length(length);
+  });
+  def("toHaveProperty", function(...args) {
+    return this.have.deep.nested.property(...args);
+  });
+  def("toBeCloseTo", function(number, numDigits = 2) {
+    utils.expectTypes(this, ["number"]);
+    return this.closeTo(number, numDigits);
+  });
+  function isSpy(putativeSpy) {
+    return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
+  }
+  const assertIsMock = (assertion) => {
+    if (!isSpy(assertion._obj))
+      throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+  };
+  const getSpy = (assertion) => {
+    assertIsMock(assertion);
+    return assertion._obj;
   };
+  def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
+    const spy = getSpy(this);
+    return this.assert(spy.callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number, spy.callCount);
+  });
+  def("toHaveBeenCalledOnce", function() {
+    const spy = getSpy(this);
+    return this.assert(spy.callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1, spy.callCount);
+  });
+  def(["toHaveBeenCalled", "toBeCalled"], function() {
+    const spy = getSpy(this);
+    return this.assert(spy.called, "expected spy to be called at least once", "expected spy to not be called at all", true, spy.called);
+  });
+  def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
+    const spy = getSpy(this);
+    const pass = spy.calls.some((callArg) => equals(callArg, args));
+    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
+  });
+  const ordinalOf = (i) => {
+    const j = i % 10;
+    const k = i % 100;
+    if (j === 1 && k !== 11)
+      return `${i}st`;
+    if (j === 2 && k !== 12)
+      return `${i}nd`;
+    if (j === 3 && k !== 13)
+      return `${i}rd`;
+    return `${i}th`;
+  };
+  def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
+    const spy = getSpy(this);
+    const nthCall = spy.calls[times - 1];
+    this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
+  });
+  def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
+    const spy = getSpy(this);
+    const lastCall = spy.calls.at(-1);
+    this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
+  });
+  def(["toThrow", "toThrowError"], function(expected) {
+    const negate = utils.flag(this, "negate");
+    if (negate)
+      this.not.to.throw(expected);
+    else
+      this.to.throw(expected);
+  });
+  def(["toHaveReturned", "toReturn"], function() {
+    const spy = getSpy(this);
+    const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
+    this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
+  });
+  def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
+    const spy = getSpy(this);
+    const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
+    this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
+  });
+  def(["toHaveReturnedWith", "toReturnWith"], function(value) {
+    const spy = getSpy(this);
+    const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
+    this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
+  });
+  def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
+    const spy = getSpy(this);
+    const lastResult = spy.returns.at(-1);
+    const pass = equals(lastResult, value);
+    this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
+  });
+  def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
+    const spy = getSpy(this);
+    const isNot = utils.flag(this, "negate");
+    const [callType, callResult] = spy.results[nthCall - 1];
+    const ordinalCall = `${ordinalOf(nthCall)} call`;
+    if (!isNot && callType === "error")
+      chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
+    const nthCallReturn = equals(callResult, value);
+    this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
+  });
+};
+
+class AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    this.sample = sample;
+    this.inverse = inverse;
+  }
+  getMatcherContext() {
+    return {
+      equals,
+      isNot: this.inverse,
+      utils: matcherUtils
+    };
+  }
 }
+class StringContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    if (!isA("String", sample))
+      throw new Error("Expected is not a string");
+    super(sample, inverse);
+  }
+  asymmetricMatch(other) {
+    const result = isA("String", other) && other.includes(this.sample);
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `String${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "string";
+  }
+}
+const JestAsymmetricMatchers = (chai, utils) => {
+  utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
+};
 
 let installed = false;
 async function setupChai() {
   if (installed)
     return;
-  chai.use(JestExtend());
-  chai.use(JestChaiExpect());
+  chai.use(JestExtend);
+  chai.use(JestChaiExpect);
   chai.use(Subset);
-  chai.use(SnapshotPlugin());
+  chai.use(SnapshotPlugin);
+  chai.use(JestAsymmetricMatchers);
   installed = true;
 }
 

package/dist/index.d.ts

@@ -572,8 +572,8 @@ interface JestMockCompat<TArgs extends any[] = any[], TReturns = any> {
     mockReturnThis(): this;
     mockReturnValue(obj: TReturns): this;
     mockReturnValueOnce(obj: TReturns): this;
-    mockResolvedValue(obj: Unpromisify<TReturns>): this;
-    mockResolvedValueOnce(obj: Unpromisify<TReturns>): this;
+    mockResolvedValue(obj: Awaited<TReturns>): this;
+    mockResolvedValueOnce(obj: Awaited<TReturns>): this;
     mockRejectedValue(obj: any): this;
     mockRejectedValueOnce(obj: any): this;
 }
@@ -581,7 +581,7 @@ interface JestMockCompatFn<TArgs extends any[] = any, TReturns = any> extends Je
     (...args: TArgs): TReturns;
 }
 declare function spyOn<T, K extends keyof T>(obj: T, method: K, accessType?: 'get' | 'set'): T[K] extends (...args: infer TArgs) => infer TReturnValue ? JestMockCompat<TArgs, TReturnValue> : JestMockCompat;
-declare type Unpromisify<T> = T extends Promise<infer R> ? R : never;
+declare type Awaited<T> = T extends Promise<infer R> ? R : never;
 declare function fn<TArgs extends any[] = any[], R = any>(): JestMockCompatFn<TArgs, R>;
 declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): JestMockCompatFn<TArgs, R>;
 
@@ -602,8 +602,10 @@ declare global {
     namespace Chai {
         interface ExpectStatic {
             extend(expects: MatchersObject): void;
+            stringContaining(expected: string): void;
         }
         interface Assertion {
+            chaiEqual(expected: any): void;
             toMatchSnapshot(message?: string): Assertion;
             toMatchInlineSnapshot(snapshot?: string, message?: string): Assertion;
             matchSnapshot(message?: string): Assertion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.89",
+  "version": "0.0.90",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -80,7 +80,8 @@
     "pkg-types": "^0.3.2",
     "pretty-format": "^27.4.2",
     "rollup": "^2.61.1",
-    "strip-ansi": "^7.0.1"
+    "strip-ansi": "^7.0.1",
+    "typescript": "^4.5.4"
   },
   "peerDependencies": {
     "c8": "*",
@@ -106,5 +107,6 @@
     "build": "rimraf dist && rollup -c",
     "dev": "rollup -c --watch src",
     "typecheck": "tsc --noEmit"
-  }
+  },
+  "readme": "# vitest\n\n[![NPM version](https://img.shields.io/npm/v/vitest?color=a1b858&label=)](https://www.npmjs.com/package/vitest)\n\nA blazing fast unit test framework powered by Vite.\n\n> **This project is currently in closed beta exclusively for Sponsors.**<br>\n> Become a Sponsor of [@patak-dev](https://github.com/sponsors/patak-dev) or [@antfu](https://github.com/sponsors/antfu) to access the source code and issues tracker.\n> Learn more at [vitest.dev](https://vitest.dev)\n"
 }