@vitest/utils 2.0.4 → 2.0.5

package/dist/diff.d.ts

@@ -88,6 +88,13 @@ declare function diffStringsRaw(a: string, b: string, cleanup: boolean, options?
  * @param options Diff options
  * @returns {string | null} a string diff
  */
-declare function diff(a: any, b: any, options?: DiffOptions): string | null;
+declare function diff(a: any, b: any, options?: DiffOptions): string | undefined;
+declare function printDiffOrStringify(expected: unknown, received: unknown, options?: DiffOptions): string | undefined;
+declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<WeakKey>, expectedReplaced?: WeakSet<WeakKey>): {
+    replacedActual: any;
+    replacedExpected: any;
+};
+type PrintLabel = (string: string) => string;
+declare function getLabelPrinter(...strings: Array<string>): PrintLabel;
 
-export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, DiffOptions, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified };
+export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, DiffOptions, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };

package/dist/diff.js

@@ -1,5 +1,8 @@
 import { format, plugins } from '@vitest/pretty-format';
 import c from 'tinyrainbow';
+import { s as stringify } from './chunk-display.js';
+import { deepClone, getOwnProperties, getType as getType$1 } from './helpers.js';
+import 'loupe';
 
 function getType(value) {
   if (value === void 0) {
@@ -1851,10 +1854,10 @@ function diff(a, b, options) {
   let omitDifference = false;
   if (aType === "object" && typeof a.asymmetricMatch === "function") {
     if (a.$$typeof !== Symbol.for("jest.asymmetricMatcher")) {
-      return null;
+      return void 0;
     }
     if (typeof a.getExpectedType !== "function") {
-      return null;
+      return void 0;
     }
     expectedType = a.getExpectedType();
     omitDifference = expectedType === "string";
@@ -1873,7 +1876,7 @@ ${bDisplay}`;
 ${bDiff}`;
   }
   if (omitDifference) {
-    return null;
+    return void 0;
   }
   switch (aType) {
     case "string":
@@ -1949,5 +1952,98 @@ function getObjectsDifference(a, b, formatOptions, options) {
     );
   }
 }
+const MAX_DIFF_STRING_LENGTH = 2e4;
+function isAsymmetricMatcher(data) {
+  const type = getType$1(data);
+  return type === "Object" && typeof data.asymmetricMatch === "function";
+}
+function isReplaceable(obj1, obj2) {
+  const obj1Type = getType$1(obj1);
+  const obj2Type = getType$1(obj2);
+  return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
+}
+function printDiffOrStringify(expected, received, options) {
+  const { aAnnotation, bAnnotation } = normalizeDiffOptions(options);
+  if (typeof expected === "string" && typeof received === "string" && expected.length > 0 && received.length > 0 && expected.length <= MAX_DIFF_STRING_LENGTH && received.length <= MAX_DIFF_STRING_LENGTH && expected !== received) {
+    if (expected.includes("\n") || received.includes("\n")) {
+      return diffStringsUnified(received, expected, options);
+    }
+    const [diffs] = diffStringsRaw(received, expected, true);
+    const hasCommonDiff = diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
+    const printLabel = getLabelPrinter(aAnnotation, bAnnotation);
+    const expectedLine = printLabel(aAnnotation) + printExpected(
+      getCommonAndChangedSubstrings(diffs, DIFF_DELETE, hasCommonDiff)
+    );
+    const receivedLine = printLabel(bAnnotation) + printReceived(
+      getCommonAndChangedSubstrings(diffs, DIFF_INSERT, hasCommonDiff)
+    );
+    return `${expectedLine}
+${receivedLine}`;
+  }
+  const clonedExpected = deepClone(expected, { forceWritable: true });
+  const clonedReceived = deepClone(received, { forceWritable: true });
+  const { replacedExpected, replacedActual } = replaceAsymmetricMatcher(clonedExpected, clonedReceived);
+  const difference = diff(replacedExpected, replacedActual, options);
+  return difference;
+}
+function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
+  if (!isReplaceable(actual, expected)) {
+    return { replacedActual: actual, replacedExpected: expected };
+  }
+  if (actualReplaced.has(actual) || expectedReplaced.has(expected)) {
+    return { replacedActual: actual, replacedExpected: expected };
+  }
+  actualReplaced.add(actual);
+  expectedReplaced.add(expected);
+  getOwnProperties(expected).forEach((key) => {
+    const expectedValue = expected[key];
+    const actualValue = actual[key];
+    if (isAsymmetricMatcher(expectedValue)) {
+      if (expectedValue.asymmetricMatch(actualValue)) {
+        actual[key] = expectedValue;
+      }
+    } else if (isAsymmetricMatcher(actualValue)) {
+      if (actualValue.asymmetricMatch(expectedValue)) {
+        expected[key] = actualValue;
+      }
+    } else if (isReplaceable(actualValue, expectedValue)) {
+      const replaced = replaceAsymmetricMatcher(
+        actualValue,
+        expectedValue,
+        actualReplaced,
+        expectedReplaced
+      );
+      actual[key] = replaced.replacedActual;
+      expected[key] = replaced.replacedExpected;
+    }
+  });
+  return {
+    replacedActual: actual,
+    replacedExpected: expected
+  };
+}
+function getLabelPrinter(...strings) {
+  const maxLength = strings.reduce(
+    (max, string) => string.length > max ? string.length : max,
+    0
+  );
+  return (string) => `${string}: ${" ".repeat(maxLength - string.length)}`;
+}
+const SPACE_SYMBOL = "\xB7";
+function replaceTrailingSpaces(text) {
+  return text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+}
+function printReceived(object) {
+  return c.red(replaceTrailingSpaces(stringify(object)));
+}
+function printExpected(value) {
+  return c.green(replaceTrailingSpaces(stringify(value)));
+}
+function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff) {
+  return diffs.reduce(
+    (reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff ? c.inverse(diff2[1]) : diff2[1] : ""),
+    ""
+  );
+}
 
-export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified };
+export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };

package/dist/error.d.ts

@@ -1,11 +1,8 @@
 import { D as DiffOptions } from './types-Bxe-2Udy.js';
 import '@vitest/pretty-format';
 
-declare function serializeError(val: any, seen?: WeakMap<WeakKey, any>): any;
-declare function processError(err: any, diffOptions?: DiffOptions, seen?: WeakSet<WeakKey>): any;
-declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<WeakKey>, expectedReplaced?: WeakSet<WeakKey>): {
-    replacedActual: any;
-    replacedExpected: any;
-};
+declare function serializeValue(val: any, seen?: WeakMap<WeakKey, any>): any;
 
-export { processError, replaceAsymmetricMatcher, serializeError };
+declare function processError(_err: any, diffOptions?: DiffOptions, seen?: WeakSet<WeakKey>): any;
+
+export { processError, serializeValue as serializeError, serializeValue };

package/dist/error.js

@@ -1,8 +1,8 @@
-import { diff } from './diff.js';
+import { printDiffOrStringify } from './diff.js';
 import { f as format, s as stringify } from './chunk-display.js';
-import { deepClone, getOwnProperties, getType } from './helpers.js';
 import '@vitest/pretty-format';
 import 'tinyrainbow';
+import './helpers.js';
 import 'loupe';
 
 const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
@@ -20,7 +20,7 @@ function getUnserializableMessage(err) {
   }
   return "<unserializable>";
 }
-function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
+function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
   if (!val || typeof val === "string") {
     return val;
   }
@@ -34,7 +34,7 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     return val;
   }
   if (isImmutable(val)) {
-    return serializeError(val.toJSON(), seen);
+    return serializeValue(val.toJSON(), seen);
   }
   if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") {
     return "Promise";
@@ -46,7 +46,7 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     return `${val.toString()} ${format(val.sample)}`;
   }
   if (typeof val.toJSON === "function") {
-    return serializeError(val.toJSON(), seen);
+    return serializeValue(val.toJSON(), seen);
   }
   if (seen.has(val)) {
     return seen.get(val);
@@ -56,7 +56,7 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     seen.set(val, clone);
     val.forEach((e, i) => {
       try {
-        clone[i] = serializeError(e, seen);
+        clone[i] = serializeValue(e, seen);
       } catch (err) {
         clone[i] = getUnserializableMessage(err);
       }
@@ -72,7 +72,7 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
           return;
         }
         try {
-          clone[key] = serializeError(val[key], seen);
+          clone[key] = serializeValue(val[key], seen);
         } catch (err) {
           delete clone[key];
           clone[key] = getUnserializableMessage(err);
@@ -86,10 +86,11 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
 function normalizeErrorMessage(message) {
   return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
 }
-function processError(err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
-  if (!err || typeof err !== "object") {
-    return { message: err };
+function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!_err || typeof _err !== "object") {
+    return { message: String(_err) };
   }
+  const err = _err;
   if (err.stack) {
     err.stackStr = String(err.stack);
   }
@@ -97,13 +98,7 @@ function processError(err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
     err.nameStr = String(err.name);
   }
   if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
-    const clonedActual = deepClone(err.actual, { forceWritable: true });
-    const clonedExpected = deepClone(err.expected, { forceWritable: true });
-    const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(
-      clonedActual,
-      clonedExpected
-    );
-    err.diff = diff(replacedExpected, replacedActual, {
+    err.diff = printDiffOrStringify(err.actual, err.expected, {
       ...diffOptions,
       ...err.diffOptions
     });
@@ -128,9 +123,9 @@ function processError(err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
   } catch {
   }
   try {
-    return serializeError(err);
+    return serializeValue(err);
   } catch (e) {
-    return serializeError(
+    return serializeValue(
       new Error(
         `Failed to fully serialize error: ${e == null ? void 0 : e.message}
 Inner error message: ${err == null ? void 0 : err.message}`
@@ -138,50 +133,5 @@ Inner error message: ${err == null ? void 0 : err.message}`
     );
   }
 }
-function isAsymmetricMatcher(data) {
-  const type = getType(data);
-  return type === "Object" && typeof data.asymmetricMatch === "function";
-}
-function isReplaceable(obj1, obj2) {
-  const obj1Type = getType(obj1);
-  const obj2Type = getType(obj2);
-  return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
-}
-function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
-  if (!isReplaceable(actual, expected)) {
-    return { replacedActual: actual, replacedExpected: expected };
-  }
-  if (actualReplaced.has(actual) || expectedReplaced.has(expected)) {
-    return { replacedActual: actual, replacedExpected: expected };
-  }
-  actualReplaced.add(actual);
-  expectedReplaced.add(expected);
-  getOwnProperties(expected).forEach((key) => {
-    const expectedValue = expected[key];
-    const actualValue = actual[key];
-    if (isAsymmetricMatcher(expectedValue)) {
-      if (expectedValue.asymmetricMatch(actualValue)) {
-        actual[key] = expectedValue;
-      }
-    } else if (isAsymmetricMatcher(actualValue)) {
-      if (actualValue.asymmetricMatch(expectedValue)) {
-        expected[key] = actualValue;
-      }
-    } else if (isReplaceable(actualValue, expectedValue)) {
-      const replaced = replaceAsymmetricMatcher(
-        actualValue,
-        expectedValue,
-        actualReplaced,
-        expectedReplaced
-      );
-      actual[key] = replaced.replacedActual;
-      expected[key] = replaced.replacedExpected;
-    }
-  });
-  return {
-    replacedActual: actual,
-    replacedExpected: expected
-  };
-}
 
-export { processError, replaceAsymmetricMatcher, serializeError };
+export { processError, serializeValue as serializeError, serializeValue };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { DeferPromise, assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { Colors } from 'tinyrainbow';
-export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack } from './types.js';
+export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack, SerializedError, TestError } from './types.js';
 
 interface SafeTimers {
     nextTick: (cb: () => void) => void;

package/dist/source-map.d.ts

@@ -1,4 +1,4 @@
-import { ParsedStack, ErrorWithDiff } from './types.js';
+import { ErrorWithDiff, ParsedStack } from './types.js';
 
 type GeneratedColumn = number;
 type SourcesIndex = number;
@@ -105,7 +105,7 @@ interface StackTraceParserOptions {
     ignoreStackEntries?: (RegExp | string)[];
     getSourceMap?: (file: string) => unknown;
     getFileName?: (id: string) => string;
-    frameFilter?: (error: Error, frame: ParsedStack) => boolean | void;
+    frameFilter?: (error: ErrorWithDiff, frame: ParsedStack) => boolean | void;
 }
 declare function parseSingleFFOrSafariStack(raw: string): ParsedStack | null;
 declare function parseSingleStack(raw: string): ParsedStack | null;

package/dist/types.d.ts

@@ -20,8 +20,27 @@ interface ParsedStack {
     line: number;
     column: number;
 }
-interface ErrorWithDiff extends Error {
-    name: string;
+interface SerializedError {
+    message: string;
+    stack?: string;
+    name?: string;
+    stacks?: ParsedStack[];
+    cause?: SerializedError;
+    [key: string]: unknown;
+}
+interface TestError extends SerializedError {
+    cause?: TestError;
+    diff?: string;
+    actual?: string;
+    expected?: string;
+}
+/**
+ * @deprecated Use `TestError` instead
+ */
+interface ErrorWithDiff {
+    message: string;
+    name?: string;
+    cause?: unknown;
     nameStr?: string;
     stack?: string;
     stackStr?: string;
@@ -36,4 +55,4 @@ interface ErrorWithDiff extends Error {
     codeFrame?: string;
 }
 
-export type { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack };
+export type { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack, SerializedError, TestError };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -63,7 +63,7 @@
     "estree-walker": "^3.0.3",
     "loupe": "^3.1.1",
     "tinyrainbow": "^1.2.0",
-    "@vitest/pretty-format": "2.0.4"
+    "@vitest/pretty-format": "2.0.5"
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.25",