@vitest/utils 1.4.0 → 1.5.0

package/dist/chunk-display.js

@@ -127,7 +127,7 @@ function objDisplay(obj, options = {}) {
   if (options.truncate && str.length >= options.truncate) {
     if (type === "[object Function]") {
       const fn = obj;
-      return !fn.name || fn.name === "" ? "[Function]" : `[Function: ${fn.name}]`;
+      return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
     } else if (type === "[object Array]") {
       return `[ Array(${obj.length}) ]`;
     } else if (type === "[object Object]") {

package/dist/diff.d.ts

@@ -1,5 +1,5 @@
-import { D as DiffOptions } from './types-widbdqe5.js';
-export { a as DiffOptionsColor } from './types-widbdqe5.js';
+import { D as DiffOptions } from './types-9l4niLY8.js';
+export { a as DiffOptionsColor } from './types-9l4niLY8.js';
 import 'pretty-format';
 
 /**
@@ -63,7 +63,7 @@ declare class Diff {
 
 declare function diffLinesUnified(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): string;
 declare function diffLinesUnified2(aLinesDisplay: Array<string>, bLinesDisplay: Array<string>, aLinesCompare: Array<string>, bLinesCompare: Array<string>, options?: DiffOptions): string;
-declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>): Array<Diff>;
+declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): [Array<Diff>, boolean];
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -73,7 +73,7 @@ declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>): Arr
  */
 
 declare function diffStringsUnified(a: string, b: string, options?: DiffOptions): string;
-declare function diffStringsRaw(a: string, b: string, cleanup: boolean): Array<Diff>;
+declare function diffStringsRaw(a: string, b: string, cleanup: boolean, options?: DiffOptions): [Array<Diff>, boolean];
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.

package/dist/diff.js

@@ -555,6 +555,7 @@ function joinAlignedDiffsExpand(diffs, options) {
 
 const noColor = (string) => string;
 const DIFF_CONTEXT_DEFAULT = 5;
+const DIFF_TRUNCATE_THRESHOLD_DEFAULT = 0;
 function getDefaultOptions() {
   const c = getColors();
   return {
@@ -575,7 +576,10 @@ function getDefaultOptions() {
     expand: true,
     includeChangeCounts: false,
     omitAnnotationLines: false,
-    patchColor: c.yellow
+    patchColor: c.yellow,
+    truncateThreshold: DIFF_TRUNCATE_THRESHOLD_DEFAULT,
+    truncateAnnotation: "... Diff result is truncated",
+    truncateAnnotationColor: noColor
   };
 }
 function getCompareKeys(compareKeys) {
@@ -644,16 +648,21 @@ ${bColor(b)}
 
 `;
 }
-function printDiffLines(diffs, options) {
-  return printAnnotation(options, countChanges(diffs)) + (options.expand ? joinAlignedDiffsExpand(diffs, options) : joinAlignedDiffsNoExpand(diffs, options));
+function printDiffLines(diffs, truncated, options) {
+  return printAnnotation(options, countChanges(diffs)) + (options.expand ? joinAlignedDiffsExpand(diffs, options) : joinAlignedDiffsNoExpand(diffs, options)) + (truncated ? options.truncateAnnotationColor(`
+${options.truncateAnnotation}`) : "");
 }
 function diffLinesUnified(aLines, bLines, options) {
+  const normalizedOptions = normalizeDiffOptions(options);
+  const [diffs, truncated] = diffLinesRaw(
+    isEmptyString(aLines) ? [] : aLines,
+    isEmptyString(bLines) ? [] : bLines,
+    normalizedOptions
+  );
   return printDiffLines(
-    diffLinesRaw(
-      isEmptyString(aLines) ? [] : aLines,
-      isEmptyString(bLines) ? [] : bLines
-    ),
-    normalizeDiffOptions(options)
+    diffs,
+    truncated,
+    normalizedOptions
   );
 }
 function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options) {
@@ -668,7 +677,7 @@ function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCo
   if (aLinesDisplay.length !== aLinesCompare.length || bLinesDisplay.length !== bLinesCompare.length) {
     return diffLinesUnified(aLinesDisplay, bLinesDisplay, options);
   }
-  const diffs = diffLinesRaw(aLinesCompare, bLinesCompare);
+  const [diffs, truncated] = diffLinesRaw(aLinesCompare, bLinesCompare, options);
   let aIndex = 0;
   let bIndex = 0;
   diffs.forEach((diff2) => {
@@ -687,11 +696,14 @@ function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCo
         bIndex += 1;
     }
   });
-  return printDiffLines(diffs, normalizeDiffOptions(options));
+  return printDiffLines(diffs, truncated, normalizeDiffOptions(options));
 }
-function diffLinesRaw(aLines, bLines) {
-  const aLength = aLines.length;
-  const bLength = bLines.length;
+function diffLinesRaw(aLines, bLines, options) {
+  const truncate = (options == null ? void 0 : options.truncateThreshold) ?? false;
+  const truncateThreshold = Math.max(Math.floor((options == null ? void 0 : options.truncateThreshold) ?? 0), 0);
+  const aLength = truncate ? Math.min(aLines.length, truncateThreshold) : aLines.length;
+  const bLength = truncate ? Math.min(bLines.length, truncateThreshold) : bLines.length;
+  const truncated = aLength !== aLines.length || bLength !== bLines.length;
   const isCommon = (aIndex2, bIndex2) => aLines[aIndex2] === bLines[bIndex2];
   const diffs = [];
   let aIndex = 0;
@@ -710,10 +722,30 @@ function diffLinesRaw(aLines, bLines) {
     diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
   for (; bIndex !== bLength; bIndex += 1)
     diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
-  return diffs;
+  return [diffs, truncated];
 }
 
-function diffStrings(a, b) {
+function getNewLineSymbol(string) {
+  return string.includes("\r\n") ? "\r\n" : "\n";
+}
+function diffStrings(a, b, options) {
+  const truncate = (options == null ? void 0 : options.truncateThreshold) ?? false;
+  const truncateThreshold = Math.max(Math.floor((options == null ? void 0 : options.truncateThreshold) ?? 0), 0);
+  let aLength = a.length;
+  let bLength = b.length;
+  if (truncate) {
+    const aMultipleLines = a.includes("\n");
+    const bMultipleLines = b.includes("\n");
+    const aNewLineSymbol = getNewLineSymbol(a);
+    const bNewLineSymbol = getNewLineSymbol(b);
+    const _a = aMultipleLines ? `${a.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}
+` : a;
+    const _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
+` : b;
+    aLength = _a.length;
+    bLength = _b.length;
+  }
+  const truncated = aLength !== a.length || bLength !== b.length;
   const isCommon = (aIndex2, bIndex2) => a[aIndex2] === b[bIndex2];
   let aIndex = 0;
   let bIndex = 0;
@@ -728,12 +760,12 @@ function diffStrings(a, b) {
     diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
   };
   const diffSequences = diff$1.default.default || diff$1.default;
-  diffSequences(a.length, b.length, isCommon, foundSubsequence);
-  if (aIndex !== a.length)
+  diffSequences(aLength, bLength, isCommon, foundSubsequence);
+  if (aIndex !== aLength)
     diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));
-  if (bIndex !== b.length)
+  if (bIndex !== bLength)
     diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));
-  return diffs;
+  return [diffs, truncated];
 }
 
 function concatenateRelevantDiffs(op, diffs, changeColor) {
@@ -888,27 +920,28 @@ function hasCommonDiff(diffs, isMultiline) {
 function diffStringsUnified(a, b, options) {
   if (a !== b && a.length !== 0 && b.length !== 0) {
     const isMultiline = a.includes("\n") || b.includes("\n");
-    const diffs = diffStringsRaw(
+    const [diffs, truncated] = diffStringsRaw(
       isMultiline ? `${a}
 ` : a,
       isMultiline ? `${b}
 ` : b,
-      true
+      true,
       // cleanupSemantic
+      options
     );
     if (hasCommonDiff(diffs, isMultiline)) {
       const optionsNormalized = normalizeDiffOptions(options);
       const lines = getAlignedDiffs(diffs, optionsNormalized.changeColor);
-      return printDiffLines(lines, optionsNormalized);
+      return printDiffLines(lines, truncated, optionsNormalized);
     }
   }
   return diffLinesUnified(a.split("\n"), b.split("\n"), options);
 }
-function diffStringsRaw(a, b, cleanup) {
-  const diffs = diffStrings(a, b);
+function diffStringsRaw(a, b, cleanup, options) {
+  const [diffs, truncated] = diffStrings(a, b, options);
   if (cleanup)
     diff_cleanupSemantic(diffs);
-  return diffs;
+  return [diffs, truncated];
 }
 
 function getCommonMessage(message, options) {

package/dist/error.d.ts

@@ -1,4 +1,4 @@
-import { D as DiffOptions } from './types-widbdqe5.js';
+import { D as DiffOptions } from './types-9l4niLY8.js';
 import 'pretty-format';
 
 declare function serializeError(val: any, seen?: WeakMap<WeakKey, any>): any;

package/dist/helpers.js

@@ -74,7 +74,14 @@ function clone(val, seen, options = defaultCloneOptions) {
       if (!descriptor)
         continue;
       const cloned = clone(val[k2], seen, options);
-      if ("get" in descriptor) {
+      if (options.forceWritable) {
+        Object.defineProperty(out, k2, {
+          enumerable: descriptor.enumerable,
+          configurable: true,
+          writable: true,
+          value: cloned
+        });
+      } else if ("get" in descriptor) {
         Object.defineProperty(out, k2, {
           ...descriptor,
           get() {
@@ -84,7 +91,6 @@ function clone(val, seen, options = defaultCloneOptions) {
       } else {
         Object.defineProperty(out, k2, {
           ...descriptor,
-          writable: options.forceWritable ? true : descriptor.writable,
           value: cloned
         });
       }

package/dist/{types-widbdqe5.d.ts → types-9l4niLY8.d.ts}

@@ -27,6 +27,9 @@ interface DiffOptions {
     omitAnnotationLines?: boolean;
     patchColor?: DiffOptionsColor;
     compareKeys?: CompareKeys;
+    truncateThreshold?: number;
+    truncateAnnotation?: string;
+    truncateAnnotationColor?: DiffOptionsColor;
 }
 
 export type { DiffOptions as D, DiffOptionsColor as a };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",