@vitest/utils 0.31.4 → 0.32.0

package/dist/chunk-display.js

@@ -0,0 +1,79 @@
+import { format as format$1, plugins } from 'pretty-format';
+import util from 'util';
+import loupeImport from 'loupe';
+
+const {
+  AsymmetricMatcher,
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent
+} = plugins;
+const PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+  const MAX_LENGTH = maxLength ?? 1e4;
+  let result;
+  try {
+    result = format$1(object, {
+      maxDepth,
+      escapeString: false,
+      // min: true,
+      plugins: PLUGINS,
+      ...options
+    });
+  } catch {
+    result = format$1(object, {
+      callToJSON: false,
+      maxDepth,
+      escapeString: false,
+      // min: true,
+      plugins: PLUGINS,
+      ...options
+    });
+  }
+  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(maxDepth / 2)) : result;
+}
+
+const loupe = typeof loupeImport.default === "function" ? loupeImport.default : loupeImport;
+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
+  });
+}
+function objDisplay(obj, options = {}) {
+  const truncateThreshold = options.truncateThreshold ?? 40;
+  const str = loupeInspect(obj, options);
+  const type = Object.prototype.toString.call(obj);
+  if (truncateThreshold && str.length >= truncateThreshold) {
+    if (type === "[object Function]") {
+      const fn = obj;
+      return !fn.name || fn.name === "" ? "[Function]" : `[Function: ${fn.name}]`;
+    } else if (type === "[object Array]") {
+      return `[ Array(${obj.length}) ]`;
+    } else if (type === "[object Object]") {
+      const keys = Object.keys(obj);
+      const kstr = keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ");
+      return `{ Object (${kstr}) }`;
+    } else {
+      return str;
+    }
+  }
+  return str;
+}
+
+export { format as f, loupeInspect as l, objDisplay as o, stringify as s, utilInspect as u };

package/dist/error.d.ts

@@ -0,0 +1,10 @@
+import { DiffOptions } from './diff.js';
+
+declare function serializeError(val: any, seen?: WeakMap<object, any>): any;
+declare function processError(err: any, options?: DiffOptions): any;
+declare function replaceAsymmetricMatcher(actual: any, expected: any, actualReplaced?: WeakSet<object>, expectedReplaced?: WeakSet<object>): {
+    replacedActual: any;
+    replacedExpected: any;
+};
+
+export { processError, replaceAsymmetricMatcher, serializeError };

package/dist/error.js

@@ -0,0 +1,148 @@
+import { unifiedDiff } from './diff.js';
+import { f as format, s as stringify } from './chunk-display.js';
+import { deepClone, getOwnProperties, getType } from './helpers.js';
+import './chunk-colors.js';
+import 'concordance';
+import 'pretty-format';
+import 'util';
+import 'loupe';
+
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isImmutable(v) {
+  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+  if (err instanceof Error)
+    return `<unserializable>: ${err.message}`;
+  if (typeof err === "string")
+    return `<unserializable>: ${err}`;
+  return "<unserializable>";
+}
+function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
+  if (!val || typeof val === "string")
+    return val;
+  if (typeof val === "function")
+    return `Function<${val.name || "anonymous"}>`;
+  if (typeof val === "symbol")
+    return val.toString();
+  if (typeof val !== "object")
+    return val;
+  if (isImmutable(val))
+    return serializeError(val.toJSON(), seen);
+  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction")
+    return "Promise";
+  if (typeof Element !== "undefined" && val instanceof Element)
+    return val.tagName;
+  if (typeof val.asymmetricMatch === "function")
+    return `${val.toString()} ${format(val.sample)}`;
+  if (seen.has(val))
+    return seen.get(val);
+  if (Array.isArray(val)) {
+    const clone = new Array(val.length);
+    seen.set(val, clone);
+    val.forEach((e, i) => {
+      try {
+        clone[i] = serializeError(e, seen);
+      } catch (err) {
+        clone[i] = getUnserializableMessage(err);
+      }
+    });
+    return clone;
+  } else {
+    const clone = /* @__PURE__ */ Object.create(null);
+    seen.set(val, clone);
+    let obj = val;
+    while (obj && obj !== OBJECT_PROTO) {
+      Object.getOwnPropertyNames(obj).forEach((key) => {
+        if (key in clone)
+          return;
+        try {
+          clone[key] = serializeError(val[key], seen);
+        } catch (err) {
+          delete clone[key];
+          clone[key] = getUnserializableMessage(err);
+        }
+      });
+      obj = Object.getPrototypeOf(obj);
+    }
+    return clone;
+  }
+}
+function normalizeErrorMessage(message) {
+  return message.replace(/__vite_ssr_import_\d+__\./g, "");
+}
+function processError(err, options = {}) {
+  if (!err || typeof err !== "object")
+    return { message: err };
+  if (err.stack)
+    err.stackStr = String(err.stack);
+  if (err.name)
+    err.nameStr = String(err.name);
+  const clonedActual = deepClone(err.actual, { forceWritable: true });
+  const clonedExpected = deepClone(err.expected, { forceWritable: true });
+  const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(clonedActual, clonedExpected);
+  if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0)
+    err.diff = unifiedDiff(replacedActual, replacedExpected, options);
+  if (typeof err.expected !== "string")
+    err.expected = stringify(err.expected, 10);
+  if (typeof err.actual !== "string")
+    err.actual = stringify(err.actual, 10);
+  try {
+    if (typeof err.message === "string")
+      err.message = normalizeErrorMessage(err.message);
+    if (typeof err.cause === "object" && typeof err.cause.message === "string")
+      err.cause.message = normalizeErrorMessage(err.cause.message);
+  } catch {
+  }
+  try {
+    return serializeError(err);
+  } catch (e) {
+    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}
+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";
+}
+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 };

package/dist/index.js

@@ -1,50 +1,11 @@
 import { notNullish, isPrimitive } from './helpers.js';
 export { assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnProperties, getType, isObject, noop, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
-import { format as format$1, plugins } from 'pretty-format';
+export { f as format, l as loupeInspect, o as objDisplay, s as stringify, u as utilInspect } 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 util from 'util';
-import loupeImport from 'loupe';
-
-const {
-  AsymmetricMatcher,
-  DOMCollection,
-  DOMElement,
-  Immutable,
-  ReactElement,
-  ReactTestComponent
-} = plugins;
-const PLUGINS = [
-  ReactTestComponent,
-  ReactElement,
-  DOMElement,
-  DOMCollection,
-  Immutable,
-  AsymmetricMatcher
-];
-function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
-  const MAX_LENGTH = maxLength ?? 1e4;
-  let result;
-  try {
-    result = format$1(object, {
-      maxDepth,
-      escapeString: false,
-      // min: true,
-      plugins: PLUGINS,
-      ...options
-    });
-  } catch {
-    result = format$1(object, {
-      callToJSON: false,
-      maxDepth,
-      escapeString: false,
-      // min: true,
-      plugins: PLUGINS,
-      ...options
-    });
-  }
-  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(maxDepth / 2)) : result;
-}
+import 'pretty-format';
+import 'util';
+import 'loupe';
 
 function getSafeTimers() {
   const {
@@ -109,40 +70,6 @@ function shuffle(array, seed = RealDate.now()) {
   return array;
 }
 
-const loupe = typeof loupeImport.default === "function" ? loupeImport.default : loupeImport;
-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
-  });
-}
-function objDisplay(obj, options = {}) {
-  const truncateThreshold = options.truncateThreshold ?? 40;
-  const str = loupeInspect(obj, options);
-  const type = Object.prototype.toString.call(obj);
-  if (truncateThreshold && str.length >= truncateThreshold) {
-    if (type === "[object Function]") {
-      const fn = obj;
-      return !fn.name || fn.name === "" ? "[Function]" : `[Function: ${fn.name}]`;
-    } else if (type === "[object Array]") {
-      return `[ Array(${obj.length}) ]`;
-    } else if (type === "[object Object]") {
-      const keys = Object.keys(obj);
-      const kstr = keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ");
-      return `{ Object (${kstr}) }`;
-    } else {
-      return str;
-    }
-  }
-  return str;
-}
-
 function createSimpleStackTrace(options) {
   const { message = "error", stackTraceLimit = 1 } = options || {};
   const limit = Error.stackTraceLimit;
@@ -344,4 +271,4 @@ function offsetToLineNumber(source, offset) {
   return line + 1;
 }
 
-export { SAFE_TIMERS_SYMBOL, createSimpleStackTrace, format, getSafeTimers, isPrimitive, lineSplitRE, loupeInspect, notNullish, objDisplay, offsetToLineNumber, parseErrorStacktrace, parseSingleStack, parseStacktrace, positionToOffset, setSafeTimers, shuffle, stringify, utilInspect };
+export { SAFE_TIMERS_SYMBOL, createSimpleStackTrace, getSafeTimers, isPrimitive, lineSplitRE, notNullish, offsetToLineNumber, parseErrorStacktrace, parseSingleStack, parseStacktrace, positionToOffset, setSafeTimers, shuffle };

package/error.d.ts

@@ -0,0 +1 @@
+export * from './dist/error.js'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "0.31.4",
+  "version": "0.32.0",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -24,6 +24,10 @@
       "types": "./dist/diff.d.ts",
       "import": "./dist/diff.js"
     },
+    "./error": {
+      "types": "./dist/error.d.ts",
+      "import": "./dist/error.js"
+    },
     "./helpers": {
       "types": "./dist/helpers.d.ts",
       "import": "./dist/helpers.js"