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

package/dist/resolver.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import { j as join, d as dirname } from './chunk-pathe.M-eThtNZ.js';
+
+const packageCache = new Map();
+function findNearestPackageData(basedir) {
+	const originalBasedir = basedir;
+	while (basedir) {
+		var _tryStatSync;
+		const cached = getCachedData(packageCache, basedir, originalBasedir);
+		if (cached) {
+			return cached;
+		}
+		const pkgPath = join(basedir, "package.json");
+		if ((_tryStatSync = tryStatSync(pkgPath)) === null || _tryStatSync === void 0 ? void 0 : _tryStatSync.isFile()) {
+			const pkgData = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf8")));
+			if (packageCache) {
+				setCacheData(packageCache, pkgData, basedir, originalBasedir);
+			}
+			return pkgData;
+		}
+		const nextBasedir = dirname(basedir);
+		if (nextBasedir === basedir) {
+			break;
+		}
+		basedir = nextBasedir;
+	}
+	return {};
+}
+function stripBomTag(content) {
+	if (content.charCodeAt(0) === 65279) {
+		return content.slice(1);
+	}
+	return content;
+}
+function tryStatSync(file) {
+	try {
+		// The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+function getCachedData(cache, basedir, originalBasedir) {
+	const pkgData = cache.get(getFnpdCacheKey(basedir));
+	if (pkgData) {
+		traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+			cache.set(getFnpdCacheKey(dir), pkgData);
+		});
+		return pkgData;
+	}
+}
+function setCacheData(cache, data, basedir, originalBasedir) {
+	cache.set(getFnpdCacheKey(basedir), data);
+	traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		cache.set(getFnpdCacheKey(dir), data);
+	});
+}
+function getFnpdCacheKey(basedir) {
+	return `fnpd_${basedir}`;
+}
+/**
+* Traverse between `longerDir` (inclusive) and `shorterDir` (exclusive) and call `cb` for each dir.
+* @param longerDir Longer dir path, e.g. `/User/foo/bar/baz`
+* @param shorterDir Shorter dir path, e.g. `/User/foo`
+*/
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+	while (longerDir !== shorterDir) {
+		cb(longerDir);
+		longerDir = dirname(longerDir);
+	}
+}
+
+export { findNearestPackageData, getCachedData, setCacheData };

package/dist/serialize.d.ts

@@ -0,0 +1,3 @@
+declare function serializeValue(val: any, seen?: WeakMap<WeakKey, any>): any;
+
+export { serializeValue };

package/dist/serialize.js

@@ -0,0 +1,118 @@
+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 = normalizeErrorMessage(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.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);
+		}
+		if (val instanceof Error) {
+			safe(() => val.message = normalizeErrorMessage(val.message));
+		}
+		return clone;
+	}
+}
+function safe(fn) {
+	try {
+		return fn();
+	} catch {}
+}
+function normalizeErrorMessage(message) {
+	return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
+}
+
+export { serializeValue };

package/dist/source-map.d.ts

@@ -1,124 +1,11 @@
 import { TestError, ParsedStack } from './types.js';
 
-type GeneratedColumn = number;
-type SourcesIndex = number;
-type SourceLine = number;
-type SourceColumn = number;
-type NamesIndex = number;
-type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
-
-interface SourceMapV3 {
-    file?: string | null;
-    names: string[];
-    sourceRoot?: string;
-    sources: (string | null)[];
-    sourcesContent?: (string | null)[];
-    version: 3;
-    ignoreList?: number[];
-}
-interface EncodedSourceMap extends SourceMapV3 {
-    mappings: string;
-}
-interface DecodedSourceMap extends SourceMapV3 {
-    mappings: SourceMapSegment[][];
-}
 type OriginalMapping = {
     source: string | null;
     line: number;
     column: number;
     name: string | null;
 };
-type InvalidOriginalMapping = {
-    source: null;
-    line: null;
-    column: null;
-    name: null;
-};
-type GeneratedMapping = {
-    line: number;
-    column: number;
-};
-type InvalidGeneratedMapping = {
-    line: null;
-    column: null;
-};
-type Bias = typeof GREATEST_LOWER_BOUND | typeof LEAST_UPPER_BOUND;
-type XInput = {
-    x_google_ignoreList?: SourceMapV3['ignoreList'];
-};
-type EncodedSourceMapXInput = EncodedSourceMap & XInput;
-type DecodedSourceMapXInput = DecodedSourceMap & XInput;
-type SourceMapInput = string | EncodedSourceMapXInput | DecodedSourceMapXInput | TraceMap;
-type Needle = {
-    line: number;
-    column: number;
-    bias?: Bias;
-};
-type SourceNeedle = {
-    source: string;
-    line: number;
-    column: number;
-    bias?: Bias;
-};
-type EachMapping = {
-    generatedLine: number;
-    generatedColumn: number;
-    source: null;
-    originalLine: null;
-    originalColumn: null;
-    name: null;
-} | {
-    generatedLine: number;
-    generatedColumn: number;
-    source: string | null;
-    originalLine: number;
-    originalColumn: number;
-    name: string | null;
-};
-declare abstract class SourceMap {
-    version: SourceMapV3['version'];
-    file: SourceMapV3['file'];
-    names: SourceMapV3['names'];
-    sourceRoot: SourceMapV3['sourceRoot'];
-    sources: SourceMapV3['sources'];
-    sourcesContent: SourceMapV3['sourcesContent'];
-    resolvedSources: SourceMapV3['sources'];
-    ignoreList: SourceMapV3['ignoreList'];
-}
-
-declare const LEAST_UPPER_BOUND = -1;
-declare const GREATEST_LOWER_BOUND = 1;
-
-declare class TraceMap implements SourceMap {
-    version: SourceMapV3['version'];
-    file: SourceMapV3['file'];
-    names: SourceMapV3['names'];
-    sourceRoot: SourceMapV3['sourceRoot'];
-    sources: SourceMapV3['sources'];
-    sourcesContent: SourceMapV3['sourcesContent'];
-    ignoreList: SourceMapV3['ignoreList'];
-    resolvedSources: string[];
-    private _encoded;
-    private _decoded;
-    private _decodedMemo;
-    private _bySources;
-    private _bySourceMemos;
-    constructor(map: SourceMapInput, mapUrl?: string | null);
-}
-/**
- * A higher-level API to find the source/line/column associated with a generated line/column
- * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
- * `source-map` library.
- */
-declare function originalPositionFor(map: TraceMap, needle: Needle): OriginalMapping | InvalidOriginalMapping;
-/**
- * Finds the generated line/column position of the provided source/line/column source position.
- */
-declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): GeneratedMapping | InvalidGeneratedMapping;
-/**
- * Iterates each mapping in generated position order.
- */
-declare function eachMapping(map: TraceMap, cb: (mapping: EachMapping) => void): void;
 
 interface StackTraceParserOptions {
 	ignoreStackEntries?: (RegExp | string)[];
@@ -126,14 +13,43 @@ interface StackTraceParserOptions {
 	getUrlId?: (id: string) => string;
 	frameFilter?: (error: TestError, frame: ParsedStack) => boolean | void;
 }
+declare const stackIgnorePatterns: (string | RegExp)[];
+
 declare function parseSingleFFOrSafariStack(raw: string): ParsedStack | null;
 declare function parseSingleStack(raw: string): ParsedStack | null;
-// Based on https://github.com/stacktracejs/error-stack-parser
-// Credit to stacktracejs
 declare function parseSingleV8Stack(raw: string): ParsedStack | null;
 declare function createStackString(stacks: ParsedStack[]): string;
 declare function parseStacktrace(stack: string, options?: StackTraceParserOptions): ParsedStack[];
 declare function parseErrorStacktrace(e: TestError | Error, options?: StackTraceParserOptions): ParsedStack[];
+interface SourceMapLike {
+	version: number;
+	mappings?: string;
+	names?: string[];
+	sources?: string[];
+	sourcesContent?: string[];
+	sourceRoot?: string;
+}
+interface Needle {
+	line: number;
+	column: number;
+}
+declare class DecodedMap {
+	map: SourceMapLike;
+	_encoded: string;
+	_decoded: undefined | number[][][];
+	_decodedMemo: Stats;
+	url: string;
+	version: number;
+	names: string[];
+	resolvedSources: string[];
+	constructor(map: SourceMapLike, from: string);
+}
+interface Stats {
+	lastKey: number;
+	lastNeedle: number;
+	lastIndex: number;
+}
+declare function getOriginalPosition(map: DecodedMap, needle: Needle): OriginalMapping | null;
 
-export { TraceMap, createStackString, eachMapping, generatedPositionFor, originalPositionFor, parseErrorStacktrace, parseSingleFFOrSafariStack, parseSingleStack, parseSingleV8Stack, parseStacktrace };
-export type { EachMapping, SourceMapInput, StackTraceParserOptions };
+export { DecodedMap, createStackString, stackIgnorePatterns as defaultStackIgnorePatterns, getOriginalPosition, parseErrorStacktrace, parseSingleFFOrSafariStack, parseSingleStack, parseSingleV8Stack, parseStacktrace };
+export type { StackTraceParserOptions };