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

package/dist/chunks/index.Z5E_ObnR.js

@@ -0,0 +1,37 @@
+import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.2VT5v0um.js';
+import { b as bench } from './benchmark.B3N2zMcH.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
+import { expectTypeOf } from '../vendor/expect-type.mjs';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '../@vitest/runner/index.js';
+import { chai } from '../@vitest/expect/index.js';
+
+const assertType = function assertType() {};
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  EvaluatedModules: VitestEvaluatedModules,
+  afterAll: afterAll,
+  afterEach: afterEach,
+  assert: assert,
+  assertType: assertType,
+  beforeAll: beforeAll,
+  beforeEach: beforeEach,
+  bench: bench,
+  chai: chai,
+  createExpect: createExpect,
+  describe: describe,
+  expect: globalExpect,
+  expectTypeOf: expectTypeOf,
+  inject: inject,
+  it: it,
+  onTestFailed: onTestFailed,
+  onTestFinished: onTestFinished,
+  recordArtifact: recordArtifact,
+  should: should,
+  suite: suite,
+  test: test,
+  vi: vi,
+  vitest: vitest
+});
+
+export { assertType as a, index as i };

package/dist/chunks/init-forks._y3TW739.js

@@ -0,0 +1,41 @@
+import { i as init } from './init.B6MLFIaN.js';
+
+if (!process.send) throw new Error("Expected worker to be run in node:child_process");
+// Store globals in case tests overwrite them
+const processExit = process.exit.bind(process);
+const processSend = process.send.bind(process);
+const processOn = process.on.bind(process);
+const processOff = process.off.bind(process);
+const processRemoveAllListeners = process.removeAllListeners.bind(process);
+// Work-around for nodejs/node#55094
+if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
+processOn("error", onError);
+function workerInit(options) {
+  const { runTests } = options;
+  init({
+    post: (v) => processSend(v),
+    on: (cb) => processOn("message", cb),
+    off: (cb) => processOff("message", cb),
+    teardown: () => {
+      processRemoveAllListeners("message");
+      processOff("error", onError);
+    },
+    runTests: (state, traces) => executeTests("run", state, traces),
+    collectTests: (state, traces) => executeTests("collect", state, traces),
+    setup: options.setup
+  });
+  async function executeTests(method, state, traces) {
+    try {
+      await runTests(method, state, traces);
+    } finally {
+      process.exit = processExit;
+    }
+  }
+}
+// Prevent leaving worker in loops where it tries to send message to closed main
+// thread, errors, and tries to send the error.
+function onError(error) {
+  if (error?.code === "ERR_IPC_CHANNEL_CLOSED" || error?.code === "EPIPE") processExit(1);
+}
+
+export { workerInit as w };

package/dist/chunks/init-threads.DBO2kn-p.js

@@ -0,0 +1,18 @@
+import { isMainThread, parentPort } from 'node:worker_threads';
+import { i as init } from './init.B6MLFIaN.js';
+
+if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
+function workerInit(options) {
+  const { runTests } = options;
+  init({
+    post: (response) => parentPort.postMessage(response),
+    on: (callback) => parentPort.on("message", callback),
+    off: (callback) => parentPort.off("message", callback),
+    teardown: () => parentPort.removeAllListeners("message"),
+    runTests: async (state, traces) => runTests("run", state, traces),
+    collectTests: async (state, traces) => runTests("collect", state, traces),
+    setup: options.setup
+  });
+}
+
+export { workerInit as w };

package/dist/chunks/init.B6MLFIaN.js

@@ -0,0 +1,334 @@
+import { readFileSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolve } from '../vendor/pathe.mjs';
+import { ModuleRunner } from '@voidzero-dev/vite-plus-core/module-runner';
+import { b as VitestTransport } from './startModuleRunner.DEj0jb3e.js';
+import { e as environments } from './index.CyBMJtT7.js';
+import { serializeError } from '../@vitest/utils/error.js';
+import { T as Traces } from './traces.CCmnQaNT.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BoxB0q7B.js';
+import { createStackString, parseStacktrace } from '../@vitest/utils/source-map.js';
+import { s as setupInspect } from './inspector.CvyFGlXm.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
+
+function isBuiltinEnvironment(env) {
+  return env in environments;
+}
+const isWindows = process.platform === "win32";
+const _loaders = /* @__PURE__ */ new Map();
+function createEnvironmentLoader(root, rpc) {
+  const cachedLoader = _loaders.get(root);
+  if (!cachedLoader || cachedLoader.isClosed()) {
+    _loaders.delete(root);
+    const moduleRunner = new ModuleRunner({
+      hmr: false,
+      sourcemapInterceptor: "prepareStackTrace",
+      transport: new VitestTransport({
+        async fetchModule(id, importer, options) {
+          const result = await rpc.fetch(id, importer, "__vitest__", options);
+          if ("cached" in result) return {
+            code: readFileSync(result.tmp, "utf-8"),
+            ...result
+          };
+          if (isWindows && "externalize" in result)
+ // TODO: vitest returns paths for external modules, but Vite returns file://
+          // https://github.com/vitejs/vite/pull/20449
+          result.externalize = isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id) ? result.externalize : pathToFileURL(result.externalize).toString();
+          return result;
+        },
+        async resolveId(id, importer) {
+          return rpc.resolve(id, importer, "__vitest__");
+        }
+      })
+    });
+    _loaders.set(root, moduleRunner);
+  }
+  return _loaders.get(root);
+}
+async function loadEnvironment(name, root, rpc, traces) {
+  if (isBuiltinEnvironment(name)) return { environment: environments[name] };
+  const loader = createEnvironmentLoader(root, rpc);
+  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
+  const pkg = await traces.$("vitest.runtime.environment.import", () => loader.import(packageId));
+  if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
+  const environment = pkg.default;
+  if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
+  if (environment.transformMode) {
+    console.warn(`The Vitest environment ${environment.name} defines the "transformMode". This options was deprecated in Vitest 4 and will be removed in the next major version. Please, use "viteEnvironment" instead.`);
+    // keep for backwards compat
+    environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
+  }
+  return {
+    environment,
+    loader
+  };
+}
+
+const cleanupListeners = /* @__PURE__ */ new Set();
+const moduleRunnerListeners = /* @__PURE__ */ new Set();
+function onCleanup(cb) {
+  cleanupListeners.add(cb);
+}
+async function cleanup() {
+  await Promise.all([...cleanupListeners].map((l) => l()));
+}
+function onModuleRunner(cb) {
+  moduleRunnerListeners.add(cb);
+}
+function emitModuleRunner(moduleRunner) {
+  moduleRunnerListeners.forEach((l) => l(moduleRunner));
+}
+
+const resolvingModules = /* @__PURE__ */ new Set();
+async function execute(method, ctx, worker, traces) {
+  const prepareStart = performance.now();
+  const cleanups = [setupInspect(ctx)];
+  // RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
+  const rpc = ctx.rpc;
+  try {
+    // do not close the RPC channel so that we can get the error messages sent to the main thread
+    cleanups.push(async () => {
+      await Promise.all(rpc.$rejectPendingCalls(({ method, reject }) => {
+        reject(/* @__PURE__ */ new Error(`[vitest-worker]: Closing rpc while "${method}" was pending`));
+      }));
+    });
+    const state = {
+      ctx,
+      evaluatedModules: new VitestEvaluatedModules(),
+      resolvingModules,
+      moduleExecutionInfo: /* @__PURE__ */ new Map(),
+      config: ctx.config,
+      environment: null,
+      durations: {
+        environment: 0,
+        prepare: prepareStart
+      },
+      rpc,
+      onCancel,
+      onCleanup: onCleanup,
+      providedContext: ctx.providedContext,
+      onFilterStackTrace(stack) {
+        return createStackString(parseStacktrace(stack));
+      },
+      metaEnv: createImportMetaEnvProxy()
+    };
+    const methodName = method === "collect" ? "collectTests" : "runTests";
+    if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
+    await worker[methodName](state, traces);
+  } finally {
+    await rpcDone().catch(() => {});
+    await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
+  }
+}
+function run(ctx, worker, traces) {
+  return execute("run", ctx, worker, traces);
+}
+function collect(ctx, worker, traces) {
+  return execute("collect", ctx, worker, traces);
+}
+async function teardown() {
+  await cleanup();
+}
+const env = process.env;
+function createImportMetaEnvProxy() {
+  // packages/vitest/src/node/plugins/index.ts:146
+  const booleanKeys = [
+    "DEV",
+    "PROD",
+    "SSR"
+  ];
+  return new Proxy(env, {
+    get(_, key) {
+      if (typeof key !== "string") return;
+      if (booleanKeys.includes(key)) return !!process.env[key];
+      return process.env[key];
+    },
+    set(_, key, value) {
+      if (typeof key !== "string") return true;
+      if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
+      else process.env[key] = value;
+      return true;
+    }
+  });
+}
+
+const __vitest_worker_response__ = true;
+const memoryUsage = process.memoryUsage.bind(process);
+let reportMemory = false;
+let traces;
+/** @experimental */
+function init(worker) {
+  worker.on(onMessage);
+  if (worker.onModuleRunner) onModuleRunner(worker.onModuleRunner);
+  let runPromise;
+  let isRunning = false;
+  let workerTeardown;
+  let setupContext;
+  function send(response) {
+    worker.post(worker.serialize ? worker.serialize(response) : response);
+  }
+  async function onMessage(rawMessage) {
+    const message = worker.deserialize ? worker.deserialize(rawMessage) : rawMessage;
+    if (message?.__vitest_worker_request__ !== true) return;
+    switch (message.type) {
+      case "start": {
+        process.env.VITEST_POOL_ID = String(message.poolId);
+        process.env.VITEST_WORKER_ID = String(message.workerId);
+        reportMemory = message.options.reportMemory;
+        traces ??= await new Traces({
+          enabled: message.traces.enabled,
+          sdkPath: message.traces.sdkPath
+        }).waitInit();
+        const { environment, config, pool } = message.context;
+        const context = traces.getContextFromCarrier(message.traces.otelCarrier);
+        // record telemetry as part of "start"
+        traces.recordInitSpan(context);
+        try {
+          setupContext = {
+            environment,
+            config,
+            pool,
+            rpc: createRuntimeRpc(worker),
+            projectName: config.name || "",
+            traces
+          };
+          workerTeardown = await traces.$("vitest.runtime.setup", { context }, () => worker.setup?.(setupContext));
+          send({
+            type: "started",
+            __vitest_worker_response__
+          });
+        } catch (error) {
+          send({
+            type: "started",
+            __vitest_worker_response__,
+            error: serializeError(error)
+          });
+        }
+        break;
+      }
+      case "run":
+        // Prevent concurrent execution if worker is already running
+        if (isRunning) {
+          send({
+            type: "testfileFinished",
+            __vitest_worker_response__,
+            error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
+          });
+          return;
+        }
+        try {
+          process.env.VITEST_WORKER_ID = String(message.context.workerId);
+        } catch (error) {
+          return send({
+            type: "testfileFinished",
+            __vitest_worker_response__,
+            error: serializeError(error),
+            usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+          });
+        }
+        isRunning = true;
+        try {
+          const tracesContext = traces.getContextFromCarrier(message.otelCarrier);
+          runPromise = traces.$("vitest.runtime.run", {
+            context: tracesContext,
+            attributes: {
+              "vitest.worker.specifications": traces.isEnabled() ? getFilesWithLocations(message.context.files) : [],
+              "vitest.worker.id": message.context.workerId
+            }
+          }, () => run({
+            ...setupContext,
+            ...message.context
+          }, worker, traces).catch((error) => serializeError(error)));
+          send({
+            type: "testfileFinished",
+            __vitest_worker_response__,
+            error: await runPromise,
+            usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+          });
+        } finally {
+          runPromise = void 0;
+          isRunning = false;
+        }
+        break;
+      case "collect":
+        // Prevent concurrent execution if worker is already running
+        if (isRunning) {
+          send({
+            type: "testfileFinished",
+            __vitest_worker_response__,
+            error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
+          });
+          return;
+        }
+        try {
+          process.env.VITEST_WORKER_ID = String(message.context.workerId);
+        } catch (error) {
+          return send({
+            type: "testfileFinished",
+            __vitest_worker_response__,
+            error: serializeError(error),
+            usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+          });
+        }
+        isRunning = true;
+        try {
+          const tracesContext = traces.getContextFromCarrier(message.otelCarrier);
+          runPromise = traces.$("vitest.runtime.collect", {
+            context: tracesContext,
+            attributes: {
+              "vitest.worker.specifications": traces.isEnabled() ? getFilesWithLocations(message.context.files) : [],
+              "vitest.worker.id": message.context.workerId
+            }
+          }, () => collect({
+            ...setupContext,
+            ...message.context
+          }, worker, traces).catch((error) => serializeError(error)));
+          send({
+            type: "testfileFinished",
+            __vitest_worker_response__,
+            error: await runPromise,
+            usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+          });
+        } finally {
+          runPromise = void 0;
+          isRunning = false;
+        }
+        break;
+      case "stop":
+        await runPromise;
+        try {
+          const context = traces.getContextFromCarrier(message.otelCarrier);
+          const error = await traces.$("vitest.runtime.teardown", { context }, async () => {
+            const error = await teardown().catch((error) => serializeError(error));
+            await workerTeardown?.();
+            return error;
+          });
+          await traces.finish();
+          send({
+            type: "stopped",
+            error,
+            __vitest_worker_response__
+          });
+        } catch (error) {
+          send({
+            type: "stopped",
+            error: serializeError(error),
+            __vitest_worker_response__
+          });
+        }
+        worker.teardown?.();
+        break;
+    }
+  }
+}
+function getFilesWithLocations(files) {
+  return files.flatMap((file) => {
+    if (!file.testLocations) return file.filepath;
+    return file.testLocations.map((location) => {
+      return `${file}:${location}`;
+    });
+  });
+}
+
+export { emitModuleRunner as e, init as i, loadEnvironment as l };

package/dist/chunks/inspector.CvyFGlXm.js

@@ -0,0 +1,53 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+const __require = createRequire(import.meta.url);
+let inspector;
+let session;
+/**
+* Enables debugging inside `worker_threads` and `child_process`.
+* Should be called as early as possible when worker/process has been set up.
+*/
+function setupInspect(ctx) {
+  const config = ctx.config;
+  const isEnabled = config.inspector.enabled;
+  if (isEnabled) {
+    inspector = __require("node:inspector");
+    if (!(inspector.url() !== void 0)) {
+      inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
+      if (config.inspectBrk) {
+        const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
+        // Stop at first test file
+        if (firstTestFile) {
+          session = new inspector.Session();
+          session.connect();
+          session.post("Debugger.enable");
+          session.post("Debugger.setBreakpointByUrl", {
+            lineNumber: 0,
+            url: pathToFileURL(firstTestFile)
+          });
+        }
+      }
+    }
+  }
+  const keepOpen = shouldKeepOpen(config);
+  return function cleanup() {
+    if (isEnabled && !keepOpen && inspector) {
+      inspector.close();
+      session?.disconnect();
+    }
+  };
+}
+function closeInspector(config) {
+  const keepOpen = shouldKeepOpen(config);
+  if (inspector && !keepOpen) {
+    inspector.close();
+    session?.disconnect();
+  }
+}
+function shouldKeepOpen(config) {
+  // In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used
+  return config.watch && config.isolate === false && config.maxWorkers === 1;
+}
+
+export { closeInspector as c, setupInspect as s };

package/dist/chunks/modules.BJuCwlRJ.js

@@ -0,0 +1,36 @@
+import { builtinModules } from 'node:module';
+
+// copied from vite
+// https://github.com/vitejs/vite/blob/814120f2ad387ca3d1e16c7dd403b04ca4b97f75/packages/vite/src/node/utils.ts#L106
+// Supported by Node, Deno, Bun
+const NODE_BUILTIN_NAMESPACE = "node:";
+// Supported by Deno
+const NPM_BUILTIN_NAMESPACE = "npm:";
+// Supported by Bun
+const BUN_BUILTIN_NAMESPACE = "bun:";
+// Some runtimes like Bun injects namespaced modules here, which is not a node builtin
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+const { bun: isBun, deno: isDeno } = process.versions;
+// TODO: Use `isBuiltin` from `node:module`, but Deno doesn't support it
+function isBuiltin(id) {
+  if (isDeno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
+  if (isBun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
+  return isNodeBuiltin(id);
+}
+function isNodeBuiltin(id) {
+  if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
+  return nodeBuiltins.includes(id);
+}
+const browserExternalId = "__vite-browser-external";
+const browserExternalLength = 24;
+function isBrowserExternal(id) {
+  return id.startsWith(browserExternalId);
+}
+function toBuiltin(id) {
+  if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
+  if (id.startsWith(NPM_BUILTIN_NAMESPACE) || id.startsWith(BUN_BUILTIN_NAMESPACE) || id.startsWith(NODE_BUILTIN_NAMESPACE)) return id;
+  if (isDeno || isBun) return id;
+  return `node:${id}`;
+}
+
+export { isBrowserExternal as a, isBuiltin as i, toBuiltin as t };

package/dist/chunks/node.Ce0vMQM7.js

@@ -0,0 +1,14 @@
+import { NodeSnapshotEnvironment } from '../@vitest/snapshot/environment.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import '../@vitest/utils/timers.js';
+
+class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
+  getHeader() {
+    return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
+  }
+  resolvePath(filepath) {
+    return getWorkerState().rpc.resolveSnapshotPath(filepath);
+  }
+}
+
+export { VitestNodeSnapshotEnvironment };

package/dist/chunks/plugin.d.CtqpEehP.d.ts

@@ -0,0 +1,38 @@
+import { DevEnvironment } from '@voidzero-dev/vite-plus-core';
+import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.CWXNI2jG.js';
+
+/**
+* Generate a unique cache identifier.
+*
+* Return `false` to disable caching of the file.
+* @experimental
+*/
+interface CacheKeyIdGenerator {
+	(context: CacheKeyIdGeneratorContext): string | undefined | null | false;
+}
+/**
+* @experimental
+*/
+interface CacheKeyIdGeneratorContext {
+	environment: DevEnvironment;
+	id: string;
+	sourceCode: string;
+}
+
+interface VitestPluginContext {
+	vitest: Vitest;
+	project: TestProject;
+	injectTestProjects: (config: TestProjectConfiguration | TestProjectConfiguration[]) => Promise<TestProject[]>;
+	/**
+	* Define a generator that will be applied before hashing the cache key.
+	*
+	* Use this to make sure Vitest generates correct hash. It is a good idea
+	* to define this function if your plugin can be registered with different options.
+	*
+	* This is called only if `experimental.fsModuleCache` is defined.
+	* @experimental
+	*/
+	experimental_defineCacheKeyGenerator: (callback: CacheKeyIdGenerator) => void;
+}
+
+export type { CacheKeyIdGenerator as C, VitestPluginContext as V, CacheKeyIdGeneratorContext as a };