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

package/dist/chunks/suite.d.BJWk38HB.d.ts

@@ -0,0 +1,10 @@
+import { Test } from '../@vitest/runner/index.js';
+import { c as BenchmarkAPI, a as BenchFunction } from './benchmark.d.DAaHLpsq.js';
+import { Options } from '../vendor/tinybench.mjs';
+import '../@vitest/runner/utils.js';
+
+declare function getBenchOptions(key: Test): Options;
+declare function getBenchFn(key: Test): BenchFunction;
+declare const bench: BenchmarkAPI;
+
+export { getBenchOptions as a, bench as b, getBenchFn as g };

package/dist/chunks/test.B8ej_ZHS.js

@@ -0,0 +1,254 @@
+import { updateTask } from '../@vitest/runner/index.js';
+import { createDefer } from '../@vitest/utils/helpers.js';
+import { getSafeTimers } from '../@vitest/utils/timers.js';
+import { a as getBenchOptions, g as getBenchFn } from './benchmark.B3N2zMcH.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import { setState, GLOBAL_EXPECT, getState } from '../@vitest/expect/index.js';
+import { getTests, getNames, getTestName } from '../@vitest/runner/utils.js';
+import { processError } from '../@vitest/utils/error.js';
+import { normalize } from '../vendor/pathe.mjs';
+import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.2VT5v0um.js';
+import { r as rpc } from './rpc.BoxB0q7B.js';
+
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+  const { Task, Bench } = await runner.importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run" && task.mode !== "queued") continue;
+    if (task.meta?.benchmark) benchmarkGroup.push(task);
+    else if (task.type === "suite") benchmarkSuiteGroup.push(task);
+  }
+  // run sub suites sequentially
+  for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1("suite-prepare", suite);
+    const addBenchTaskListener = (task, benchmark) => {
+      task.addEventListener("complete", (e) => {
+        const taskRes = e.task.result;
+        const result = benchmark.result.benchmark;
+        benchmark.result.state = "pass";
+        Object.assign(result, taskRes);
+        // compute extra stats and free raw samples as early as possible
+        const samples = result.samples;
+        result.sampleCount = samples.length;
+        result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+        if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
+        updateTask$1("test-finished", benchmark);
+      }, { once: true });
+      task.addEventListener("error", (e) => {
+        const task = e.task;
+        defer.reject(benchmark ? task.result.error : e);
+      }, { once: true });
+    };
+    benchmarkGroup.forEach((benchmark) => {
+      const benchmarkInstance = new Bench(getBenchOptions(benchmark));
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+      benchmarkTasks.set(benchmark, task);
+      addBenchTaskListener(task, benchmark);
+    });
+    const { setTimeout } = getSafeTimers();
+    const tasks = [];
+    for (const benchmark of benchmarkGroup) {
+      const task = benchmarkTasks.get(benchmark);
+      updateTask$1("test-prepare", benchmark);
+      await task.warmup();
+      tasks.push([await new Promise((resolve) => setTimeout(async () => {
+        resolve(await task.run());
+      })), benchmark]);
+    }
+    suite.result.duration = performance.now() - start;
+    suite.result.state = "pass";
+    updateTask$1("suite-finished", suite);
+    defer.resolve(null);
+    await defer;
+  }
+  function updateTask$1(event, task) {
+    updateTask(event, task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  moduleRunner;
+  constructor(config) {
+    this.config = config;
+  }
+  async importTinybench() {
+    return await import('../vendor/tinybench.mjs');
+  }
+  importFile(filepath, source) {
+    if (source === "setup") {
+      const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
+      if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
+    }
+    return this.moduleRunner.import(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTask() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
+
+// worker context is shared between all tests
+const workerContext = Object.create(null);
+class VitestTestRunner {
+  snapshotClient = getSnapshotClient();
+  workerState = getWorkerState();
+  moduleRunner;
+  cancelRun = false;
+  assertionsErrors = /* @__PURE__ */ new WeakMap();
+  pool = this.workerState.ctx.pool;
+  _otel;
+  viteEnvironment;
+  constructor(config) {
+    this.config = config;
+    const environment = this.workerState.environment;
+    this.viteEnvironment = environment.viteEnvironment || environment.name;
+  }
+  importFile(filepath, source) {
+    if (source === "setup") {
+      const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+      if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+    }
+    return this._otel.$(`vitest.module.import_${source === "setup" ? "setup" : "spec"}`, { attributes: { "code.file.path": filepath } }, () => this.moduleRunner.import(filepath));
+  }
+  onCollectStart(file) {
+    this.workerState.current = file;
+  }
+  onCleanupWorkerContext(listener) {
+    this.workerState.onCleanup(listener);
+  }
+  onAfterRunFiles() {
+    this.snapshotClient.clear();
+    this.workerState.current = void 0;
+  }
+  getWorkerContext() {
+    return workerContext;
+  }
+  async onAfterRunSuite(suite) {
+    if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+    if (suite.mode !== "skip" && "filepath" in suite) {
+      // mark snapshots in skipped tests as not obsolete
+      for (const test of getTests(suite)) if (test.mode === "skip") {
+        const name = getNames(test).slice(1).join(" > ");
+        this.snapshotClient.skipTest(suite.file.filepath, name);
+      }
+      const result = await this.snapshotClient.finish(suite.file.filepath);
+      if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+        let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+        for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+        suite.result.errors ??= [];
+        suite.result.errors.push(processError(new Error(message)));
+        suite.result.state = "fail";
+      }
+      await rpc().snapshotSaved(result);
+    }
+    this.workerState.current = suite.suite || suite.file;
+  }
+  onAfterRunTask(test) {
+    if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+    this.workerState.current = test.suite || test.file;
+  }
+  cancel(_reason) {
+    this.cancelRun = true;
+  }
+  injectValue(key) {
+    // inject has a very limiting type controlled by ProvidedContext
+    // some tests override it which causes the build to fail
+    return inject(key);
+  }
+  async onBeforeRunTask(test) {
+    if (this.cancelRun) test.mode = "skip";
+    if (test.mode !== "run" && test.mode !== "queued") return;
+    this.workerState.current = test;
+  }
+  async onBeforeRunSuite(suite) {
+    if (this.cancelRun) suite.mode = "skip";
+    // initialize snapshot state before running file suite
+    if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+    this.workerState.current = suite;
+  }
+  onBeforeTryTask(test) {
+    clearModuleMocks(this.config);
+    this.snapshotClient.clearTest(test.file.filepath, test.id);
+    setState({
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberErrorGen: null,
+      currentTestName: getTestName(test),
+      snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+    }, globalThis[GLOBAL_EXPECT]);
+  }
+  onAfterTryTask(test) {
+    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+    if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+    if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+  }
+  extendTaskContext(context) {
+    // create error during the test initialization so we have a nice stack trace
+    if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+    let _expect;
+    Object.defineProperty(context, "expect", { get() {
+      if (!_expect) _expect = createExpect(context.task);
+      return _expect;
+    } });
+    Object.defineProperty(context, "_local", { get() {
+      return _expect != null;
+    } });
+    return context;
+  }
+  getImportDurations() {
+    const importDurations = {};
+    const entries = this.workerState.moduleExecutionInfo?.entries() || [];
+    for (const [filepath, { duration, selfTime, external, importer }] of entries) importDurations[normalize(filepath)] = {
+      selfTime,
+      totalTime: duration,
+      external,
+      importer
+    };
+    return importDurations;
+  }
+  trace = (name, attributes, cb) => {
+    const options = typeof attributes === "object" ? { attributes } : {};
+    return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+  };
+  __setTraces(traces) {
+    this._otel = traces;
+  }
+}
+function clearModuleMocks(config) {
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+  if (restoreMocks) vi.restoreAllMocks();
+  if (mockReset) vi.resetAllMocks();
+  if (clearMocks) vi.clearAllMocks();
+  if (unstubEnvs) vi.unstubAllEnvs();
+  if (unstubGlobals) vi.unstubAllGlobals();
+}
+
+export { NodeBenchmarkRunner as N, VitestTestRunner as V };

package/dist/chunks/traces.CCmnQaNT.js

@@ -0,0 +1,217 @@
+class Traces {
+  /**
+  * otel stands for OpenTelemetry
+  */
+  #otel = null;
+  #sdk = null;
+  #init = null;
+  #noopSpan = createNoopSpan();
+  #noopContext = createNoopContext();
+  #initStartTime = performance.now();
+  #initEndTime = 0;
+  #initRecorded = false;
+  constructor(options) {
+    if (options.enabled) {
+      const apiInit = import('@opentelemetry/api').then((api) => {
+        this.#otel = {
+          tracer: api.trace.getTracer(options.tracerName || "vitest"),
+          context: api.context,
+          propagation: api.propagation,
+          trace: api.trace,
+          SpanKind: api.SpanKind,
+          SpanStatusCode: api.SpanStatusCode
+        };
+      }).catch(() => {
+        throw new Error(`"@opentelemetry/api" is not installed locally. Make sure you have setup OpenTelemetry instrumentation: https://vitest.dev/guide/open-telemetry`);
+      });
+      const sdkInit = (options.sdkPath ? import(
+        /* @vite-ignore */
+        options.sdkPath
+) : Promise.resolve()).catch((cause) => {
+        throw new Error(`Failed to import custom OpenTelemetry SDK script (${options.sdkPath}): ${cause.message}`);
+      });
+      this.#init = Promise.all([sdkInit, apiInit]).then(([sdk]) => {
+        if (sdk != null) {
+          if (sdk.default != null && typeof sdk.default === "object" && typeof sdk.default.shutdown === "function") this.#sdk = sdk.default;
+          else if (options.watchMode !== true && process.env.VITEST_MODE !== "watch") console.warn(`OpenTelemetry instrumentation module (${options.sdkPath}) does not have a default export with a "shutdown" method. Vitest won't be able to ensure that all traces are processed in time. Try running Vitest in watch mode instead.`);
+        }
+      }).finally(() => {
+        this.#initEndTime = performance.now();
+        this.#init = null;
+      });
+    }
+  }
+  isEnabled() {
+    return !!this.#otel;
+  }
+  /**
+  * @internal
+  */
+  async waitInit() {
+    if (this.#init) await this.#init;
+    return this;
+  }
+  /**
+  * @internal
+  */
+  recordInitSpan(context) {
+    if (this.#initRecorded) return;
+    this.#initRecorded = true;
+    this.startSpan("vitest.runtime.traces", { startTime: this.#initStartTime }, context).end(this.#initEndTime);
+  }
+  /**
+  * @internal
+  */
+  startContextSpan(name, currentContext) {
+    if (!this.#otel) return {
+      span: this.#noopSpan,
+      context: this.#noopContext
+    };
+    const activeContext = currentContext || this.#otel.context.active();
+    const span = this.#otel.tracer.startSpan(name, {}, activeContext);
+    return {
+      span,
+      context: this.#otel.trace.setSpan(activeContext, span)
+    };
+  }
+  /**
+  * @internal
+  */
+  getContextFromCarrier(carrier) {
+    if (!this.#otel) return this.#noopContext;
+    const activeContext = this.#otel.context.active();
+    if (!carrier) return activeContext;
+    return this.#otel.propagation.extract(activeContext, carrier);
+  }
+  /**
+  * @internal
+  */
+  getContextFromEnv(env) {
+    if (!this.#otel) return this.#noopContext;
+    // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/context/env-carriers.md
+    // some tools sets only `TRACEPARENT` but not `TRACESTATE`
+    const carrier = {};
+    if (typeof env.TRACEPARENT === "string") carrier.traceparent = env.TRACEPARENT;
+    if (typeof env.TRACESTATE === "string") carrier.tracestate = env.TRACESTATE;
+    return this.getContextFromCarrier(carrier);
+  }
+  /**
+  * @internal
+  */
+  getContextCarrier(context) {
+    if (!this.#otel) return;
+    const carrier = {};
+    this.#otel.propagation.inject(context || this.#otel.context.active(), carrier);
+    return carrier;
+  }
+  #callActiveSpan(span, callback) {
+    const otel = this.#otel;
+    let result;
+    try {
+      result = callback(span);
+      if (result instanceof Promise) return result.catch((error) => {
+        span.recordException({
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        });
+        span.setStatus({ code: otel.SpanStatusCode.ERROR });
+        throw error;
+      }).finally(() => span.end());
+      return result;
+    } catch (error) {
+      if (error instanceof Error) {
+        span.recordException({
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        });
+        span.setStatus({ code: otel.SpanStatusCode.ERROR });
+      }
+      throw error;
+    } finally {
+      // end sync callbcak
+      if (!(result instanceof Promise)) span.end();
+    }
+  }
+  /**
+  * @internal
+  */
+  $(name, optionsOrFn, fn) {
+    const callback = typeof optionsOrFn === "function" ? optionsOrFn : fn;
+    if (!this.#otel) return callback(this.#noopSpan);
+    const otel = this.#otel;
+    const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+    const context = options.context;
+    if (context) return otel.tracer.startActiveSpan(name, options, context, (span) => this.#callActiveSpan(span, callback));
+    return otel.tracer.startActiveSpan(name, options, (span) => this.#callActiveSpan(span, callback));
+  }
+  /**
+  * @internal
+  */
+  startSpan(name, options, context) {
+    if (!this.#otel) return this.#noopSpan;
+    const { tracer } = this.#otel;
+    return tracer.startSpan(name, options, context);
+  }
+  // On browser mode, async context is not automatically propagated,
+  // so we manually bind the `$` calls to the provided context.
+  // TODO: this doesn't bind to user land's `@optelemetry/api` calls
+  /**
+  * @internal
+  */
+  bind(context) {
+    if (!this.#otel) return;
+    const original = this.$.__original ?? this.$;
+    this.$ = this.#otel.context.bind(context, original);
+    this.$.__original = original;
+  }
+  /**
+  * @internal
+  */
+  async finish() {
+    await this.#sdk?.shutdown();
+  }
+  /**
+  * @internal
+  */
+  async flush() {
+    await this.#sdk?.forceFlush?.();
+  }
+}
+function noopSpan() {
+  return this;
+}
+function createNoopSpan() {
+  return {
+    setAttribute: noopSpan,
+    setStatus: noopSpan,
+    addEvent: noopSpan,
+    addLink: noopSpan,
+    addLinks: noopSpan,
+    setAttributes: noopSpan,
+    updateName: noopSpan,
+    end: () => {},
+    isRecording: () => false,
+    recordException: noopSpan,
+    spanContext() {
+      return {
+        spanId: "",
+        traceFlags: 0,
+        traceId: ""
+      };
+    }
+  };
+}
+function noopContext() {
+  return this;
+}
+function createNoopContext() {
+  return {
+    getValue: noopContext,
+    setValue: noopContext,
+    deleteValue: noopContext
+  };
+}
+
+export { Traces as T };

package/dist/chunks/traces.d.402V_yFI.d.ts

@@ -0,0 +1,18 @@
+interface OTELCarrier {
+	traceparent?: string;
+	tracestate?: string;
+}
+interface TracesOptions {
+	enabled: boolean;
+	watchMode?: boolean;
+	sdkPath?: string;
+	tracerName?: string;
+}
+declare class Traces {
+	#private;
+	constructor(options: TracesOptions);
+	isEnabled(): boolean;
+}
+
+export { Traces as T };
+export type { OTELCarrier as O };

package/dist/chunks/utils.DvEY5TfP.js

@@ -0,0 +1,52 @@
+import { getSafeTimers } from '../@vitest/utils/timers.js';
+
+const NAME_WORKER_STATE = "__vitest_worker__";
+function getWorkerState() {
+  // @ts-expect-error untyped global
+  const workerState = globalThis[NAME_WORKER_STATE];
+  if (!workerState) throw new Error("Vitest failed to access its internal state.\n\nOne of the following is possible:\n- \"vitest\" is imported directly without running \"vitest\" command\n- \"vitest\" is imported inside \"globalSetup\" (to fix this, use \"setupFiles\" instead, because \"globalSetup\" runs in a different context)\n- \"vitest\" is imported inside Vite / Vitest config file\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n");
+  return workerState;
+}
+function provideWorkerState(context, state) {
+  Object.defineProperty(context, NAME_WORKER_STATE, {
+    value: state,
+    configurable: true,
+    writable: true,
+    enumerable: false
+  });
+  return state;
+}
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
+}
+function resetModules(modules, resetMocks = false) {
+  const skipPaths = [
+    /\/vitest\/dist\//,
+    /vitest-virtual-\w+\/dist/,
+    /@vitest\/dist/,
+    ...!resetMocks ? [/^mock:/] : []
+  ];
+  modules.idToModuleMap.forEach((node, path) => {
+    if (skipPaths.some((re) => re.test(path))) return;
+    node.promise = void 0;
+    node.exports = void 0;
+    node.evaluated = false;
+    node.importers.clear();
+  });
+}
+function waitNextTick() {
+  const { setTimeout } = getSafeTimers();
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function waitForImportsToResolve() {
+  await waitNextTick();
+  const state = getWorkerState();
+  const promises = [];
+  const resolvingCount = state.resolvingModules.size;
+  for (const [_, mod] of state.evaluatedModules.idToModuleMap) if (mod.promise && !mod.evaluated) promises.push(mod.promise);
+  if (!promises.length && !resolvingCount) return;
+  await Promise.allSettled(promises);
+  await waitForImportsToResolve();
+}
+
+export { getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, waitForImportsToResolve as w };