@vitest/utils 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/error.d.ts

@@ -1,9 +1,7 @@
 import { D as DiffOptions } from './types.d-BCElaP-c.js';
+export { serializeValue as serializeError } from './serialize.js';
 import '@vitest/pretty-format';
 
-// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
-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 './helpers.js';
-import 'loupe';
+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.
@@ -17,8 +22,20 @@ declare function notNullish<T>(v: T | null | undefined): v is NonNullable<T>;
 declare function assertTypes(value: unknown, name: string, types: string[]): void;
 declare function isPrimitive(value: unknown): boolean;
 declare function slash(path: string): string;
-// convert RegExp.toString to RegExp
-declare function parseRegexp(input: string): RegExp;
+declare function cleanUrl(url: string): string;
+declare const isExternalUrl: (url: string) => boolean;
+/**
+* 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.
+*/
+declare function wrapId(id: string): string;
+/**
+* Undo {@link wrapId}'s `/@id/` and null byte replacements.
+*/
+declare function unwrapId(id: string): string;
+declare function withTrailingSlash(path: string): string;
+declare function isBareImport(id: string): boolean;
 declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 declare function isObject(item: unknown): boolean;
 declare function getType(value: unknown): string;
@@ -28,8 +45,8 @@ declare function clone<T>(val: T, seen: WeakMap<any, any>, options?: CloneOption
 declare function noop(): void;
 declare function objectAttr(source: any, path: string, defaultValue?: undefined): any;
 type DeferPromise<T> = Promise<T> & {
-	resolve: (value: T | PromiseLike<T>) => void
-	reject: (reason?: any) => void
+	resolve: (value: T | PromiseLike<T>) => void;
+	reject: (reason?: any) => void;
 };
 declare function createDefer<T>(): DeferPromise<T>;
 /**
@@ -52,5 +69,5 @@ declare function isNegativeNaN(val: number): boolean;
 */
 declare function deepMerge<T extends object = object>(target: T, ...sources: any[]): T;
 
-export { assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };
+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,3 +1,34 @@
+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.
@@ -31,22 +62,35 @@ function isPrimitive(value) {
 function slash(path) {
 	return path.replace(/\\/g, "/");
 }
-// convert RegExp.toString to RegExp
-function parseRegexp(input) {
-	// Parse input
-	// eslint-disable-next-line regexp/no-misleading-capturing-group
-	const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
-	// match nothing
-	if (!m) {
-		return /$^/;
-	}
-	// Invalid flags
-	// eslint-disable-next-line regexp/optimal-quantifier-concatenation
-	if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3])) {
-		return new RegExp(input);
+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}/`;
 	}
-	// Create the regular expression
-	return new RegExp(m[2], m[3]);
+	return path;
+}
+const bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
+function isBareImport(id) {
+	return bareImportRE.test(id);
 }
 function toArray(array) {
 	if (array === null || array === undefined) {
@@ -248,4 +292,4 @@ function deepMerge(target, ...sources) {
 	return deepMerge(target, ...sources);
 }
 
-export { assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };
+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 };