@vitest/utils 4.1.5 → 4.1.6

package/dist/diff.d.ts

@@ -1,6 +1,6 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { D as DiffOptions } from './types.d-BCElaP-c.js';
 export { a as DiffOptionsColor, S as SerializedDiffOptions } from './types.d-BCElaP-c.js';
-import '@vitest/pretty-format';
 
 /**
 * Diff Match and Patch
@@ -75,14 +75,29 @@ declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>, opti
 declare function diffStringsUnified(a: string, b: string, options?: DiffOptions): string;
 declare function diffStringsRaw(a: string, b: string, cleanup: boolean, options?: DiffOptions): [Array<Diff>, boolean];
 
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+interface StringifiedMemory {
+	expected?: string;
+	actual?: string;
+}
+interface Memorize {
+	(pointer: "expected" | "actual", stringifiedValue: string): string;
+}
 /**
 * @param a Expected value
 * @param b Received value
 * @param options Diff options
 * @returns {string | null} a string diff
 */
-declare function diff(a: any, b: any, options?: DiffOptions): string | undefined;
-declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions): string | undefined;
+declare function diff(a: any, b: any, options?: DiffOptions, memorize?: Memorize): string | undefined;
+declare function getDefaultFormatOptions(options?: DiffOptions): PrettyFormatOptions;
+declare function printDiffOrStringify(received: unknown, expected: unknown, options?: DiffOptions, memory?: StringifiedMemory): string | undefined;
 declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<WeakKey>, expectedReplaced?: WeakSet<WeakKey>): {
 	replacedActual: any;
 	replacedExpected: any;
@@ -90,4 +105,5 @@ declare function replaceAsymmetricMatcher(actual: any, expected: any, actualRepl
 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, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };
+export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, DiffOptions, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getDefaultFormatOptions, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };
+export type { StringifiedMemory };

package/dist/diff.js

@@ -1968,6 +1968,7 @@ const FALLBACK_FORMAT_OPTIONS = {
 	maxDepth: 8,
 	plugins: PLUGINS
 };
+const DEFAULT_MEMORIZE = (_, v) => v;
 // Generate a string that will highlight the difference between two values
 // with green and red. (similar to how github does code diffing)
 /**
@@ -1976,7 +1977,7 @@ const FALLBACK_FORMAT_OPTIONS = {
 * @param options Diff options
 * @returns {string | null} a string diff
 */
-function diff(a, b, options) {
+function diff(a, b, options, memorize = DEFAULT_MEMORIZE) {
 	if (Object.is(a, b)) {
 		return "";
 	}
@@ -2010,8 +2011,8 @@ function diff(a, b, options) {
 		function truncate(s) {
 			return s.length <= MAX_LENGTH ? s : `${s.slice(0, MAX_LENGTH)}...`;
 		}
-		aDisplay = truncate(aDisplay);
-		bDisplay = truncate(bDisplay);
+		aDisplay = memorize("expected", truncate(aDisplay));
+		bDisplay = memorize("actual", truncate(bDisplay));
 		const aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)}\n${aDisplay}`;
 		const bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)}\n${bDisplay}`;
 		return `${aDiff}\n\n${bDiff}`;
@@ -2022,15 +2023,21 @@ function diff(a, b, options) {
 	switch (aType) {
 		case "string": return diffLinesUnified(a.split("\n"), b.split("\n"), options);
 		case "boolean":
-		case "number": return comparePrimitive(a, b, options);
-		case "map": return compareObjects(sortMap(a), sortMap(b), options);
-		case "set": return compareObjects(sortSet(a), sortSet(b), options);
-		default: return compareObjects(a, b, options);
+		case "number": return comparePrimitive(a, b, options, memorize);
+		case "map": return compareObjects(sortMap(a), sortMap(b), options, memorize);
+		case "set": return compareObjects(sortSet(a), sortSet(b), options, memorize);
+		default: return compareObjects(a, b, options, memorize);
 	}
 }
-function comparePrimitive(a, b, options) {
-	const aFormat = format(a, FORMAT_OPTIONS);
-	const bFormat = format(b, FORMAT_OPTIONS);
+function createMemorize(memory) {
+	return (pointer, stringifiedValue) => {
+		memory[pointer] = stringifiedValue;
+		return stringifiedValue;
+	};
+}
+function comparePrimitive(a, b, options, memorize = DEFAULT_MEMORIZE) {
+	const aFormat = memorize("expected", format(a, FORMAT_OPTIONS));
+	const bFormat = memorize("actual", format(b, FORMAT_OPTIONS));
 	return aFormat === bFormat ? "" : diffLinesUnified(aFormat.split("\n"), bFormat.split("\n"), options);
 }
 function sortMap(map) {
@@ -2039,12 +2046,12 @@ function sortMap(map) {
 function sortSet(set) {
 	return new Set(Array.from(set.values()).sort());
 }
-function compareObjects(a, b, options) {
+function compareObjects(a, b, options, memorize = DEFAULT_MEMORIZE) {
 	let difference;
 	let hasThrown = false;
 	try {
 		const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
-		difference = getObjectsDifference(a, b, formatOptions, options);
+		difference = getObjectsDifference(a, b, formatOptions, options, memorize);
 	} catch {
 		hasThrown = true;
 	}
@@ -2053,13 +2060,16 @@ function compareObjects(a, b, options) {
 	// without calling `toJSON`. It's also possible that toJSON might throw.
 	if (difference === undefined || difference === noDiffMessage) {
 		const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-		difference = getObjectsDifference(a, b, formatOptions, options);
+		difference = getObjectsDifference(a, b, formatOptions, options, memorize);
 		if (difference !== noDiffMessage && !hasThrown) {
 			difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}\n\n${difference}`;
 		}
 	}
 	return difference;
 }
+function getDefaultFormatOptions(options) {
+	return getFormatOptions(FORMAT_OPTIONS, options);
+}
 function getFormatOptions(formatOptions, options) {
 	const { compareKeys, printBasicPrototype, maxDepth } = normalizeDiffOptions(options);
 	return {
@@ -2069,7 +2079,7 @@ function getFormatOptions(formatOptions, options) {
 		maxDepth: maxDepth ?? formatOptions.maxDepth
 	};
 }
-function getObjectsDifference(a, b, formatOptions, options) {
+function getObjectsDifference(a, b, formatOptions, options, memorize = DEFAULT_MEMORIZE) {
 	const formatOptionsZeroIndent = {
 		...formatOptions,
 		indent: 0
@@ -2079,8 +2089,8 @@ function getObjectsDifference(a, b, formatOptions, options) {
 	if (aCompare === bCompare) {
 		return getCommonMessage(NO_DIFF_MESSAGE, options);
 	} else {
-		const aDisplay = format(a, formatOptions);
-		const bDisplay = format(b, formatOptions);
+		const aDisplay = memorize("expected", format(a, formatOptions));
+		const bDisplay = memorize("actual", format(b, formatOptions));
 		return diffLinesUnified2(aDisplay.split("\n"), bDisplay.split("\n"), aCompare.split("\n"), bCompare.split("\n"), options);
 	}
 }
@@ -2094,7 +2104,7 @@ function isReplaceable(obj1, obj2) {
 	const obj2Type = getType$1(obj2);
 	return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
 }
-function printDiffOrStringify(received, expected, options) {
+function printDiffOrStringify(received, expected, options, memory) {
 	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")) {
@@ -2111,7 +2121,8 @@ function printDiffOrStringify(received, expected, options) {
 	const clonedExpected = deepClone(expected, { forceWritable: true });
 	const clonedReceived = deepClone(received, { forceWritable: true });
 	const { replacedExpected, replacedActual } = replaceAsymmetricMatcher(clonedReceived, clonedExpected);
-	const difference = diff(replacedExpected, replacedActual, options);
+	const memorize = memory ? createMemorize(memory) : DEFAULT_MEMORIZE;
+	const difference = diff(replacedExpected, replacedActual, options, memorize);
 	return difference;
 	// }
 	// const printLabel = getLabelPrinter(aAnnotation, bAnnotation)
@@ -2198,4 +2209,4 @@ function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff) {
 	return diffs.reduce((reduced, diff) => reduced + (diff[0] === DIFF_EQUAL ? diff[1] : diff[0] === op ? hasCommonDiff ? c.inverse(diff[1]) : diff[1] : ""), "");
 }
 
-export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };
+export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getDefaultFormatOptions, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };

package/dist/error.js

@@ -1,8 +1,8 @@
-import { printDiffOrStringify } from './diff.js';
-import { stringify } from './display.js';
+import { format } from '@vitest/pretty-format';
+import { printDiffOrStringify, getDefaultFormatOptions } from './diff.js';
 import { serializeValue } from './serialize.js';
-import '@vitest/pretty-format';
 import 'tinyrainbow';
+import './display.js';
 import './helpers.js';
 import './constants.js';
 
@@ -12,16 +12,13 @@ function processError(_err, diffOptions, seen = new WeakSet()) {
 	}
 	const err = _err;
 	if (err.showDiff || err.showDiff === undefined && err.expected !== undefined && err.actual !== undefined) {
-		err.diff = printDiffOrStringify(err.actual, err.expected, {
+		const options = {
 			...diffOptions,
 			...err.diffOptions
-		});
-	}
-	if ("expected" in err && typeof err.expected !== "string") {
-		err.expected = stringify(err.expected, 10);
-	}
-	if ("actual" in err && typeof err.actual !== "string") {
-		err.actual = stringify(err.actual, 10);
+		};
+		err.diff = printDiffOrStringify(err.actual, err.expected, options, err);
+		err.expected = prettifyValue(err.expected, options);
+		err.actual = prettifyValue(err.actual, options);
 	}
 	// some Error implementations may not allow rewriting cause
 	// in most cases, the assignment will lead to "err.cause = err.cause"
@@ -37,5 +34,11 @@ function processError(_err, diffOptions, seen = new WeakSet()) {
 		return serializeValue(new Error(`Failed to fully serialize error: ${e?.message}\nInner error message: ${err?.message}`));
 	}
 }
+function prettifyValue(value, options) {
+	if (typeof value !== "string") {
+		return format(value, getDefaultFormatOptions(options));
+	}
+	return value;
+}
 
 export { processError, serializeValue as serializeError };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "4.1.5",
+  "version": "4.1.6",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -86,7 +86,7 @@
   "dependencies": {
     "convert-source-map": "^2.0.0",
     "tinyrainbow": "^3.1.0",
-    "@vitest/pretty-format": "4.1.5"
+    "@vitest/pretty-format": "4.1.6"
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "0.3.31",