@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/chunks/{base.CJ0Y4ePK.js → base.DM0-RqVb.js}

@@ -1,21 +1,23 @@
 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 { r as resolveTestRunner, a as resolveSnapshotEnvironment, d as detectAsyncLeaks, s as setupChaiConfig } from './index.DGNSnENe.js';
+import { l as loadEnvironment, e as emitModuleRunner, a as listenForErrors } from './init.DICorXCo.js';
+import { N as NativeModuleRunner } from './nativeModuleRunner.BIakptoF.js';
+import { T as Traces } from './traces.CCmnQaNT.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.DEj0jb3e.js';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startVitestModuleRunner.C3ZR-4J3.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 { s as setupCommonEnv, b as startCoverageInsideWorker, c as stopCoverageInsideWorker } from './setup-common.B41N_kPE.js';
+import { g as globalExpect, v as vi } from './test.CTcmp4Su.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';
+import { i as index } from './index.DlDSLQD3.js';
+import { g as getWorkerState, r as resetModules, p as provideWorkerState, a as getSafeWorkerState } from './utils.BX5Fg8C4.js';
 
 // this should only be used in Node
 let globalSetup = false;
@@ -56,7 +58,7 @@ function resolveAsset(mod, url) {
   mod.exports = url;
 }
 async function setupConsoleLogSpy() {
-  const { createCustomConsole } = await import('./console.Cf-YriPC.js');
+  const { createCustomConsole } = await import('./console.3WNpx0tS.js');
   globalThis.console = createCustomConsole();
 }
 
@@ -79,12 +81,16 @@ async function run(method, files, config, moduleRunner, environment, traces) {
   await traces.$(`vitest.test.runner.${method}`, async () => {
     for (const file of files) {
       if (config.isolate) {
-        moduleRunner.mocker.reset();
+        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));
+      if (method === "run") {
+        const collectAsyncLeaks = config.detectAsyncLeaks ? detectAsyncLeaks(file.filepath, workerState.ctx.projectName) : void 0;
+        await traces.$(`vitest.test.runner.${method}.module`, { attributes: { "code.file.path": file.filepath } }, () => startTests([file], testRunner));
+        const leaks = await collectAsyncLeaks?.();
+        if (leaks?.length) workerState.rpc.onAsyncLeaks(leaks);
+      } 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
@@ -97,15 +103,47 @@ async function run(method, files, config, moduleRunner, environment, traces) {
 let _moduleRunner;
 const evaluatedModules = new VitestEvaluatedModules();
 const moduleExecutionInfo = /* @__PURE__ */ new Map();
-function startModuleRunner(options) {
+async function startModuleRunner(options) {
   if (_moduleRunner) return _moduleRunner;
+  process.exit = (code = process.exitCode || 0) => {
+    throw new Error(`process.exit unexpectedly called with "${code}"`);
+  };
+  const state = () => getSafeWorkerState() || options.state;
+  listenForErrors(state);
+  if (options.state.config.experimental.viteModuleRunner === false) {
+    const root = options.state.config.root;
+    let mocker;
+    if (options.state.config.experimental.nodeLoader !== false) {
+      // this additionally imports acorn/magic-string
+      const { NativeModuleMocker } = await import('./nativeModuleMocker.DndvSdL6.js');
+      mocker = new NativeModuleMocker({
+        async resolveId(id, importer) {
+          // TODO: use import.meta.resolve instead
+          return state().rpc.resolve(id, importer, "__vitest__");
+        },
+        root,
+        moduleDirectories: state().config.deps.moduleDirectories || ["/node_modules/"],
+        traces: options.traces || new Traces({ enabled: false }),
+        getCurrentTestFilepath() {
+          return state().filepath;
+        },
+        spyModule
+      });
+    }
+    _moduleRunner = new NativeModuleRunner(root, mocker);
+    return _moduleRunner;
+  }
   _moduleRunner = startVitestModuleRunner(options);
   return _moduleRunner;
 }
 let _currentEnvironment;
 let _environmentTime;
 /** @experimental */
-async function setupEnvironment(context) {
+async function setupBaseEnvironment(context) {
+  if (context.config.experimental.viteModuleRunner === false) {
+    const { setupNodeLoaderHooks } = await import('./native.DPzPHdi5.js');
+    await setupNodeLoaderHooks(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
@@ -118,7 +156,7 @@ async function setupEnvironment(context) {
     throw new Error(`Failed to load custom "defines": ${error.message}`);
   }
   const otel = context.traces;
-  const { environment, loader } = await loadEnvironment(environmentName, config.root, rpc, otel);
+  const { environment, loader } = await loadEnvironment(environmentName, config.root, rpc, otel, context.config.experimental.viteModuleRunner);
   _currentEnvironment = environment;
   const env = await otel.$("vitest.runtime.environment.setup", { attributes: {
     "vitest.environment": environment.name,
@@ -151,7 +189,7 @@ async function runBaseTests(method, state, traces) {
       state.evaluatedModules.invalidateModule(module);
     });
   });
-  const moduleRunner = startModuleRunner({
+  const moduleRunner = await startModuleRunner({
     state,
     evaluatedModules: state.evaluatedModules,
     spyModule,
@@ -162,4 +200,4 @@ async function runBaseTests(method, state, traces) {
   await run(method, ctx.files, ctx.config, moduleRunner, _currentEnvironment, traces);
 }
 
-export { runBaseTests as r, setupEnvironment as s };
+export { runBaseTests as r, setupBaseEnvironment as s };

package/dist/chunks/{benchmark.B3N2zMcH.js → benchmark.D0SlKNbZ.js}

@@ -1,7 +1,7 @@
 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';
+import { g as getWorkerState } from './utils.BX5Fg8C4.js';
 
 const benchFns = /* @__PURE__ */ new WeakMap();
 const benchOptsMap = /* @__PURE__ */ new WeakMap();

package/dist/chunks/{browser.d.ChKACdzH.d.ts → browser.d.X3SXoOCV.d.ts}

@@ -1,6 +1,6 @@
 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';
+import { T as TestExecutionMethod } from './worker.d.B84sVRy0.js';
 
 type SerializedTestSpecification = [project: {
 	name: string | undefined;
@@ -8,6 +8,9 @@ type SerializedTestSpecification = [project: {
 }, file: string, options: {
 	pool: string;
 	testLines?: number[] | undefined;
+	testIds?: string[] | undefined;
+	testNamePattern?: RegExp | undefined;
+	testTagsFilter?: string[] | undefined;
 }];
 
 interface ModuleDefinitionLocation {