@vitest/utils 4.0.0-beta.8 → 4.0.0

package/dist/chunk-_commonjsHelpers.js

@@ -1,158 +1,5 @@
-import { plugins, format as format$1 } from '@vitest/pretty-format';
-import * as loupe 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,
-			plugins: PLUGINS,
-			...options
-		});
-	} catch {
-		result = format$1(object, {
-			callToJSON: false,
-			maxDepth,
-			escapeString: false,
-			plugins: PLUGINS,
-			...options
-		});
-	}
-	// Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
-	return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
-		maxLength,
-		...options
-	}) : result;
-}
-const formatRegExp = /%[sdjifoOc%]/g;
-function format(...args) {
-	if (typeof args[0] !== "string") {
-		const objects = [];
-		for (let i = 0; i < args.length; i++) {
-			objects.push(inspect(args[i], {
-				depth: 0,
-				colors: false
-			}));
-		}
-		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) {
-					if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
-						return value.toString();
-					}
-					return inspect(value, {
-						depth: 0,
-						colors: false
-					});
-				}
-				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 (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 loupe.inspect(obj, options);
-}
-function objDisplay(obj, options = {}) {
-	if (typeof options.truncate === "undefined") {
-		options.truncate = 40;
-	}
-	const str = inspect(obj, options);
-	const type = Object.prototype.toString.call(obj);
-	if (options.truncate && str.length >= options.truncate) {
-		if (type === "[object Function]") {
-			const fn = obj;
-			return !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 getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-export { format as f, getDefaultExportFromCjs as g, inspect as i, objDisplay as o, stringify as s };
+export { getDefaultExportFromCjs as g };

package/dist/constants.d.ts

@@ -0,0 +1,21 @@
+declare const KNOWN_ASSET_TYPES: string[];
+declare const KNOWN_ASSET_RE: RegExp;
+declare const CSS_LANGS_RE: RegExp;
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+declare const VALID_ID_PREFIX = "/@id/";
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+declare const NULL_BYTE_PLACEHOLDER = "__x00__";
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES, NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };

package/dist/constants.js

@@ -0,0 +1,49 @@
+// TODO: this is all copy pasted from Vite - can they expose a module that exports only constants?
+const KNOWN_ASSET_TYPES = [
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+];
+const KNOWN_ASSET_RE = new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
+const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+/**
+* Prefix for resolved Ids that are not valid browser import specifiers
+*/
+const VALID_ID_PREFIX = `/@id/`;
+/**
+* Plugins that use 'virtual modules' (e.g. for helper functions), prefix the
+* module ID with `\0`, a convention from the rollup ecosystem.
+* This prevents other plugins from trying to process the id (like node resolution),
+* and core features like sourcemaps can use this info to differentiate between
+* virtual modules and regular files.
+* `\0` is not a permitted char in import URLs so we have to replace them during
+* import analysis. The id will be decoded back before entering the plugins pipeline.
+* These encoded virtual ids are also prefixed by the VALID_ID_PREFIX, so virtual
+* modules in the browser end up encoded as `/@id/__x00__{id}`
+*/
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES, NULL_BYTE_PLACEHOLDER, VALID_ID_PREFIX };

package/dist/diff.d.ts

@@ -61,13 +61,8 @@ declare class Diff {
 * LICENSE file in the root directory of this source tree.
 */
 
-// Compare two arrays of strings line-by-line. Format as comparison lines.
 declare function diffLinesUnified(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): string;
-// Given two pairs of arrays of strings:
-// Compare the pair of comparison arrays line-by-line.
-// Format the corresponding lines in the pair of displayable arrays.
 declare function diffLinesUnified2(aLinesDisplay: Array<string>, bLinesDisplay: Array<string>, aLinesCompare: Array<string>, bLinesCompare: Array<string>, options?: DiffOptions): string;
-// Compare two arrays of strings line-by-line.
 declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>, options?: DiffOptions): [Array<Diff>, boolean];
 
 /**
@@ -77,15 +72,9 @@ declare function diffLinesRaw(aLines: Array<string>, bLines: Array<string>, opti
 * LICENSE file in the root directory of this source tree.
 */
 
-// Compare two strings character-by-character.
-// Format as comparison lines in which changed substrings have inverse colors.
 declare function diffStringsUnified(a: string, b: string, options?: DiffOptions): string;
-// Compare two strings character-by-character.
-// Optionally clean up small common substrings, also known as chaff.
 declare function diffStringsRaw(a: string, b: string, cleanup: boolean, options?: DiffOptions): [Array<Diff>, boolean];
 
-// Generate a string that will highlight the difference between two values
-// with green and red. (similar to how github does code diffing)
 /**
 * @param a Expected value
 * @param b Received value

package/dist/diff.js

@@ -1,8 +1,9 @@
 import { plugins, format } from '@vitest/pretty-format';
 import c from 'tinyrainbow';
-import { g as getDefaultExportFromCjs, s as stringify } from './chunk-_commonjsHelpers.js';
-import { g as deepClone, k as getOwnProperties, l as getType$1 } from './chunk-helpers.js';
-import 'loupe';
+import { stringify } from './display.js';
+import { deepClone, getOwnProperties, getType as getType$1 } from './helpers.js';
+import { g as getDefaultExportFromCjs } from './chunk-_commonjsHelpers.js';
+import './constants.js';
 
 /**
 * Diff Match and Patch
@@ -332,6 +333,7 @@ function diff_cleanupSemanticLossless(diffs) {
 * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
 */
 function diff_cleanupMerge(diffs) {
+	var _diffs$at;
 	// Add a dummy entry at the end.
 	diffs.push(new Diff(DIFF_EQUAL, ""));
 	let pointer = 0;
@@ -402,7 +404,7 @@ function diff_cleanupMerge(diffs) {
 				break;
 		}
 	}
-	if (diffs[diffs.length - 1][1] === "") {
+	if (((_diffs$at = diffs.at(-1)) === null || _diffs$at === void 0 ? void 0 : _diffs$at[1]) === "") {
 		diffs.pop();
 	}
 	// Second pass: look for single edits surrounded on both sides by equalities
@@ -1300,7 +1302,7 @@ function requireBuild () {
 	return build;
 }
 
-var buildExports = requireBuild();
+var buildExports = /*@__PURE__*/ requireBuild();
 var diffSequences = /*@__PURE__*/getDefaultExportFromCjs(buildExports);
 
 function formatTrailingSpaces(line, trailingSpaceFormatter) {

package/dist/display.d.ts

@@ -0,0 +1,28 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+
+type Inspect = (value: unknown, options: Options) => string;
+interface Options {
+	showHidden: boolean;
+	depth: number;
+	colors: boolean;
+	customInspect: boolean;
+	showProxy: boolean;
+	maxArrayLength: number;
+	breakLength: number;
+	truncate: number;
+	seen: unknown[];
+	inspect: Inspect;
+	stylize: (value: string, styleType: string) => string;
+}
+type LoupeOptions = Partial<Options>;
+interface StringifyOptions extends PrettyFormatOptions {
+	maxLength?: number;
+}
+declare function stringify(object: unknown, maxDepth?: number, { maxLength,...options }?: StringifyOptions): string;
+declare const formatRegExp: RegExp;
+declare function format(...args: unknown[]): string;
+declare function inspect(obj: unknown, options?: LoupeOptions): string;
+declare function objDisplay(obj: unknown, options?: LoupeOptions): string;
+
+export { format, formatRegExp, inspect, objDisplay, stringify };
+export type { LoupeOptions, StringifyOptions };