@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/utils/timers.js

@@ -0,0 +1,49 @@
+const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+  const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+  const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || {};
+  return {
+    nextTick: safeNextTick,
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate,
+    queueMicrotask: safeQueueMicrotask
+  };
+}
+function setSafeTimers() {
+  const { setTimeout: safeSetTimeout, setInterval: safeSetInterval, clearInterval: safeClearInterval, clearTimeout: safeClearTimeout, setImmediate: safeSetImmediate, clearImmediate: safeClearImmediate, queueMicrotask: safeQueueMicrotask } = globalThis;
+  const { nextTick: safeNextTick } = globalThis.process || {};
+  const timers = {
+    nextTick: safeNextTick,
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate,
+    queueMicrotask: safeQueueMicrotask
+  };
+  globalThis[SAFE_TIMERS_SYMBOL] = timers;
+}
+/**
+* Returns a promise that resolves after the specified duration.
+*
+* @param timeout - Delay in milliseconds
+* @param scheduler - Timer function to use, defaults to `setTimeout`. Useful for mocked timers.
+*
+* @example
+* await delay(100)
+*
+* @example
+* // With mocked timers
+* const { setTimeout } = getSafeTimers()
+* await delay(100, setTimeout)
+*/
+function delay(timeout, scheduler = setTimeout) {
+  return new Promise((resolve) => scheduler(resolve, timeout));
+}
+
+export { delay, getSafeTimers, setSafeTimers };

package/dist/@vitest/utils/types.d-BCElaP-c.d.ts

@@ -0,0 +1,53 @@
+import { CompareKeys } from '../pretty-format/index.js';
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+type DiffOptionsColor = (arg: string) => string;
+interface DiffOptions {
+	aAnnotation?: string;
+	aColor?: DiffOptionsColor;
+	aIndicator?: string;
+	bAnnotation?: string;
+	bColor?: DiffOptionsColor;
+	bIndicator?: string;
+	changeColor?: DiffOptionsColor;
+	changeLineTrailingSpaceColor?: DiffOptionsColor;
+	commonColor?: DiffOptionsColor;
+	commonIndicator?: string;
+	commonLineTrailingSpaceColor?: DiffOptionsColor;
+	contextLines?: number;
+	emptyFirstOrLastLinePlaceholder?: string;
+	expand?: boolean;
+	includeChangeCounts?: boolean;
+	omitAnnotationLines?: boolean;
+	patchColor?: DiffOptionsColor;
+	printBasicPrototype?: boolean;
+	maxDepth?: number;
+	compareKeys?: CompareKeys;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+	truncateAnnotationColor?: DiffOptionsColor;
+}
+interface SerializedDiffOptions {
+	aAnnotation?: string;
+	aIndicator?: string;
+	bAnnotation?: string;
+	bIndicator?: string;
+	commonIndicator?: string;
+	contextLines?: number;
+	emptyFirstOrLastLinePlaceholder?: string;
+	expand?: boolean;
+	includeChangeCounts?: boolean;
+	omitAnnotationLines?: boolean;
+	printBasicPrototype?: boolean;
+	maxDepth?: number;
+	truncateThreshold?: number;
+	truncateAnnotation?: string;
+}
+
+export type { DiffOptions as D, SerializedDiffOptions as S, DiffOptionsColor as a };

package/dist/@vitest/utils/types.d.ts

@@ -0,0 +1,34 @@
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type MergeInsertions<T> = T extends object ? { [K in keyof T] : MergeInsertions<T[K]> } : T;
+type DeepMerge<
+	F,
+	S
+> = MergeInsertions<{ [K in keyof F | keyof S] : K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never }>;
+interface Constructable {
+	new (...args: any[]): any;
+}
+interface ParsedStack {
+	method: string;
+	file: string;
+	line: number;
+	column: number;
+}
+interface SerializedError {
+	message: string;
+	stacks?: ParsedStack[];
+	stack?: string;
+	name?: string;
+	cause?: SerializedError;
+	[key: string]: unknown;
+}
+interface TestError extends SerializedError {
+	cause?: TestError;
+	diff?: string;
+	actual?: string;
+	expected?: string;
+}
+
+export type { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, MergeInsertions, Nullable, ParsedStack, SerializedError, TestError };

package/dist/@vitest/utils/types.js

@@ -0,0 +1 @@
+

package/dist/browser-compat.js

@@ -0,0 +1,3 @@
+// Re-export @vitest/browser compatible symbols
+// This allows this package to be used as an override for @vitest/browser
+export { resolveScreenshotPath, defineBrowserProvider, parseKeyDef, defineBrowserCommand } from './@vitest/browser/index.js';

package/dist/browser.d.ts

@@ -0,0 +1,46 @@
+import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.d.Cy95HiCx.js';
+import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.BZtK59WP.js';
+import { SerializedDiffOptions } from './@vitest/utils/diff.js';
+export { O as OTELCarrier, T as Traces } from './chunks/traces.d.402V_yFI.js';
+export { collectTests, startTests } from './@vitest/runner/index.js';
+import * as _vitest_spy from './@vitest/spy/index.js';
+export { _vitest_spy as SpyModule };
+export { LoupeOptions, ParsedStack, StringifyOptions } from './@vitest/utils/index.js';
+export { browserFormat, format, inspect, stringify } from './@vitest/utils/display.js';
+export { processError } from './@vitest/utils/error.js';
+export { getType } from './@vitest/utils/helpers.js';
+export { DecodedMap, getOriginalPosition } from './@vitest/utils/source-map.js';
+export { getSafeTimers, setSafeTimers } from './@vitest/utils/timers.js';
+import './@vitest/pretty-format/index.js';
+import './@vitest/snapshot/index.js';
+
+declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
+	isolate: boolean;
+}): Promise<unknown>;
+declare function takeCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader): Promise<unknown>;
+declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
+	isolate: boolean;
+}): Promise<unknown>;
+
+interface PublicModuleRunner {
+	import: (id: string) => Promise<any>;
+}
+
+declare function setupCommonEnv(config: SerializedConfig): Promise<void>;
+declare function loadDiffConfig(config: SerializedConfig, moduleRunner: PublicModuleRunner): Promise<SerializedDiffOptions | undefined>;
+declare function loadSnapshotSerializers(config: SerializedConfig, moduleRunner: PublicModuleRunner): Promise<void>;
+
+interface FsOptions {
+	encoding?: BufferEncoding;
+	flag?: string | number;
+}
+interface BrowserCommands {
+	readFile: (path: string, options?: BufferEncoding | FsOptions) => Promise<string>;
+	writeFile: (path: string, content: string, options?: BufferEncoding | (FsOptions & {
+		mode?: number | string;
+	})) => Promise<void>;
+	removeFile: (path: string) => Promise<void>;
+}
+
+export { loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };
+export type { BrowserCommands, FsOptions };

package/dist/browser.js

@@ -0,0 +1,20 @@
+export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.Cm-kSBVi.js';
+export { T as Traces } from './chunks/traces.CCmnQaNT.js';
+export { collectTests, startTests } from './@vitest/runner/index.js';
+import * as spyModule from './@vitest/spy/index.js';
+export { spyModule as SpyModule };
+export { browserFormat, format, inspect, stringify } from './@vitest/utils/display.js';
+export { processError } from './@vitest/utils/error.js';
+export { getType } from './@vitest/utils/helpers.js';
+export { DecodedMap, getOriginalPosition } from './@vitest/utils/source-map.js';
+export { getSafeTimers, setSafeTimers } from './@vitest/utils/timers.js';
+import './chunks/coverage.D_JHT54q.js';
+import './@vitest/snapshot/index.js';
+import './chunks/utils.DvEY5TfP.js';
+
+/**
+* @internal
+*/
+const __INTERNAL = { _extendedMethods: /* @__PURE__ */ new Set() };
+
+export { __INTERNAL };

package/dist/chunks/_commonjsHelpers.D26ty3Ew.js

@@ -0,0 +1,6 @@
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+export { commonjsGlobal as c, getDefaultExportFromCjs as g };

package/dist/chunks/base.CJ0Y4ePK.js

@@ -0,0 +1,165 @@
+import { runInThisContext } from 'node:vm';
+import * as spyModule from '../@vitest/spy/index.js';
+import { r as resolveTestRunner, a as resolveSnapshotEnvironment, s as setupChaiConfig } from './index.6Qv1eEA6.js';
+import { l as loadEnvironment, e as emitModuleRunner } from './init.B6MLFIaN.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.DEj0jb3e.js';
+import { performance as performance$1 } from 'node:perf_hooks';
+import { startTests, collectTests } from '../@vitest/runner/index.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.Cm-kSBVi.js';
+import { g as globalExpect, v as vi } from './vi.2VT5v0um.js';
+import { c as closeInspector } from './inspector.CvyFGlXm.js';
+import { createRequire } from 'node:module';
+import timers from 'node:timers';
+import timersPromises from 'node:timers/promises';
+import util from 'node:util';
+import { KNOWN_ASSET_TYPES } from '../@vitest/utils/constants.js';
+import { i as index } from './index.Z5E_ObnR.js';
+import { g as getWorkerState, r as resetModules, p as provideWorkerState } from './utils.DvEY5TfP.js';
+
+// this should only be used in Node
+let globalSetup = false;
+async function setupGlobalEnv(config, environment) {
+  await setupCommonEnv(config);
+  Object.defineProperty(globalThis, "__vitest_index__", {
+    value: index,
+    enumerable: false
+  });
+  globalExpect.setState({ environment: environment.name });
+  if (globalSetup) return;
+  globalSetup = true;
+  if ((environment.viteEnvironment || environment.name) === "client") {
+    const _require = createRequire(import.meta.url);
+    // always mock "required" `css` files, because we cannot process them
+    _require.extensions[".css"] = resolveCss;
+    _require.extensions[".scss"] = resolveCss;
+    _require.extensions[".sass"] = resolveCss;
+    _require.extensions[".less"] = resolveCss;
+    // since we are using Vite, we can assume how these will be resolved
+    KNOWN_ASSET_TYPES.forEach((type) => {
+      _require.extensions[`.${type}`] = resolveAsset;
+    });
+    process.env.SSR = "";
+  } else process.env.SSR = "1";
+  // @ts-expect-error not typed global for patched timers
+  globalThis.__vitest_required__ = {
+    util,
+    timers,
+    timersPromises
+  };
+  if (!config.disableConsoleIntercept) await setupConsoleLogSpy();
+}
+function resolveCss(mod) {
+  mod.exports = "";
+}
+function resolveAsset(mod, url) {
+  mod.exports = url;
+}
+async function setupConsoleLogSpy() {
+  const { createCustomConsole } = await import('./console.Cf-YriPC.js');
+  globalThis.console = createCustomConsole();
+}
+
+// browser shouldn't call this!
+async function run(method, files, config, moduleRunner, environment, traces) {
+  const workerState = getWorkerState();
+  const [testRunner] = await Promise.all([
+    traces.$("vitest.runtime.runner", () => resolveTestRunner(config, moduleRunner, traces)),
+    traces.$("vitest.runtime.global_env", () => setupGlobalEnv(config, environment)),
+    traces.$("vitest.runtime.coverage.start", () => startCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate })),
+    traces.$("vitest.runtime.snapshot.environment", async () => {
+      if (!workerState.config.snapshotOptions.snapshotEnvironment) workerState.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, moduleRunner);
+    })
+  ]);
+  workerState.onCancel((reason) => {
+    closeInspector(config);
+    testRunner.cancel?.(reason);
+  });
+  workerState.durations.prepare = performance$1.now() - workerState.durations.prepare;
+  await traces.$(`vitest.test.runner.${method}`, async () => {
+    for (const file of files) {
+      if (config.isolate) {
+        moduleRunner.mocker.reset();
+        resetModules(workerState.evaluatedModules, true);
+      }
+      workerState.filepath = file.filepath;
+      if (method === "run") await traces.$(`vitest.test.runner.${method}.module`, { attributes: { "code.file.path": file.filepath } }, () => startTests([file], testRunner));
+      else await traces.$(`vitest.test.runner.${method}.module`, { attributes: { "code.file.path": file.filepath } }, () => collectTests([file], testRunner));
+      // reset after tests, because user might call `vi.setConfig` in setupFile
+      vi.resetConfig();
+      // mocks should not affect different files
+      vi.restoreAllMocks();
+    }
+  });
+  await traces.$("vitest.runtime.coverage.stop", () => stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.isolate }));
+}
+
+let _moduleRunner;
+const evaluatedModules = new VitestEvaluatedModules();
+const moduleExecutionInfo = /* @__PURE__ */ new Map();
+function startModuleRunner(options) {
+  if (_moduleRunner) return _moduleRunner;
+  _moduleRunner = startVitestModuleRunner(options);
+  return _moduleRunner;
+}
+let _currentEnvironment;
+let _environmentTime;
+/** @experimental */
+async function setupEnvironment(context) {
+  const startTime = performance.now();
+  const { environment: { name: environmentName, options: environmentOptions }, rpc, config } = context;
+  // we could load @vite/env, but it would take ~8ms, while this takes ~0,02ms
+  if (context.config.serializedDefines) try {
+    runInThisContext(`(() =>{\n${context.config.serializedDefines}})()`, {
+      lineOffset: 1,
+      filename: "virtual:load-defines.js"
+    });
+  } catch (error) {
+    throw new Error(`Failed to load custom "defines": ${error.message}`);
+  }
+  const otel = context.traces;
+  const { environment, loader } = await loadEnvironment(environmentName, config.root, rpc, otel);
+  _currentEnvironment = environment;
+  const env = await otel.$("vitest.runtime.environment.setup", { attributes: {
+    "vitest.environment": environment.name,
+    "vitest.environment.vite_environment": environment.viteEnvironment || environment.name
+  } }, () => environment.setup(globalThis, environmentOptions || config.environmentOptions || {}));
+  _environmentTime = performance.now() - startTime;
+  if (config.chaiConfig) setupChaiConfig(config.chaiConfig);
+  return async () => {
+    await otel.$("vitest.runtime.environment.teardown", () => env.teardown(globalThis));
+    await loader?.close();
+  };
+}
+/** @experimental */
+async function runBaseTests(method, state, traces) {
+  const { ctx } = state;
+  state.environment = _currentEnvironment;
+  state.durations.environment = _environmentTime;
+  // state has new context, but we want to reuse existing ones
+  state.evaluatedModules = evaluatedModules;
+  state.moduleExecutionInfo = moduleExecutionInfo;
+  provideWorkerState(globalThis, state);
+  if (ctx.invalidates) ctx.invalidates.forEach((filepath) => {
+    (state.evaluatedModules.fileToModulesMap.get(filepath) || []).forEach((module) => {
+      state.evaluatedModules.invalidateModule(module);
+    });
+  });
+  ctx.files.forEach((i) => {
+    const filepath = i.filepath;
+    (state.evaluatedModules.fileToModulesMap.get(filepath) || []).forEach((module) => {
+      state.evaluatedModules.invalidateModule(module);
+    });
+  });
+  const moduleRunner = startModuleRunner({
+    state,
+    evaluatedModules: state.evaluatedModules,
+    spyModule,
+    createImportMeta: createNodeImportMeta,
+    traces
+  });
+  emitModuleRunner(moduleRunner);
+  await run(method, ctx.files, ctx.config, moduleRunner, _currentEnvironment, traces);
+}
+
+export { runBaseTests as r, setupEnvironment as s };

package/dist/chunks/benchmark.B3N2zMcH.js

@@ -0,0 +1,40 @@
+import { getCurrentSuite } from '../@vitest/runner/index.js';
+import { createChainable } from '../@vitest/runner/utils.js';
+import { noop } from '../@vitest/utils/helpers.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+
+const benchFns = /* @__PURE__ */ new WeakMap();
+const benchOptsMap = /* @__PURE__ */ new WeakMap();
+function getBenchOptions(key) {
+  return benchOptsMap.get(key);
+}
+function getBenchFn(key) {
+  return benchFns.get(key);
+}
+const bench = createBenchmark(function(name, fn = noop, options = {}) {
+  if (getWorkerState().config.mode !== "benchmark") throw new Error("`bench()` is only available in benchmark mode.");
+  const task = getCurrentSuite().task(formatName(name), {
+    ...this,
+    meta: { benchmark: true }
+  });
+  benchFns.set(task, fn);
+  benchOptsMap.set(task, options);
+  // vitest runner sets mode to `todo` if handler is not passed down
+  // but we store handler separetly
+  if (!this.todo && task.mode === "todo") task.mode = "run";
+});
+function createBenchmark(fn) {
+  const benchmark = createChainable([
+    "skip",
+    "only",
+    "todo"
+  ], fn);
+  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+  return benchmark;
+}
+function formatName(name) {
+  return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
+}
+
+export { getBenchOptions as a, bench as b, getBenchFn as g };

package/dist/chunks/benchmark.d.DAaHLpsq.d.ts

@@ -0,0 +1,24 @@
+import { Test } from '../@vitest/runner/index.js';
+import { ChainableFunction } from '../@vitest/runner/utils.js';
+import { TaskResult, Bench, Options } from '../vendor/tinybench.mjs';
+
+interface Benchmark extends Test {
+	meta: {
+		benchmark: true;
+		result?: TaskResult;
+	};
+}
+interface BenchmarkResult extends TaskResult {
+	name: string;
+	rank: number;
+	sampleCount: number;
+	median: number;
+}
+type BenchFunction = (this: Bench) => Promise<void> | void;
+type ChainableBenchmarkAPI = ChainableFunction<"skip" | "only" | "todo", (name: string | Function, fn?: BenchFunction, options?: Options) => void>;
+type BenchmarkAPI = ChainableBenchmarkAPI & {
+	skipIf: (condition: any) => ChainableBenchmarkAPI;
+	runIf: (condition: any) => ChainableBenchmarkAPI;
+};
+
+export type { BenchmarkResult as B, BenchFunction as a, Benchmark as b, BenchmarkAPI as c };

package/dist/chunks/browser.d.ChKACdzH.d.ts

@@ -0,0 +1,59 @@
+import { FileSpecification } from '../@vitest/runner/index.js';
+import { O as OTELCarrier } from './traces.d.402V_yFI.js';
+import { T as TestExecutionMethod } from './worker.d.Dyxm8DEL.js';
+
+type SerializedTestSpecification = [project: {
+	name: string | undefined;
+	root: string;
+}, file: string, options: {
+	pool: string;
+	testLines?: number[] | undefined;
+}];
+
+interface ModuleDefinitionLocation {
+	line: number;
+	column: number;
+}
+interface SourceModuleLocations {
+	modules: ModuleDefinitionDiagnostic[];
+	untracked: ModuleDefinitionDiagnostic[];
+}
+interface ModuleDefinitionDiagnostic {
+	start: ModuleDefinitionLocation;
+	end: ModuleDefinitionLocation;
+	startIndex: number;
+	endIndex: number;
+	rawUrl: string;
+	resolvedUrl: string;
+	resolvedId: string;
+}
+interface ModuleDefinitionDurationsDiagnostic extends ModuleDefinitionDiagnostic {
+	selfTime: number;
+	totalTime: number;
+	transformTime?: number;
+	external?: boolean;
+	importer?: string;
+}
+interface UntrackedModuleDefinitionDiagnostic {
+	url: string;
+	resolvedId: string;
+	resolvedUrl: string;
+	selfTime: number;
+	totalTime: number;
+	transformTime?: number;
+	external?: boolean;
+	importer?: string;
+}
+interface SourceModuleDiagnostic {
+	modules: ModuleDefinitionDurationsDiagnostic[];
+	untrackedModules: UntrackedModuleDefinitionDiagnostic[];
+}
+
+interface BrowserTesterOptions {
+	method: TestExecutionMethod;
+	files: FileSpecification[];
+	providedContext: string;
+	otelCarrier?: OTELCarrier;
+}
+
+export type { BrowserTesterOptions as B, ModuleDefinitionDurationsDiagnostic as M, SerializedTestSpecification as S, UntrackedModuleDefinitionDiagnostic as U, ModuleDefinitionDiagnostic as a, ModuleDefinitionLocation as b, SourceModuleDiagnostic as c, SourceModuleLocations as d };