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

package/dist/chunks/{index.C5r1PdPD.js → index.CEzQDJGb.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '../@vitest/runner/utils.js';
 import * as pathe from '../vendor/pathe.mjs';
 import c from '../vendor/tinyrainbow.mjs';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.M8mOzt4Y.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.DXMFO5MJ.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '../@vitest/utils/helpers.js';
 

package/dist/chunks/{index.D3XRDfWc.js → index.CMESou6r.js}

@@ -209,5 +209,30 @@ async function installPackage(names, options = {}) {
     }
   );
 }
+async function uninstallPackage(names, options = {}) {
+  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
+  const [agent] = detectedAgent.split("@");
+  if (!Array.isArray(names))
+    names = [names];
+  const args = options.additionalArgs || [];
+  if (agent === "pnpm" && existsSync(resolve(options.cwd ?? process.cwd(), "pnpm-workspace.yaml")))
+    args.unshift("-w");
+  return x(
+    agent,
+    [
+      agent === "yarn" ? "remove" : "uninstall",
+      options.dev ? "-D" : "",
+      ...args,
+      ...names
+    ].filter(Boolean),
+    {
+      nodeOptions: {
+        stdio: options.silent ? "ignore" : "inherit",
+        cwd: options.cwd
+      },
+      throwOnError: true
+    }
+  );
+}
 
-export { detectPackageManager, installPackage };
+export { detectPackageManager, installPackage, uninstallPackage };

package/dist/chunks/{index.6Qv1eEA6.js → index.DGNSnENe.js}

@@ -1,25 +1,99 @@
 import { chai } from '../@vitest/expect/index.js';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Cm-kSBVi.js';
-import { r as rpc } from './rpc.BoxB0q7B.js';
-import { g as getWorkerState } from './utils.DvEY5TfP.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.B8ej_ZHS.js';
+import { createHook } from 'node:async_hooks';
+import { l as loadDiffConfig, a as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.B41N_kPE.js';
+import { r as rpc } from './rpc.MzXet3jl.js';
+import { g as getWorkerState } from './utils.BX5Fg8C4.js';
+import { T as TestRunner, N as NodeBenchmarkRunner } from './test.CTcmp4Su.js';
 
 function setupChaiConfig(config) {
   Object.assign(chai.config, config);
 }
 
-async function resolveSnapshotEnvironment(config, executor) {
+async function resolveSnapshotEnvironment(config, moduleRunner) {
   if (!config.snapshotEnvironment) {
-    const { VitestNodeSnapshotEnvironment } = await import('./node.Ce0vMQM7.js');
+    const { VitestNodeSnapshotEnvironment } = await import('./node.COQbm6gK.js');
     return new VitestNodeSnapshotEnvironment();
   }
-  const mod = await executor.import(config.snapshotEnvironment);
+  const mod = await moduleRunner.import(config.snapshotEnvironment);
   if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
   return mod.default;
 }
 
+const IGNORED_TYPES = new Set([
+  "DNSCHANNEL",
+  "ELDHISTOGRAM",
+  "PerformanceObserver",
+  "RANDOMBYTESREQUEST",
+  "SIGNREQUEST",
+  "STREAM_END_OF_STREAM",
+  "TCPWRAP",
+  "TIMERWRAP",
+  "TLSWRAP",
+  "ZLIB"
+]);
+function detectAsyncLeaks(testFile, projectName) {
+  const resources = /* @__PURE__ */ new Map();
+  const hook = createHook({
+    init(asyncId, type, triggerAsyncId, resource) {
+      if (IGNORED_TYPES.has(type)) return;
+      let stack = "";
+      const limit = Error.stackTraceLimit;
+      // VitestModuleEvaluator's async wrapper of node:vm causes out-of-bound stack traces, simply skip it.
+      // Crash fixed in https://github.com/vitejs/vite/pull/21585
+      try {
+        Error.stackTraceLimit = 100;
+        stack = (/* @__PURE__ */ new Error("VITEST_DETECT_ASYNC_LEAKS")).stack || "";
+      } catch {
+        return;
+      } finally {
+        Error.stackTraceLimit = limit;
+      }
+      if (!stack.includes(testFile)) {
+        const trigger = resources.get(triggerAsyncId);
+        if (!trigger) return;
+        stack = trigger.stack;
+      }
+      let isActive = isActiveDefault;
+      if ("hasRef" in resource) {
+        const ref = new WeakRef(resource);
+        isActive = () => ref.deref()?.hasRef() ?? false;
+      }
+      resources.set(asyncId, {
+        type,
+        stack,
+        projectName,
+        filename: testFile,
+        isActive
+      });
+    },
+    destroy(asyncId) {
+      if (resources.get(asyncId)?.type !== "PROMISE") resources.delete(asyncId);
+    },
+    promiseResolve(asyncId) {
+      resources.delete(asyncId);
+    }
+  });
+  hook.enable();
+  return async function collect() {
+    await Promise.resolve(setImmediate);
+    hook.disable();
+    const leaks = [];
+    for (const resource of resources.values()) if (resource.isActive()) leaks.push({
+      stack: resource.stack,
+      type: resource.type,
+      filename: resource.filename,
+      projectName: resource.projectName
+    });
+    resources.clear();
+    return leaks;
+  };
+}
+function isActiveDefault() {
+  return true;
+}
+
 async function getTestRunnerConstructor(config, moduleRunner) {
-  if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+  if (!config.runner) return config.mode === "test" ? TestRunner : NodeBenchmarkRunner;
   const mod = await moduleRunner.import(config.runner);
   if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
   return mod.default;
@@ -78,6 +152,18 @@ async function resolveTestRunner(config, moduleRunner, traces) {
       state.durations.prepare = 0;
       state.durations.environment = 0;
     });
+    // Strip function conditions from retry config before sending via RPC
+    // Functions cannot be cloned by structured clone algorithm
+    const sanitizeRetryConditions = (task) => {
+      if (task.retry && typeof task.retry === "object" && typeof task.retry.condition === "function")
+ // Remove function condition - it can't be serialized
+      task.retry = {
+        ...task.retry,
+        condition: void 0
+      };
+      if (task.tasks) task.tasks.forEach(sanitizeRetryConditions);
+    };
+    files.forEach(sanitizeRetryConditions);
     rpc().onCollected(files);
     await originalOnCollected?.call(testRunner, files);
   };
@@ -106,4 +192,4 @@ async function resolveTestRunner(config, moduleRunner, traces) {
   return testRunner;
 }
 
-export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };
+export { resolveSnapshotEnvironment as a, detectAsyncLeaks as d, resolveTestRunner as r, setupChaiConfig as s };