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

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

@@ -0,0 +1,210 @@
+import { PrettyFormatOptions } from '../@vitest/pretty-format/index.js';
+import { SequenceHooks, SequenceSetupFiles } from '../@vitest/runner/index.js';
+import { SnapshotUpdateState, SnapshotEnvironment } from '../@vitest/snapshot/index.js';
+import { SerializedDiffOptions } from '../@vitest/utils/diff.js';
+
+/**
+ * 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.js';
+import c from '../vendor/tinyrainbow.mjs';
+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 };