@vitest/expect 0.27.2 → 0.28.0

package/dist/index.d.ts

@@ -1,43 +1,21 @@
 import { use } from 'chai';
 import { stringify } from '@vitest/utils';
+export { setColors as setupColors } from '@vitest/utils';
 
 type Formatter = (input: string | number | null | undefined) => string;
 
-declare const EXPECTED_COLOR: Formatter;
-declare const RECEIVED_COLOR: Formatter;
-declare const INVERTED_COLOR: Formatter;
-declare const BOLD_WEIGHT: Formatter;
-declare const DIM_COLOR: Formatter;
-declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
-declare const printReceived: (object: unknown) => string;
-declare const printExpected: (value: unknown) => string;
+declare function getMatcherUtils(): {
+    EXPECTED_COLOR: Formatter;
+    RECEIVED_COLOR: Formatter;
+    INVERTED_COLOR: Formatter;
+    BOLD_WEIGHT: Formatter;
+    DIM_COLOR: Formatter;
+    matcherHint: (matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions) => string;
+    printReceived: (object: unknown) => string;
+    printExpected: (value: unknown) => string;
+};
 declare function diff(a: any, b: any, options?: DiffOptions): string;
 
-declare const jestMatcherUtils_stringify: typeof stringify;
-declare const jestMatcherUtils_EXPECTED_COLOR: typeof EXPECTED_COLOR;
-declare const jestMatcherUtils_RECEIVED_COLOR: typeof RECEIVED_COLOR;
-declare const jestMatcherUtils_INVERTED_COLOR: typeof INVERTED_COLOR;
-declare const jestMatcherUtils_BOLD_WEIGHT: typeof BOLD_WEIGHT;
-declare const jestMatcherUtils_DIM_COLOR: typeof DIM_COLOR;
-declare const jestMatcherUtils_matcherHint: typeof matcherHint;
-declare const jestMatcherUtils_printReceived: typeof printReceived;
-declare const jestMatcherUtils_printExpected: typeof printExpected;
-declare const jestMatcherUtils_diff: typeof diff;
-declare namespace jestMatcherUtils {
-  export {
-    jestMatcherUtils_stringify as stringify,
-    jestMatcherUtils_EXPECTED_COLOR as EXPECTED_COLOR,
-    jestMatcherUtils_RECEIVED_COLOR as RECEIVED_COLOR,
-    jestMatcherUtils_INVERTED_COLOR as INVERTED_COLOR,
-    jestMatcherUtils_BOLD_WEIGHT as BOLD_WEIGHT,
-    jestMatcherUtils_DIM_COLOR as DIM_COLOR,
-    jestMatcherUtils_matcherHint as matcherHint,
-    jestMatcherUtils_printReceived as printReceived,
-    jestMatcherUtils_printExpected as printExpected,
-    jestMatcherUtils_diff as diff,
-  };
-}
-
 type FirstFunctionArgument<T> = T extends (arg: infer A) => unknown ? A : never;
 type ChaiPlugin = FirstFunctionArgument<typeof use>;
 type Tester = (a: any, b: any) => boolean | undefined;
@@ -70,6 +48,7 @@ interface DiffOptions {
     omitAnnotationLines?: boolean;
     patchColor?: Formatter;
     compareKeys?: any;
+    showLegend?: boolean;
 }
 interface MatcherState {
     assertionCalls: number;
@@ -86,7 +65,9 @@ interface MatcherState {
     promise: string;
     suppressedErrors: Array<Error>;
     testPath?: string;
-    utils: typeof jestMatcherUtils & {
+    utils: ReturnType<typeof getMatcherUtils> & {
+        diff: typeof diff;
+        stringify: typeof stringify;
         iterableEquality: Tester;
         subsetEquality: Tester;
     };

package/dist/index.js

@@ -1,5 +1,6 @@
-import c from 'picocolors';
-import { stringify, unifiedDiff, isObject, assertTypes } from '@vitest/utils';
+import { getColors, stringify, isObject, assertTypes } from '@vitest/utils';
+export { setColors as setupColors } from '@vitest/utils';
+import { unifiedDiff } from '@vitest/utils/diff';
 import { AssertionError, util } from 'chai';
 import { isMockFunction } from '@vitest/spy';
 
@@ -29,75 +30,87 @@ const setState = (state, expect) => {
   map.set(expect, current);
 };
 
-const EXPECTED_COLOR = c.green;
-const RECEIVED_COLOR = c.red;
-const INVERTED_COLOR = c.inverse;
-const BOLD_WEIGHT = c.bold;
-const DIM_COLOR = c.dim;
-function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
-  const {
-    comment = "",
-    isDirectExpectCall = false,
-    isNot = false,
-    promise = "",
-    secondArgument = "",
-    expectedColor = EXPECTED_COLOR,
-    receivedColor = RECEIVED_COLOR,
-    secondArgumentColor = EXPECTED_COLOR
-  } = options;
-  let hint = "";
-  let dimString = "expect";
-  if (!isDirectExpectCall && received !== "") {
-    hint += DIM_COLOR(`${dimString}(`) + receivedColor(received);
-    dimString = ")";
-  }
-  if (promise !== "") {
-    hint += DIM_COLOR(`${dimString}.`) + promise;
-    dimString = "";
-  }
-  if (isNot) {
-    hint += `${DIM_COLOR(`${dimString}.`)}not`;
-    dimString = "";
-  }
-  if (matcherName.includes(".")) {
-    dimString += matcherName;
-  } else {
-    hint += DIM_COLOR(`${dimString}.`) + matcherName;
-    dimString = "";
-  }
-  if (expected === "") {
-    dimString += "()";
-  } else {
-    hint += DIM_COLOR(`${dimString}(`) + expectedColor(expected);
-    if (secondArgument)
-      hint += DIM_COLOR(", ") + secondArgumentColor(secondArgument);
-    dimString = ")";
+function getMatcherUtils() {
+  const c = () => getColors();
+  const EXPECTED_COLOR = c().green;
+  const RECEIVED_COLOR = c().red;
+  const INVERTED_COLOR = c().inverse;
+  const BOLD_WEIGHT = c().bold;
+  const DIM_COLOR = c().dim;
+  function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
+    const {
+      comment = "",
+      isDirectExpectCall = false,
+      isNot = false,
+      promise = "",
+      secondArgument = "",
+      expectedColor = EXPECTED_COLOR,
+      receivedColor = RECEIVED_COLOR,
+      secondArgumentColor = EXPECTED_COLOR
+    } = options;
+    let hint = "";
+    let dimString = "expect";
+    if (!isDirectExpectCall && received !== "") {
+      hint += DIM_COLOR(`${dimString}(`) + receivedColor(received);
+      dimString = ")";
+    }
+    if (promise !== "") {
+      hint += DIM_COLOR(`${dimString}.`) + promise;
+      dimString = "";
+    }
+    if (isNot) {
+      hint += `${DIM_COLOR(`${dimString}.`)}not`;
+      dimString = "";
+    }
+    if (matcherName.includes(".")) {
+      dimString += matcherName;
+    } else {
+      hint += DIM_COLOR(`${dimString}.`) + matcherName;
+      dimString = "";
+    }
+    if (expected === "") {
+      dimString += "()";
+    } else {
+      hint += DIM_COLOR(`${dimString}(`) + expectedColor(expected);
+      if (secondArgument)
+        hint += DIM_COLOR(", ") + secondArgumentColor(secondArgument);
+      dimString = ")";
+    }
+    if (comment !== "")
+      dimString += ` // ${comment}`;
+    if (dimString !== "")
+      hint += DIM_COLOR(dimString);
+    return hint;
   }
-  if (comment !== "")
-    dimString += ` // ${comment}`;
-  if (dimString !== "")
-    hint += DIM_COLOR(dimString);
-  return hint;
+  const SPACE_SYMBOL = "\xB7";
+  const replaceTrailingSpaces = (text) => text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+  const printReceived = (object) => RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
+  const printExpected = (value) => EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
+  return {
+    EXPECTED_COLOR,
+    RECEIVED_COLOR,
+    INVERTED_COLOR,
+    BOLD_WEIGHT,
+    DIM_COLOR,
+    matcherHint,
+    printReceived,
+    printExpected
+  };
 }
-const SPACE_SYMBOL = "\xB7";
-const replaceTrailingSpaces = (text) => text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
-const printReceived = (object) => RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
-const printExpected = (value) => EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
 function diff(a, b, options) {
-  return unifiedDiff(stringify(b), stringify(a));
+  const c = getColors();
+  return unifiedDiff(stringify(b), stringify(a), {
+    colorDim: c.dim,
+    colorSuccess: c.green,
+    colorError: c.red,
+    showLegend: options == null ? void 0 : options.showLegend
+  });
 }
 
 var matcherUtils = /*#__PURE__*/Object.freeze({
   __proto__: null,
   stringify: stringify,
-  EXPECTED_COLOR: EXPECTED_COLOR,
-  RECEIVED_COLOR: RECEIVED_COLOR,
-  INVERTED_COLOR: INVERTED_COLOR,
-  BOLD_WEIGHT: BOLD_WEIGHT,
-  DIM_COLOR: DIM_COLOR,
-  matcherHint: matcherHint,
-  printReceived: printReceived,
-  printExpected: printExpected,
+  getMatcherUtils: getMatcherUtils,
   diff: diff
 });
 
@@ -609,6 +622,7 @@ const JestAsymmetricMatchers = (chai, utils) => {
 };
 
 const JestChaiExpect = (chai, utils) => {
+  const c = () => getColors();
   function def(name, fn) {
     const addMethod = (n) => {
       utils.addMethod(chai.Assertion.prototype, n, fn);
@@ -913,44 +927,44 @@ const JestChaiExpect = (chai, utils) => {
     return `${i}th`;
   };
   const formatCalls = (spy, msg, actualCall) => {
-    msg += c.gray(`
+    msg += c().gray(`
 
 Received: 
 ${spy.mock.calls.map((callArg, i) => {
-      let methodCall = c.bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call:
+      let methodCall = c().bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call:
 
 `);
       if (actualCall)
-        methodCall += unifiedDiff(stringify(callArg), stringify(actualCall), { showLegend: false });
+        methodCall += diff(callArg, actualCall, { showLegend: false });
       else
         methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
       methodCall += "\n";
       return methodCall;
     }).join("\n")}`);
-    msg += c.gray(`
+    msg += c().gray(`
 
-Number of calls: ${c.bold(spy.mock.calls.length)}
+Number of calls: ${c().bold(spy.mock.calls.length)}
 `);
     return msg;
   };
   const formatReturns = (spy, msg, actualReturn) => {
-    msg += c.gray(`
+    msg += c().gray(`
 
 Received: 
 ${spy.mock.results.map((callReturn, i) => {
-      let methodCall = c.bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
+      let methodCall = c().bold(`    ${ordinalOf(i + 1)} ${spy.getMockName()} call return:
 
 `);
       if (actualReturn)
-        methodCall += unifiedDiff(stringify(callReturn.value), stringify(actualReturn), { showLegend: false });
+        methodCall += diff(callReturn.value, actualReturn, { showLegend: false });
       else
         methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
       methodCall += "\n";
       return methodCall;
     }).join("\n")}`);
-    msg += c.gray(`
+    msg += c().gray(`
 
-Number of calls: ${c.bold(spy.mock.calls.length)}
+Number of calls: ${c().bold(spy.mock.calls.length)}
 `);
     return msg;
   };
@@ -1236,13 +1250,14 @@ Number of calls: ${c.bold(spy.mock.calls.length)}
   });
 };
 
-const isAsyncFunction = (fn) => typeof fn === "function" && fn[Symbol.toStringTag] === "AsyncFunction";
 const getMatcherState = (assertion, expect) => {
   const obj = assertion._obj;
   const isNot = util.flag(assertion, "negate");
   const promise = util.flag(assertion, "promise") || "";
   const jestUtils = {
-    ...matcherUtils,
+    ...getMatcherUtils(),
+    diff,
+    stringify,
     iterableEquality,
     subsetEquality
   };
@@ -1270,21 +1285,21 @@ class JestExtendError extends Error {
 function JestExtendPlugin(expect, matchers) {
   return (c, utils) => {
     Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
-      function expectSyncWrapper(...args) {
-        const { state, isNot, obj } = getMatcherState(this, expect);
-        const { pass, message, actual, expected } = expectAssertion.call(state, obj, ...args);
-        if (pass && isNot || !pass && !isNot)
-          throw new JestExtendError(message(), actual, expected);
-      }
-      async function expectAsyncWrapper(...args) {
+      function expectWrapper(...args) {
         const { state, isNot, obj } = getMatcherState(this, expect);
-        const { pass, message, actual, expected } = await expectAssertion.call(state, obj, ...args);
+        const result = expectAssertion.call(state, obj, ...args);
+        if (result && typeof result === "object" && result instanceof Promise) {
+          return result.then(({ pass: pass2, message: message2, actual: actual2, expected: expected2 }) => {
+            if (pass2 && isNot || !pass2 && !isNot)
+              throw new JestExtendError(message2(), actual2, expected2);
+          });
+        }
+        const { pass, message, actual, expected } = result;
         if (pass && isNot || !pass && !isNot)
           throw new JestExtendError(message(), actual, expected);
       }
-      const expectAssertionWrapper = isAsyncFunction(expectAssertion) ? expectAsyncWrapper : expectSyncWrapper;
-      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, expectAssertionWrapper);
-      utils.addMethod(c.Assertion.prototype, expectAssertionName, expectAssertionWrapper);
+      utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, expectWrapper);
+      utils.addMethod(c.Assertion.prototype, expectAssertionName, expectWrapper);
       class CustomMatcher extends AsymmetricMatcher {
         constructor(inverse = false, ...sample) {
           super(sample, inverse);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/expect",
   "type": "module",
-  "version": "0.27.2",
+  "version": "0.28.0",
   "description": "Jest's expect matchers as a Chai plugin",
   "license": "MIT",
   "repository": {
@@ -25,9 +25,11 @@
   ],
   "dependencies": {
     "chai": "^4.3.7",
-    "picocolors": "^1.0.0",
-    "@vitest/utils": "0.27.2",
-    "@vitest/spy": "0.27.2"
+    "@vitest/utils": "0.28.0",
+    "@vitest/spy": "0.28.0"
+  },
+  "devDependencies": {
+    "picocolors": "^1.0.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",