@vitest/utils 0.32.1 → 0.32.3

package/dist/chunk-display.js

@@ -1,6 +1,5 @@
 import { format as format$1, plugins } from 'pretty-format';
-import util from 'util';
-import loupeImport from 'loupe';
+import { inspect as inspect$1 } from 'loupe';
 
 const {
   AsymmetricMatcher,
@@ -42,22 +41,87 @@ function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
   return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(maxDepth / 2)) : result;
 }
 
-const loupe = typeof loupeImport.default === "function" ? loupeImport.default : loupeImport;
+const formatRegExp = /%[sdjifoOcj%]/g;
 function format(...args) {
-  return util.format(...args);
-}
-function utilInspect(item, options) {
-  return util.inspect(item, options);
-}
-function loupeInspect(obj, options = {}) {
-  return loupe(obj, {
-    depth: 2,
-    truncate: options.truncateThreshold === 0 ? Infinity : options.truncateThreshold ?? 40
+  if (typeof args[0] !== "string") {
+    const objects = [];
+    for (let i2 = 0; i2 < args.length; i2++)
+      objects.push(inspect(args[i2], { depth: 0, colors: false, compact: 3 }));
+    return objects.join(" ");
+  }
+  const len = args.length;
+  let i = 1;
+  const template = args[0];
+  let str = String(template).replace(formatRegExp, (x) => {
+    if (x === "%%")
+      return "%";
+    if (i >= len)
+      return x;
+    switch (x) {
+      case "%s": {
+        const value = args[i++];
+        if (typeof value === "bigint")
+          return `${value.toString()}n`;
+        if (typeof value === "number" && value === 0 && 1 / value < 0)
+          return "-0";
+        if (typeof value === "object" && value !== null)
+          return inspect(value, { depth: 0, colors: false, compact: 3 });
+        return String(value);
+      }
+      case "%d": {
+        const value = args[i++];
+        if (typeof value === "bigint")
+          return `${value.toString()}n`;
+        return Number(value).toString();
+      }
+      case "%i": {
+        const value = args[i++];
+        if (typeof value === "bigint")
+          return `${value.toString()}n`;
+        return Number.parseInt(String(value)).toString();
+      }
+      case "%f":
+        return Number.parseFloat(String(args[i++])).toString();
+      case "%o":
+        return inspect(args[i++], { showHidden: true, showProxy: true });
+      case "%O":
+        return inspect(args[i++]);
+      case "%c": {
+        i++;
+        return "";
+      }
+      case "%j":
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (err) {
+          const m = err.message;
+          if (
+            // chromium
+            m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")
+          )
+            return "[Circular]";
+          throw err;
+        }
+      default:
+        return x;
+    }
   });
+  for (let x = args[i]; i < len; x = args[++i]) {
+    if (x === null || typeof x !== "object")
+      str += ` ${x}`;
+    else
+      str += ` ${inspect(x)}`;
+  }
+  return str;
+}
+function inspect(obj, options = {}) {
+  if (options.truncate === 0)
+    options.truncate = Number.POSITIVE_INFINITY;
+  return inspect$1(obj, options);
 }
 function objDisplay(obj, options = {}) {
-  const truncateThreshold = options.truncateThreshold ?? 40;
-  const str = loupeInspect(obj, options);
+  const truncateThreshold = options.truncate ?? 40;
+  const str = inspect(obj, options);
   const type = Object.prototype.toString.call(obj);
   if (truncateThreshold && str.length >= truncateThreshold) {
     if (type === "[object Function]") {
@@ -76,4 +140,4 @@ function objDisplay(obj, options = {}) {
   return str;
 }
 
-export { format as f, loupeInspect as l, objDisplay as o, stringify as s, utilInspect as u };
+export { format as f, inspect as i, objDisplay as o, stringify as s };

package/dist/diff.d.ts

@@ -109,6 +109,12 @@ declare function diffStringsRaw(a: string, b: string, cleanup: boolean): Array<D
 * LICENSE file in the root directory of this source tree.
 */
 
+/**
+ * @param a Expected value
+ * @param b Received value
+ * @param options Diff options
+ * @returns
+ */
 declare function diff(a: any, b: any, options?: DiffOptions): string | null;
 
 export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, DiffOptions, DiffOptionsColor, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified };

package/dist/diff.js

@@ -41,6 +41,8 @@ const DIFF_DELETE = -1;
 const DIFF_INSERT = 1;
 const DIFF_EQUAL = 0;
 class Diff {
+  0;
+  1;
   constructor(op, text) {
     this[0] = op;
     this[1] = text;
@@ -726,7 +728,8 @@ function diffLinesRaw(aLines, bLines) {
     for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1)
       diffs.push(new Diff(DIFF_EQUAL, bLines[bIndex]));
   };
-  diff$1.default.default(aLength, bLength, isCommon, foundSubsequence);
+  const diffSequences = diff$1.default.default || diff$1.default;
+  diffSequences(aLength, bLength, isCommon, foundSubsequence);
   for (; aIndex !== aLength; aIndex += 1)
     diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
   for (; bIndex !== bLength; bIndex += 1)
@@ -748,7 +751,8 @@ function diffStrings(a, b) {
     bIndex = bCommon + nCommon;
     diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
   };
-  diff$1.default.default(a.length, b.length, isCommon, foundSubsequence);
+  const diffSequences = diff$1.default.default || diff$1.default;
+  diffSequences(a.length, b.length, isCommon, foundSubsequence);
   if (aIndex !== a.length)
     diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));
   if (bIndex !== b.length)
@@ -763,6 +767,12 @@ function concatenateRelevantDiffs(op, diffs, changeColor) {
   );
 }
 class ChangeBuffer {
+  op;
+  line;
+  // incomplete line
+  lines;
+  // complete lines
+  changeColor;
   constructor(op, changeColor) {
     this.op = op;
     this.line = [];
@@ -816,6 +826,9 @@ class ChangeBuffer {
   }
 }
 class CommonBuffer {
+  deleteBuffer;
+  insertBuffer;
+  lines;
   constructor(deleteBuffer, insertBuffer) {
     this.deleteBuffer = deleteBuffer;
     this.insertBuffer = insertBuffer;

package/dist/error.js

@@ -4,7 +4,6 @@ import { getOwnProperties, getType } from './helpers.js';
 import 'pretty-format';
 import 'diff-sequences';
 import './chunk-colors.js';
-import 'util';
 import 'loupe';
 
 const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
@@ -81,7 +80,7 @@ function processError(err) {
   if (err.name)
     err.nameStr = String(err.name);
   if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0)
-    err.diff = diff(err.actual, err.expected);
+    err.diff = diff(err.expected, err.actual);
   if (typeof err.expected !== "string")
     err.expected = stringify(err.expected, 10);
   if (typeof err.actual !== "string")

package/dist/index.d.ts

@@ -2,7 +2,6 @@ export { assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnPro
 import { ParsedStack, ErrorWithDiff } from './types.js';
 export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, MergeInsertions, MutableArray, Nullable } from './types.js';
 import { PrettyFormatOptions } from 'pretty-format';
-import util from 'util';
 
 declare function stringify(object: unknown, maxDepth?: number, { maxLength, ...options }?: PrettyFormatOptions & {
     maxLength?: number;
@@ -22,11 +21,22 @@ declare function setSafeTimers(): void;
 declare function shuffle<T>(array: T[], seed?: number): T[];
 
 interface LoupeOptions {
-    truncateThreshold?: number;
+    showHidden?: boolean | undefined;
+    depth?: number | null | undefined;
+    colors?: boolean | undefined;
+    customInspect?: boolean | undefined;
+    showProxy?: boolean | undefined;
+    maxArrayLength?: number | null | undefined;
+    maxStringLength?: number | null | undefined;
+    breakLength?: number | undefined;
+    compact?: boolean | number | undefined;
+    sorted?: boolean | ((a: string, b: string) => number) | undefined;
+    getters?: 'get' | 'set' | boolean | undefined;
+    numericSeparator?: boolean | undefined;
+    truncate?: number;
 }
-declare function format(...args: any[]): string;
-declare function utilInspect(item: unknown, options?: util.InspectOptions): string;
-declare function loupeInspect(obj: unknown, options?: LoupeOptions): string;
+declare function format(...args: unknown[]): string;
+declare function inspect(obj: unknown, options?: LoupeOptions): any;
 declare function objDisplay(obj: unknown, options?: LoupeOptions): string;
 
 declare const SAFE_TIMERS_SYMBOL: unique symbol;
@@ -93,4 +103,4 @@ declare function parseErrorStacktrace(e: ErrorWithDiff, ignore?: (string | RegEx
 declare function positionToOffset(source: string, lineNumber: number, columnNumber: number): number;
 declare function offsetToLineNumber(source: string, offset: number): number;
 
-export { ErrorWithDiff, ParsedStack, SAFE_COLORS_SYMBOL, SAFE_TIMERS_SYMBOL, createColors, createSimpleStackTrace, format, getColors, getDefaultColors, getSafeTimers, lineSplitRE, loupeInspect, objDisplay, offsetToLineNumber, parseErrorStacktrace, parseSingleStack, parseStacktrace, positionToOffset, setSafeTimers, setupColors, shuffle, stringify, utilInspect };
+export { ErrorWithDiff, ParsedStack, SAFE_COLORS_SYMBOL, SAFE_TIMERS_SYMBOL, createColors, createSimpleStackTrace, format, getColors, getDefaultColors, getSafeTimers, inspect, lineSplitRE, objDisplay, offsetToLineNumber, parseErrorStacktrace, parseSingleStack, parseStacktrace, positionToOffset, setSafeTimers, setupColors, shuffle, stringify };

package/dist/index.js

@@ -1,10 +1,9 @@
 import { notNullish, isPrimitive } from './helpers.js';
 export { assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnProperties, getType, isObject, noop, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
-export { f as format, l as loupeInspect, o as objDisplay, s as stringify, u as utilInspect } from './chunk-display.js';
+export { f as format, i as inspect, o as objDisplay, s as stringify } from './chunk-display.js';
 import { S as SAFE_TIMERS_SYMBOL } from './chunk-colors.js';
 export { a as SAFE_COLORS_SYMBOL, c as createColors, b as getColors, g as getDefaultColors, s as setupColors } from './chunk-colors.js';
 import 'pretty-format';
-import 'util';
 import 'loupe';
 
 function getSafeTimers() {
@@ -219,8 +218,8 @@ function parseSingleStack(raw) {
   return {
     method,
     file,
-    line: parseInt(lineNumber),
-    column: parseInt(columnNumber)
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
   };
 }
 function parseStacktrace(stack, ignore = stackIgnorePatterns) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "0.32.1",
+  "version": "0.32.3",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -44,7 +44,7 @@
   "dependencies": {
     "diff-sequences": "^29.4.3",
     "loupe": "^2.3.6",
-    "pretty-format": "^27.5.1"
+    "pretty-format": "^29.5.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",