@vitest/utils 4.0.0-beta.10 → 4.0.0-beta.12

package/dist/error.d.ts

@@ -1,8 +1,7 @@
 import { D as DiffOptions } from './types.d-BCElaP-c.js';
+export { serializeValue as serializeError } from './serialize.js';
 import '@vitest/pretty-format';
 
-declare function serializeValue(val: any, seen?: WeakMap<WeakKey, any>): any;
-
 declare function processError(_err: any, diffOptions?: DiffOptions, seen?: WeakSet<WeakKey>): any;
 
-export { processError, serializeValue as serializeError, serializeValue };
+export { processError };

package/dist/error.js

@@ -1,126 +1,12 @@
 import { printDiffOrStringify } from './diff.js';
-import { f as format, s as stringify } from './chunk-_commonjsHelpers.js';
+import { stringify } from './display.js';
+import { serializeValue } from './serialize.js';
 import '@vitest/pretty-format';
 import 'tinyrainbow';
-import './chunk-helpers.js';
-import 'loupe';
+import './helpers.js';
+import './constants.js';
+import './chunk-_commonjsHelpers.js';
 
-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>";
-}
-// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
-function serializeValue(val, seen = new WeakMap()) {
-	if (!val || typeof val === "string") {
-		return val;
-	}
-	if (val instanceof Error && "toJSON" in val && typeof val.toJSON === "function") {
-		const jsonValue = val.toJSON();
-		if (jsonValue && jsonValue !== val && typeof jsonValue === "object") {
-			if (typeof val.message === "string") {
-				safe(() => jsonValue.message ?? (jsonValue.message = val.message));
-			}
-			if (typeof val.stack === "string") {
-				safe(() => jsonValue.stack ?? (jsonValue.stack = val.stack));
-			}
-			if (typeof val.name === "string") {
-				safe(() => jsonValue.name ?? (jsonValue.name = val.name));
-			}
-			if (val.cause != null) {
-				safe(() => jsonValue.cause ?? (jsonValue.cause = serializeValue(val.cause, seen)));
-			}
-		}
-		return serializeValue(jsonValue, seen);
-	}
-	if (typeof val === "function") {
-		return `Function<${val.name || "anonymous"}>`;
-	}
-	if (typeof val === "symbol") {
-		return val.toString();
-	}
-	if (typeof val !== "object") {
-		return val;
-	}
-	if (typeof Buffer !== "undefined" && val instanceof Buffer) {
-		return `<Buffer(${val.length}) ...>`;
-	}
-	if (typeof Uint8Array !== "undefined" && val instanceof Uint8Array) {
-		return `<Uint8Array(${val.length}) ...>`;
-	}
-	// cannot serialize immutables as immutables
-	if (isImmutable(val)) {
-		return serializeValue(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 (typeof val.toJSON === "function") {
-		return serializeValue(val.toJSON(), seen);
-	}
-	if (seen.has(val)) {
-		return seen.get(val);
-	}
-	if (Array.isArray(val)) {
-		// eslint-disable-next-line unicorn/no-new-array -- we need to keep sparse arrays ([1,,3])
-		const clone = new Array(val.length);
-		seen.set(val, clone);
-		val.forEach((e, i) => {
-			try {
-				clone[i] = serializeValue(e, seen);
-			} catch (err) {
-				clone[i] = getUnserializableMessage(err);
-			}
-		});
-		return clone;
-	} else {
-		// Objects with `Error` constructors appear to cause problems during worker communication
-		// using `MessagePort`, so the serialized error object is being recreated as plain object.
-		const clone = 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] = serializeValue(val[key], seen);
-				} catch (err) {
-					// delete in case it has a setter from prototype that might throw
-					delete clone[key];
-					clone[key] = getUnserializableMessage(err);
-				}
-			});
-			obj = Object.getPrototypeOf(obj);
-		}
-		return clone;
-	}
-}
-function safe(fn) {
-	try {
-		return fn();
-	} catch {}
-}
-function normalizeErrorMessage(message) {
-	return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
-}
 function processError(_err, diffOptions, seen = new WeakSet()) {
 	if (!_err || typeof _err !== "object") {
 		return { message: String(_err) };
@@ -138,12 +24,6 @@ function processError(_err, diffOptions, seen = new WeakSet()) {
 	if ("actual" in err && typeof err.actual !== "string") {
 		err.actual = stringify(err.actual, 10);
 	}
-	// some Error implementations don't allow rewriting message
-	try {
-		if (typeof err.message === "string") {
-			err.message = normalizeErrorMessage(err.message);
-		}
-	} catch {}
 	// some Error implementations may not allow rewriting cause
 	// in most cases, the assignment will lead to "err.cause = err.cause"
 	try {
@@ -159,4 +39,4 @@ function processError(_err, diffOptions, seen = new WeakSet()) {
 	}
 }
 
-export { processError, serializeValue as serializeError, serializeValue };
+export { processError, serializeValue as serializeError };

package/dist/helpers.d.ts

@@ -1,5 +1,9 @@
 import { Nullable, Arrayable } from './types.js';
 
+declare function nanoid(size?: number): string;
+
+declare function shuffle<T>(array: T[], seed?: number): T[];
+
 interface CloneOptions {
 	forceWritable?: boolean;
 }
@@ -7,6 +11,7 @@ interface ErrorOptions {
 	message?: string;
 	stackTraceLimit?: number;
 }
+
 /**
 * Get original stacktrace without source map support the most performant way.
 * - Create only 1 stack frame.
@@ -31,7 +36,6 @@ declare function wrapId(id: string): string;
 declare function unwrapId(id: string): string;
 declare function withTrailingSlash(path: string): string;
 declare function isBareImport(id: string): boolean;
-declare function parseRegexp(input: string): RegExp;
 declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 declare function isObject(item: unknown): boolean;
 declare function getType(value: unknown): string;
@@ -65,5 +69,5 @@ declare function isNegativeNaN(val: number): boolean;
 */
 declare function deepMerge<T extends object = object>(target: T, ...sources: any[]): T;
 
-export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray, unwrapId, withTrailingSlash, wrapId };
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, shuffle, slash, toArray, unwrapId, withTrailingSlash, wrapId };
 export type { DeferPromise };

package/dist/helpers.js

@@ -1 +1,295 @@
-export { b as assertTypes, c as cleanUrl, d as clone, e as createDefer, f as createSimpleStackTrace, g as deepClone, h as deepMerge, j as getCallLastIndex, k as getOwnProperties, l as getType, m as isBareImport, o as isExternalUrl, p as isNegativeNaN, q as isObject, i as isPrimitive, r as noop, n as notNullish, s as objectAttr, t as parseRegexp, u as slash, v as toArray, w as unwrapId, x as withTrailingSlash, y as wrapId } from './chunk-helpers.js';
+import { VALID_ID_PREFIX, NULL_BYTE_PLACEHOLDER } from './constants.js';
+
+// port from nanoid
+// https://github.com/ai/nanoid
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) {
+		id += urlAlphabet[Math.random() * 64 | 0];
+	}
+	return id;
+}
+
+const RealDate = Date;
+function random(seed) {
+	const x = Math.sin(seed++) * 1e4;
+	return x - Math.floor(x);
+}
+function shuffle(array, seed = RealDate.now()) {
+	let length = array.length;
+	while (length) {
+		const index = Math.floor(random(seed) * length--);
+		const previous = array[length];
+		array[length] = array[index];
+		array[index] = previous;
+		++seed;
+	}
+	return array;
+}
+
+/**
+* Get original stacktrace without source map support the most performant way.
+* - Create only 1 stack frame.
+* - Rewrite prepareStackTrace to bypass "support-stack-trace" (usually takes ~250ms).
+*/
+function createSimpleStackTrace(options) {
+	const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+	const limit = Error.stackTraceLimit;
+	const prepareStackTrace = Error.prepareStackTrace;
+	Error.stackTraceLimit = stackTraceLimit;
+	Error.prepareStackTrace = (e) => e.stack;
+	const err = new Error(message);
+	const stackTrace = err.stack || "";
+	Error.prepareStackTrace = prepareStackTrace;
+	Error.stackTraceLimit = limit;
+	return stackTrace;
+}
+function notNullish(v) {
+	return v != null;
+}
+function assertTypes(value, name, types) {
+	const receivedType = typeof value;
+	const pass = types.includes(receivedType);
+	if (!pass) {
+		throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+	}
+}
+function isPrimitive(value) {
+	return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function slash(path) {
+	return path.replace(/\\/g, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+const externalRE = /^(?:[a-z]+:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+/**
+* Prepend `/@id/` and replace null byte so the id is URL-safe.
+* This is prepended to resolved ids that are not valid browser
+* import specifiers by the importAnalysis plugin.
+*/
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+function withTrailingSlash(path) {
+	if (path.at(-1) !== "/") {
+		return `${path}/`;
+	}
+	return path;
+}
+const bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
+function isBareImport(id) {
+	return bareImportRE.test(id);
+}
+function toArray(array) {
+	if (array === null || array === undefined) {
+		array = [];
+	}
+	if (Array.isArray(array)) {
+		return array;
+	}
+	return [array];
+}
+function isObject(item) {
+	return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function isFinalObj(obj) {
+	return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function getType(value) {
+	return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function collectOwnProperties(obj, collector) {
+	const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+	Object.getOwnPropertyNames(obj).forEach(collect);
+	Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function getOwnProperties(obj) {
+	const ownProps = new Set();
+	if (isFinalObj(obj)) {
+		return [];
+	}
+	collectOwnProperties(obj, ownProps);
+	return Array.from(ownProps);
+}
+const defaultCloneOptions = { forceWritable: false };
+function deepClone(val, options = defaultCloneOptions) {
+	const seen = new WeakMap();
+	return clone(val, seen, options);
+}
+function clone(val, seen, options = defaultCloneOptions) {
+	let k, out;
+	if (seen.has(val)) {
+		return seen.get(val);
+	}
+	if (Array.isArray(val)) {
+		out = Array.from({ length: k = val.length });
+		seen.set(val, out);
+		while (k--) {
+			out[k] = clone(val[k], seen, options);
+		}
+		return out;
+	}
+	if (Object.prototype.toString.call(val) === "[object Object]") {
+		out = Object.create(Object.getPrototypeOf(val));
+		seen.set(val, out);
+		// we don't need properties from prototype
+		const props = getOwnProperties(val);
+		for (const k of props) {
+			const descriptor = Object.getOwnPropertyDescriptor(val, k);
+			if (!descriptor) {
+				continue;
+			}
+			const cloned = clone(val[k], seen, options);
+			if (options.forceWritable) {
+				Object.defineProperty(out, k, {
+					enumerable: descriptor.enumerable,
+					configurable: true,
+					writable: true,
+					value: cloned
+				});
+			} else if ("get" in descriptor) {
+				Object.defineProperty(out, k, {
+					...descriptor,
+					get() {
+						return cloned;
+					}
+				});
+			} else {
+				Object.defineProperty(out, k, {
+					...descriptor,
+					value: cloned
+				});
+			}
+		}
+		return out;
+	}
+	return val;
+}
+function noop() {}
+function objectAttr(source, path, defaultValue = undefined) {
+	// a[3].b -> a.3.b
+	const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+	let result = source;
+	for (const p of paths) {
+		result = new Object(result)[p];
+		if (result === undefined) {
+			return defaultValue;
+		}
+	}
+	return result;
+}
+function createDefer() {
+	let resolve = null;
+	let reject = null;
+	const p = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	p.resolve = resolve;
+	p.reject = reject;
+	return p;
+}
+/**
+* If code starts with a function call, will return its last index, respecting arguments.
+* This will return 25 - last ending character of toMatch ")"
+* Also works with callbacks
+* ```
+* toMatch({ test: '123' });
+* toBeAliased('123')
+* ```
+*/
+function getCallLastIndex(code) {
+	let charIndex = -1;
+	let inString = null;
+	let startedBracers = 0;
+	let endedBracers = 0;
+	let beforeChar = null;
+	while (charIndex <= code.length) {
+		beforeChar = code[charIndex];
+		charIndex++;
+		const char = code[charIndex];
+		const isCharString = char === "\"" || char === "'" || char === "`";
+		if (isCharString && beforeChar !== "\\") {
+			if (inString === char) {
+				inString = null;
+			} else if (!inString) {
+				inString = char;
+			}
+		}
+		if (!inString) {
+			if (char === "(") {
+				startedBracers++;
+			}
+			if (char === ")") {
+				endedBracers++;
+			}
+		}
+		if (startedBracers && endedBracers && startedBracers === endedBracers) {
+			return charIndex;
+		}
+	}
+	return null;
+}
+function isNegativeNaN(val) {
+	if (!Number.isNaN(val)) {
+		return false;
+	}
+	const f64 = new Float64Array(1);
+	f64[0] = val;
+	const u32 = new Uint32Array(f64.buffer);
+	const isNegative = u32[1] >>> 31 === 1;
+	return isNegative;
+}
+function toString(v) {
+	return Object.prototype.toString.call(v);
+}
+function isPlainObject(val) {
+	return toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+}
+function isMergeableObject(item) {
+	return isPlainObject(item) && !Array.isArray(item);
+}
+/**
+* Deep merge :P
+*
+* Will merge objects only if they are plain
+*
+* Do not merge types - it is very expensive and usually it's better to case a type here
+*/
+function deepMerge(target, ...sources) {
+	if (!sources.length) {
+		return target;
+	}
+	const source = sources.shift();
+	if (source === undefined) {
+		return target;
+	}
+	if (isMergeableObject(target) && isMergeableObject(source)) {
+		Object.keys(source).forEach((key) => {
+			const _source = source;
+			if (isMergeableObject(_source[key])) {
+				if (!target[key]) {
+					target[key] = {};
+				}
+				deepMerge(target[key], _source[key]);
+			} else {
+				target[key] = _source[key];
+			}
+		});
+	}
+	return deepMerge(target, ...sources);
+}
+
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, shuffle, slash, toArray, unwrapId, withTrailingSlash, wrapId };

package/dist/highlight.d.ts

@@ -0,0 +1,9 @@
+import { Colors } from 'tinyrainbow';
+
+interface HighlightOptions {
+	jsx?: boolean;
+	colors?: Colors;
+}
+declare function highlight(code: string, options?: HighlightOptions): string;
+
+export { highlight };