@depup/vitest 4.0.18-depup.0

package/dist/chunks/config.d.Cy95HiCx.d.ts

@@ -0,0 +1,210 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+import { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { SnapshotUpdateState, SnapshotEnvironment } from '@vitest/snapshot';
+import { SerializedDiffOptions } from '@vitest/utils/diff';
+
+/**
+ * Names of clock methods that may be faked by install.
+ */
+type FakeMethod =
+    | "setTimeout"
+    | "clearTimeout"
+    | "setImmediate"
+    | "clearImmediate"
+    | "setInterval"
+    | "clearInterval"
+    | "Date"
+    | "nextTick"
+    | "hrtime"
+    | "requestAnimationFrame"
+    | "cancelAnimationFrame"
+    | "requestIdleCallback"
+    | "cancelIdleCallback"
+    | "performance"
+    | "queueMicrotask";
+
+interface FakeTimerInstallOpts {
+    /**
+     * Installs fake timers with the specified unix epoch (default: 0)
+     */
+    now?: number | Date | undefined;
+
+    /**
+     * An array with names of global methods and APIs to fake.
+     * For instance, `vi.useFakeTimer({ toFake: ['setTimeout', 'performance'] })` will fake only `setTimeout()` and `performance.now()`
+     * @default everything available globally except `nextTick`
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll()
+     * @default 10000
+     */
+    loopLimit?: number | undefined;
+
+    /**
+     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
+     * 20ms for every 20ms change in the real system time) (default: false)
+     */
+    shouldAdvanceTime?: boolean | undefined;
+
+    /**
+     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
+     * in the real system time (default: 20)
+     */
+    advanceTimeDelta?: number | undefined;
+
+    /**
+     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers.
+     * @default true
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+
+    /**
+     * Don't throw error when asked to fake timers that are not present.
+     * @default false
+     */
+    ignoreMissingTimers?: boolean | undefined;
+}
+
+/**
+* Config that tests have access to.
+*/
+interface SerializedConfig {
+	name: string | undefined;
+	globals: boolean;
+	base: string | undefined;
+	snapshotEnvironment?: string;
+	disableConsoleIntercept: boolean | undefined;
+	runner: string | undefined;
+	isolate: boolean;
+	maxWorkers: number;
+	mode: "test" | "benchmark";
+	bail: number | undefined;
+	environmentOptions?: Record<string, any>;
+	root: string;
+	setupFiles: string[];
+	passWithNoTests: boolean;
+	testNamePattern: RegExp | undefined;
+	allowOnly: boolean;
+	testTimeout: number;
+	hookTimeout: number;
+	clearMocks: boolean;
+	mockReset: boolean;
+	restoreMocks: boolean;
+	unstubGlobals: boolean;
+	unstubEnvs: boolean;
+	fakeTimers: FakeTimerInstallOpts;
+	maxConcurrency: number;
+	defines: Record<string, any>;
+	expect: {
+		requireAssertions?: boolean;
+		poll?: {
+			timeout?: number;
+			interval?: number;
+		};
+	};
+	printConsoleTrace: boolean | undefined;
+	sequence: {
+		shuffle?: boolean;
+		concurrent?: boolean;
+		seed: number;
+		hooks: SequenceHooks;
+		setupFiles: SequenceSetupFiles;
+	};
+	deps: {
+		web: {
+			transformAssets?: boolean;
+			transformCss?: boolean;
+			transformGlobPattern?: RegExp | RegExp[];
+		};
+		optimizer: Record<string, {
+			enabled: boolean;
+		}>;
+		interopDefault: boolean | undefined;
+		moduleDirectories: string[] | undefined;
+	};
+	snapshotOptions: {
+		updateSnapshot: SnapshotUpdateState;
+		expand: boolean | undefined;
+		snapshotFormat: PrettyFormatOptions | undefined;
+		/**
+		* only exists for tests, not available in the main process
+		*/
+		snapshotEnvironment: SnapshotEnvironment;
+	};
+	pool: string;
+	snapshotSerializers: string[];
+	chaiConfig: {
+		includeStack?: boolean;
+		showDiff?: boolean;
+		truncateThreshold?: number;
+	} | undefined;
+	diff: string | SerializedDiffOptions | undefined;
+	retry: number;
+	includeTaskLocation: boolean | undefined;
+	inspect: boolean | string | undefined;
+	inspectBrk: boolean | string | undefined;
+	inspector: {
+		enabled?: boolean;
+		port?: number;
+		host?: string;
+		waitForDebugger?: boolean;
+	};
+	watch: boolean;
+	env: Record<string, any>;
+	browser: {
+		name: string;
+		headless: boolean;
+		isolate: boolean;
+		fileParallelism: boolean;
+		ui: boolean;
+		viewport: {
+			width: number;
+			height: number;
+		};
+		locators: {
+			testIdAttribute: string;
+		};
+		screenshotFailures: boolean;
+		providerOptions: {
+			actionTimeout?: number;
+		};
+		trace: BrowserTraceViewMode;
+		trackUnhandledErrors: boolean;
+	};
+	standalone: boolean;
+	logHeapUsage: boolean | undefined;
+	coverage: SerializedCoverageConfig;
+	benchmark: {
+		includeSamples: boolean;
+	} | undefined;
+	serializedDefines: string;
+	experimental: {
+		fsModuleCache: boolean;
+		printImportBreakdown: boolean | undefined;
+		openTelemetry: {
+			enabled: boolean;
+			sdkPath?: string;
+			browserSdkPath?: string;
+		} | undefined;
+	};
+}
+interface SerializedCoverageConfig {
+	provider: "istanbul" | "v8" | "custom" | undefined;
+	reportsDirectory: string;
+	htmlReporter: {
+		subdir: string | undefined;
+	} | undefined;
+	enabled: boolean;
+	customProviderModule: string | undefined;
+}
+type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookTimeout" | "clearMocks" | "mockReset" | "restoreMocks" | "fakeTimers" | "maxConcurrency" | "expect" | "printConsoleTrace"> & {
+	sequence?: {
+		hooks?: SequenceHooks;
+	};
+};
+type RuntimeOptions = Partial<RuntimeConfig>;
+type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
+
+export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, RuntimeConfig as b };

package/dist/chunks/console.Cf-YriPC.js

@@ -0,0 +1,146 @@
+import { Console } from 'node:console';
+import { relative } from 'node:path';
+import { Writable } from 'node:stream';
+import { getSafeTimers } from '@vitest/utils/timers';
+import c from 'tinyrainbow';
+import { R as RealDate } from './date.Bq6ZW5rf.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+
+const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
+function getTaskIdByStack(root) {
+	const stack = (/* @__PURE__ */ new Error("STACK_TRACE_ERROR")).stack?.split("\n");
+	if (!stack) return UNKNOWN_TEST_ID;
+	const index = stack.findIndex((line) => line.includes("at Console.value"));
+	const line = index === -1 ? null : stack[index + 2];
+	if (!line) return UNKNOWN_TEST_ID;
+	const filepath = line.match(/at\s(.*)\s?/)?.[1];
+	if (filepath) return relative(root, filepath);
+	return UNKNOWN_TEST_ID;
+}
+function createCustomConsole(defaultState) {
+	const stdoutBuffer = /* @__PURE__ */ new Map();
+	const stderrBuffer = /* @__PURE__ */ new Map();
+	const timers = /* @__PURE__ */ new Map();
+	const { queueMicrotask } = getSafeTimers();
+	function queueCancelableMicrotask(callback) {
+		let canceled = false;
+		queueMicrotask(() => {
+			if (!canceled) callback();
+		});
+		return () => {
+			canceled = true;
+		};
+	}
+	const state = () => defaultState || getWorkerState();
+	// group sync console.log calls with micro task
+	function schedule(taskId) {
+		const timer = timers.get(taskId);
+		const { stdoutTime, stderrTime } = timer;
+		timer.cancel?.();
+		timer.cancel = queueCancelableMicrotask(() => {
+			if (stderrTime < stdoutTime) {
+				sendStderr(taskId);
+				sendStdout(taskId);
+			} else {
+				sendStdout(taskId);
+				sendStderr(taskId);
+			}
+		});
+	}
+	function sendStdout(taskId) {
+		sendBuffer("stdout", taskId);
+	}
+	function sendStderr(taskId) {
+		sendBuffer("stderr", taskId);
+	}
+	function sendBuffer(type, taskId) {
+		const buffers = type === "stdout" ? stdoutBuffer : stderrBuffer;
+		const buffer = buffers.get(taskId);
+		if (!buffer) return;
+		if (state().config.printConsoleTrace) buffer.forEach(([buffer, origin]) => {
+			sendLog(type, taskId, String(buffer), buffer.length, origin);
+		});
+		else sendLog(type, taskId, buffer.map((i) => String(i[0])).join(""), buffer.length);
+		const timer = timers.get(taskId);
+		buffers.delete(taskId);
+		if (type === "stderr") timer.stderrTime = 0;
+		else timer.stdoutTime = 0;
+	}
+	function sendLog(type, taskId, content, size, origin) {
+		const timer = timers.get(taskId);
+		const time = type === "stderr" ? timer.stderrTime : timer.stdoutTime;
+		state().rpc.onUserConsoleLog({
+			type,
+			content: content || "<empty line>",
+			taskId,
+			time: time || RealDate.now(),
+			size,
+			origin
+		});
+	}
+	return new Console({
+		stdout: new Writable({ write(data, encoding, callback) {
+			const s = state();
+			const id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
+			let timer = timers.get(id);
+			if (timer) timer.stdoutTime = timer.stdoutTime || RealDate.now();
+			else {
+				timer = {
+					stdoutTime: RealDate.now(),
+					stderrTime: RealDate.now()
+				};
+				timers.set(id, timer);
+			}
+			let buffer = stdoutBuffer.get(id);
+			if (!buffer) {
+				buffer = [];
+				stdoutBuffer.set(id, buffer);
+			}
+			if (state().config.printConsoleTrace) {
+				const limit = Error.stackTraceLimit;
+				Error.stackTraceLimit = limit + 6;
+				const trace = (/* @__PURE__ */ new Error("STACK_TRACE")).stack?.split("\n").slice(7).join("\n");
+				Error.stackTraceLimit = limit;
+				buffer.push([data, trace]);
+			} else buffer.push([data, void 0]);
+			schedule(id);
+			callback();
+		} }),
+		stderr: new Writable({ write(data, encoding, callback) {
+			const s = state();
+			const id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
+			let timer = timers.get(id);
+			if (timer) timer.stderrTime = timer.stderrTime || RealDate.now();
+			else {
+				timer = {
+					stderrTime: RealDate.now(),
+					stdoutTime: RealDate.now()
+				};
+				timers.set(id, timer);
+			}
+			let buffer = stderrBuffer.get(id);
+			if (!buffer) {
+				buffer = [];
+				stderrBuffer.set(id, buffer);
+			}
+			if (state().config.printConsoleTrace) {
+				const limit = Error.stackTraceLimit;
+				Error.stackTraceLimit = limit + 6;
+				const stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack?.split("\n");
+				Error.stackTraceLimit = limit;
+				if (stack?.some((line) => line.includes("at Console.trace"))) buffer.push([data, void 0]);
+				else {
+					const trace = stack?.slice(7).join("\n");
+					Error.stackTraceLimit = limit;
+					buffer.push([data, trace]);
+				}
+			} else buffer.push([data, void 0]);
+			schedule(id);
+			callback();
+		} }),
+		colorMode: c.isColorSupported,
+		groupIndentation: 2
+	});
+}
+
+export { UNKNOWN_TEST_ID, createCustomConsole };

package/dist/chunks/constants.D_Q9UYh-.js

@@ -0,0 +1,36 @@
+// if changed, update also jsdocs and docs
+const defaultPort = 51204;
+const defaultBrowserPort = 63315;
+const defaultInspectPort = 9229;
+const API_PATH = "/__vitest_api__";
+const CONFIG_NAMES = ["vitest.config", "vite.config"];
+const CONFIG_EXTENSIONS = [
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+];
+const configFiles = CONFIG_NAMES.flatMap((name) => CONFIG_EXTENSIONS.map((ext) => name + ext));
+const globalApis = [
+	"suite",
+	"test",
+	"describe",
+	"it",
+	"chai",
+	"expect",
+	"assert",
+	"expectTypeOf",
+	"assertType",
+	"vitest",
+	"vi",
+	"beforeAll",
+	"afterAll",
+	"beforeEach",
+	"afterEach",
+	"onTestFinished",
+	"onTestFailed"
+];
+
+export { API_PATH as A, defaultPort as a, defaultInspectPort as b, configFiles as c, defaultBrowserPort as d, globalApis as g };