@nuxt/test-utils 3.21.0 → 3.22.0

package/README.md

@@ -11,7 +11,7 @@ Nuxt Test Utils is currently powering [the tests we use on Nuxt itself](https://
 You can find out more about how to use Nuxt Test Utils:
 
 - in [a general overview](https://nuxt.com/docs/getting-started/testing)
-- in [an in-depth guide for module authors](https://nuxt.com/docs/guide/going-further/modules#testing)
+- in [an in-depth guide for module authors](https://nuxt.com/docs/4.x/guide/modules/testing)
 
 ## License
 

package/dist/config.d.mts

@@ -1,9 +1,8 @@
-import * as vite from 'vite';
-import { UserConfig } from 'vite';
 import { NuxtConfig, Nuxt } from '@nuxt/schema';
 import { InlineConfig } from 'vitest/node';
 import { TestProjectInlineConfiguration } from 'vitest/config';
 import { DotenvOptions } from 'c12';
+import { UserConfig, UserConfigFnPromise } from 'vite';
 
 interface GetVitestConfigOptions {
     nuxt: Nuxt;
@@ -19,7 +18,7 @@ declare function getVitestConfigFromNuxt(options?: GetVitestConfigOptions, loadN
 declare function defineVitestProject(config: TestProjectInlineConfiguration): Promise<TestProjectInlineConfiguration>;
 declare function defineVitestConfig(config?: UserConfig & {
     test?: InlineConfig;
-}): vite.UserConfigFnPromise;
+}): UserConfigFnPromise;
 interface NuxtEnvironmentOptions {
     rootDir?: string;
     /**

package/dist/config.mjs

@@ -3,12 +3,31 @@ import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
 import { createResolver, findPath } from '@nuxt/kit';
-import { a as applyEnv, l as loadKit } from './shared/test-utils.G1ew4kEe.mjs';
+import { a as applyEnv, l as loadKit } from './shared/test-utils.BIY9XRkB.mjs';
 import 'destr';
 import 'scule';
 import 'node:url';
 import 'exsolve';
 
+const PLUGIN_NAME = "nuxt:vitest:nuxt-environment-options";
+const STUB_ID = "nuxt-vitest-environment-options";
+function NuxtVitestEnvironmentOptionsPlugin(environmentOptions = {}) {
+  return {
+    name: PLUGIN_NAME,
+    enforce: "pre",
+    resolveId(id) {
+      if (id.endsWith(STUB_ID)) {
+        return STUB_ID;
+      }
+    },
+    load(id) {
+      if (id.endsWith(STUB_ID)) {
+        return `export default ${JSON.stringify(environmentOptions || {})}`;
+      }
+    }
+  };
+}
+
 async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {}) {
   const { buildNuxt, loadNuxt } = await loadKit(rootDir);
   const nuxt = await loadNuxt({
@@ -73,6 +92,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
       }
     });
   }
+  delete options.viteConfig.root;
   options.viteConfig.plugins = (options.viteConfig.plugins || []).filter((p) => !p || !("name" in p) || !excludedPlugins.includes(p.name));
   const resolver = createResolver(import.meta.url);
   const resolvedConfig = defu(
@@ -91,7 +111,6 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         noDiscovery: true
       },
       test: {
-        dir: process.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -188,14 +207,12 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   return resolvedConfig;
 }
 async function defineVitestProject(config) {
-  if (process.env.__NUXT_VITEST_RESOLVED__) return config;
   const resolvedConfig = await resolveConfig(config);
   resolvedConfig.test.environment = "nuxt";
   return resolvedConfig;
 }
 function defineVitestConfig(config = {}) {
   return defineConfig(async () => {
-    if (process.env.__NUXT_VITEST_RESOLVED__) return config;
     const resolvedConfig = await resolveConfig(config);
     if (resolvedConfig.test.browser?.enabled) {
       return resolvedConfig;
@@ -256,22 +273,7 @@ async function resolveConfig(config) {
       overrides: structuredClone(overrides)
     })
   );
-  const PLUGIN_NAME = "nuxt:vitest:nuxt-environment-options";
-  const STUB_ID = "nuxt-vitest-environment-options";
-  resolvedConfig.plugins.push({
-    name: PLUGIN_NAME,
-    enforce: "pre",
-    resolveId(id) {
-      if (id.endsWith(STUB_ID)) {
-        return STUB_ID;
-      }
-    },
-    load(id) {
-      if (id.endsWith(STUB_ID)) {
-        return `export default ${JSON.stringify(resolvedConfig.test.environmentOptions || {})}`;
-      }
-    }
-  });
+  resolvedConfig.plugins.push(NuxtVitestEnvironmentOptionsPlugin(resolvedConfig.test.environmentOptions));
   if (resolvedConfig.test.browser?.enabled) {
     if (resolvedConfig.test.environment === "nuxt") {
       resolvedConfig.test.setupFiles = Array.isArray(resolvedConfig.test.setupFiles) ? resolvedConfig.test.setupFiles : [resolvedConfig.test.setupFiles].filter(Boolean);

package/dist/e2e.d.mts

@@ -1,5 +1,5 @@
-import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils.20kU0tZa.mjs';
-export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils.20kU0tZa.mjs';
+import { T as TestOptions, b as TestContext, a as TestHooks } from './shared/test-utils.ZByFDqps.mjs';
+export { $ as $fetch, G as GotoOptions, N as NuxtPage, S as StartServerOptions, h as TestRunner, c as createBrowser, d as createPage, f as fetch, g as getBrowser, s as startServer, e as stopServer, u as url, w as waitForHydration } from './shared/test-utils.ZByFDqps.mjs';
 import { LogType } from 'consola';
 import 'playwright-core';
 import '@nuxt/schema';

package/dist/e2e.mjs

@@ -1,13 +1,13 @@
-export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.3NR-so9-.mjs';
-import { u as useTestContext } from './shared/test-utils.CtwoJP76.mjs';
-export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.CtwoJP76.mjs';
+export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.D2ZzXztg.mjs';
+import { u as useTestContext } from './shared/test-utils.C_clWQBc.mjs';
+export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.C_clWQBc.mjs';
 import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { distDir } from '#dirs';
 import 'node:fs';
 import 'node:path';
 import 'defu';
-import './shared/test-utils.G1ew4kEe.mjs';
+import './shared/test-utils.BIY9XRkB.mjs';
 import 'destr';
 import 'scule';
 import 'node:url';
@@ -52,8 +52,10 @@ async function runTests(opts) {
     {
       root: opts.rootDir,
       run: !opts.watch,
-      deps: {
-        inline: [/@nuxt\/test-utils/]
+      server: {
+        deps: {
+          inline: [/@nuxt\/test-utils/]
+        }
       }
     },
     // Vite options
@@ -63,13 +65,15 @@ async function runTests(opts) {
       },
       test: {
         dir: opts.rootDir,
-        deps: {
-          inline: [
-            distDir,
-            "@nuxt/test-utils",
-            "@nuxt/test-utils-nightly",
-            "@nuxt/test-utils-edge"
-          ]
+        server: {
+          deps: {
+            inline: [
+              distDir,
+              "@nuxt/test-utils",
+              "@nuxt/test-utils-nightly",
+              "@nuxt/test-utils-edge"
+            ]
+          }
         },
         globals: true,
         globalSetup: [

package/dist/experimental.mjs

@@ -1,6 +1,6 @@
 import { resolve } from 'pathe';
 import { stringifyQuery } from 'ufo';
-import { $ as $fetch, u as useTestContext } from './shared/test-utils.CtwoJP76.mjs';
+import { $ as $fetch, u as useTestContext } from './shared/test-utils.C_clWQBc.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/module.mjs

@@ -1,22 +1,20 @@
-import { pathToFileURL } from 'node:url';
-import { resolveIgnorePatterns, defineNuxtModule, createResolver, resolvePath, importModule, logger } from '@nuxt/kit';
-import { getPort } from 'get-port-please';
-import { h } from 'vue';
-import { debounce } from 'perfect-debounce';
-import { isCI } from 'std-env';
-import { defu } from 'defu';
-import { extname, join, dirname, relative } from 'pathe';
-import { getVitestConfigFromNuxt } from './config.mjs';
+import { resolveIgnorePatterns, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath, logger } from '@nuxt/kit';
+import { extname, join, dirname, resolve, relative } from 'pathe';
+import { provider, isCI } from 'std-env';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
-import { l as loadKit } from './shared/test-utils.G1ew4kEe.mjs';
+import { l as loadKit } from './shared/test-utils.BIY9XRkB.mjs';
 import { readFileSync } from 'node:fs';
-import 'node:process';
-import 'vite';
-import 'c12';
+import { h } from 'vue';
+import { defineEventHandler } from 'h3';
+import { debounce } from 'perfect-debounce';
+import { fork } from 'node:child_process';
+import { c as createVitestTestSummary, l as listenCliMessages, s as sendMessageToCli } from './shared/test-utils.DDUpsMYL.mjs';
+import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
+import 'node:url';
 import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
@@ -297,28 +295,232 @@ async function setupImportMocking(nuxt) {
 
 const PLUGIN_NAME = "nuxt:vitest:nuxt-root-stub";
 const STUB_ID = "nuxt-vitest-app-entry";
-const NuxtRootStubPlugin = createUnplugin((options) => {
-  const STUB_ID_WITH_EXT = STUB_ID + extname(options.entry);
+const NuxtRootStubPlugin = (options) => {
+  const extension = extname(options.entry);
+  const escapedExt = extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const entryPath = join(dirname(options.entry), STUB_ID + extension);
+  const idFilter = new RegExp(`${STUB_ID}(?:${escapedExt})?$`);
   return {
     name: PLUGIN_NAME,
     enforce: "pre",
-    vite: {
-      async resolveId(id, importer) {
-        if (id.endsWith(STUB_ID) || id.endsWith(STUB_ID_WITH_EXT)) {
-          return importer?.endsWith("index.html") ? id : join(dirname(options.entry), STUB_ID_WITH_EXT);
-        }
+    resolveId: {
+      filter: {
+        id: idFilter
+      },
+      async handler(id, importer) {
+        return importer?.endsWith("index.html") ? id : entryPath;
+      }
+    },
+    load: {
+      filter: {
+        id: idFilter
       },
-      async load(id) {
-        if (id.endsWith(STUB_ID) || id.endsWith(STUB_ID_WITH_EXT)) {
-          const entryContents = readFileSync(options.entry, "utf-8");
-          return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+      async handler() {
+        const entryContents = readFileSync(options.entry, "utf-8");
+        return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+      }
+    }
+  };
+};
+
+async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
+  const iframeSrc = "/__test_utils_vitest__/";
+  const updateTabs = debounce(() => {
+    nuxt.callHook("devtools:customTabs:refresh");
+  }, 100);
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    const tab = createVitestCustomTab(vitestWrapper, { iframeSrc });
+    const index = tabs.findIndex(({ name }) => tab.name === name);
+    if (index === -1) {
+      tabs.push(tab);
+    } else {
+      tabs.splice(index, 1, tab);
+    }
+  });
+  addDevServerHandler({
+    route: iframeSrc,
+    handler: defineEventHandler(
+      () => iframeContentHtml(vitestWrapper.uiUrl)
+    )
+  });
+  vitestWrapper.ons({
+    started() {
+      updateTabs();
+    },
+    updated() {
+      updateTabs();
+    },
+    finished() {
+      updateTabs();
+    },
+    exited() {
+      updateTabs();
+    }
+  });
+}
+function createVitestCustomTab(vitest, { iframeSrc }) {
+  const launchView = {
+    type: "launch",
+    description: "Start tests along with Nuxt",
+    actions: [
+      {
+        get label() {
+          switch (vitest.status) {
+            case "starting":
+              return "Starting...";
+            case "running":
+              return "Running Vitest";
+            case "stopped":
+              return "Start Vitest";
+            case "finished":
+              return "Start Vitest";
+          }
+        },
+        get pending() {
+          return vitest.status === "starting" || vitest.status === "running";
+        },
+        handle: () => {
+          vitest.start();
         }
       }
+    ]
+  };
+  const uiView = {
+    type: "iframe",
+    persistent: false,
+    src: iframeSrc
+  };
+  const tab = {
+    title: "Vitest",
+    name: "vitest",
+    icon: "logos-vitest",
+    get view() {
+      if (vitest.status === "stopped" || vitest.status === "starting" || !vitest.uiUrl) {
+        return launchView;
+      } else {
+        return uiView;
+      }
+    },
+    extraTabVNode: vitest.testSummary.totalCount ? h("div", { style: { color: vitest.testSummary.failedCount ? "orange" : "green" } }, [
+      h("span", {}, vitest.testSummary.passedCount),
+      h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
+      h(
+        "span",
+        { style: { opacity: "0.8", fontSize: "0.9em" } },
+        vitest.testSummary.totalCount
+      )
+    ]) : void 0
+  };
+  return tab;
+}
+function iframeContentHtml(uiUrl) {
+  return [
+    "<html><head><script>",
+    `(${function redirect(uiUrl2, provider2) {
+      if (typeof window === "undefined") return;
+      if (!uiUrl2) return;
+      if (provider2 === "stackblitz") {
+        const url = new URL(window.location.href);
+        const newUrl = new URL(uiUrl2);
+        newUrl.host = url.host.replace(/--\d+--/, `--${newUrl.port}--`);
+        newUrl.protocol = url.protocol;
+        newUrl.port = url.port;
+        uiUrl2 = newUrl.toString();
+      }
+      window.location.replace(uiUrl2);
+    }})(${JSON.stringify(uiUrl)}, ${JSON.stringify(provider)})`,
+    "<\/script></head></html>"
+  ].join("\n");
+}
+
+function vitestWrapper(options) {
+  const { cwd, ...startOptions } = options;
+  let _status = "stopped";
+  let _uiUrl;
+  let _process;
+  let _testSummary = createVitestTestSummary();
+  const _handlers = {
+    started: [({ uiUrl }) => {
+      _uiUrl = uiUrl;
+      _status = "running";
+      _testSummary = createVitestTestSummary();
+    }],
+    updated: [(summary) => {
+      _testSummary = summary;
+    }],
+    finished: [(summary) => {
+      _status = "finished";
+      _testSummary = summary;
+    }],
+    exited: [clear]
+  };
+  function clear() {
+    _status = "stopped";
+    _uiUrl = void 0;
+    _process = void 0;
+    _testSummary = createVitestTestSummary();
+  }
+  function on(name, handler) {
+    _handlers[name] ??= [];
+    _handlers[name]?.push(handler);
+  }
+  function ons(handlers) {
+    for (const [name, handler] of Object.entries(handlers)) {
+      if (typeof handler === "function") {
+        on(name, handler);
+      }
+    }
+  }
+  async function stop() {
+    const vitest = _process;
+    if (!vitest || vitest.exitCode !== null) return;
+    return new Promise((resolve2) => {
+      vitest.once("exit", () => resolve2());
+      sendMessageToCli(vitest, "stop", { force: true });
+    });
+  }
+  async function start() {
+    if (_process) return false;
+    const vitest = fork(resolve(distDir, "./vitest-wrapper/cli.mjs"), {
+      cwd,
+      env: {
+        ...process.env,
+        NODE_ENV: "test",
+        MODE: "test"
+      },
+      stdio: startOptions.logToConsole ? void 0 : ["ignore", "ignore", "inherit", "ipc"]
+    });
+    _status = "starting";
+    _process = vitest;
+    vitest.once("exit", () => {
+      _handlers.exited.forEach((fn) => fn({ exitCode: vitest.exitCode ?? 0 }));
+    });
+    listenCliMessages(vitest, ({ type, payload }) => {
+      _handlers[type].forEach((fn) => fn(payload));
+    });
+    sendMessageToCli(vitest, "start", startOptions);
+    return true;
+  }
+  return {
+    on,
+    ons,
+    stop,
+    start,
+    get uiUrl() {
+      return _uiUrl;
+    },
+    get options() {
+      return options;
+    },
+    get status() {
+      return _status;
+    },
+    get testSummary() {
+      return { ..._testSummary };
     }
   };
-});
+}
 
-const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-vue-inspector:post", "vite-plugin-inspect", "nuxt:type-check"];
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
@@ -334,141 +536,64 @@ const module$1 = defineNuxtModule({
     }
     const { addVitePlugin } = await loadKit(nuxt.options.rootDir);
     const resolver = createResolver(import.meta.url);
-    addVitePlugin(NuxtRootStubPlugin.vite({
-      entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
-      rootStubPath: await resolvePath(resolver.resolve("./runtime/nuxt-root"))
-    }));
+    if (nuxt.options.test || nuxt.options.dev) {
+      addVitePlugin(NuxtRootStubPlugin({
+        entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
+        rootStubPath: await resolvePath(resolver.resolve("./runtime/nuxt-root"))
+      }));
+    }
     if (!nuxt.options.test && !nuxt.options.dev) {
       nuxt.options.vite.define ||= {};
       nuxt.options.vite.define["import.meta.vitest"] = "undefined";
     }
-    nuxt.hook("prepare:types", (ctx2) => {
-      ctx2.references.push({ types: "vitest/import-meta" });
-      if (ctx2.nodeTsConfig) {
-        ctx2.nodeTsConfig.include ||= [];
-        ctx2.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
+    nuxt.hook("prepare:types", (ctx) => {
+      ctx.references.push({ types: "vitest/import-meta" });
+      if (ctx.nodeTsConfig) {
+        ctx.nodeTsConfig.include ||= [];
+        ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
         if (nuxt.options.workspaceDir !== nuxt.options.rootDir) {
-          ctx2.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
+          ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.workspaceDir, "vitest.config.*")));
         }
       }
     });
     if (!nuxt.options.dev) return;
     if (process.env.TEST || process.env.VITE_TEST) return;
-    const rawViteConfigPromise = new Promise((resolve) => {
-      nuxt.hook("app:resolve", () => {
-        nuxt.hook("vite:configResolved", (config, { isClient }) => {
-          if (isClient) resolve(config);
-        });
-      });
-    });
-    let loaded = false;
-    let promise;
-    let ctx = void 0;
-    let testFiles = null;
-    const updateTabs = debounce(() => {
-      nuxt.callHook("devtools:customTabs:refresh");
-    }, 100);
-    let URL;
-    async function start() {
-      const { mergeConfig } = await importModule("vite", { paths: nuxt.options.modulesDir });
-      const rawViteConfig = mergeConfig({}, await rawViteConfigPromise);
-      const viteConfig = await getVitestConfigFromNuxt({ nuxt, viteConfig: defu({ test: options.vitestConfig }, rawViteConfig) });
-      viteConfig.plugins = (viteConfig.plugins || []).filter((p) => {
-        return !p || !("name" in p) || !vitePluginBlocklist.includes(p.name);
-      });
-      viteConfig.test.environmentMatchGlobs ||= [];
-      viteConfig.test.environmentMatchGlobs.push(
-        ["**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "nuxt"],
-        ["{test,tests}/nuxt/**.*", "nuxt"]
-      );
-      process.env.__NUXT_VITEST_RESOLVED__ = "true";
-      const { startVitest } = await import(pathToFileURL(await resolvePath("vitest/node")).href);
-      const customReporter = {
-        onInit(_ctx) {
-          ctx = _ctx;
-        },
-        onTaskUpdate() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        },
-        onFinished() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        }
-      };
-      const watchMode = !process.env.NUXT_VITEST_DEV_TEST && !isCI;
-      const PORT = await getPort({ port: 15555 });
-      const PROTOCOL = nuxt.options.devServer.https ? "https" : "http";
-      URL = `${PROTOCOL}://localhost:${PORT}/__vitest__/`;
-      const overrides = watchMode ? {
-        passWithNoTests: true,
-        reporters: options.logToConsole ? [
-          ...toArray(options.vitestConfig?.reporters ?? ["default"]),
-          customReporter
-        ] : [customReporter],
-        // do not report to console
-        watch: true,
-        ui: true,
-        open: false,
-        api: {
-          port: PORT
-        }
-      } : { watch: false };
-      const promise2 = startVitest("test", [], defu(overrides, viteConfig.test), viteConfig);
-      promise2.catch(() => process.exit(1));
-      if (watchMode) {
-        logger.info(`Vitest UI starting on ${URL}`);
-        nuxt.hook("close", () => promise2.then((v) => v?.close()));
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      } else {
-        promise2.then((v) => nuxt.close().then(() => v?.close()).then(() => process.exit()));
-      }
-      loaded = true;
-    }
-    nuxt.hook("devtools:customTabs", (tabs) => {
-      const failedCount = testFiles?.filter((f) => f.result?.state === "fail").length ?? 0;
-      const passedCount = testFiles?.filter((f) => f.result?.state === "pass").length ?? 0;
-      const totalCount = testFiles?.length ?? 0;
-      tabs.push({
-        title: "Vitest",
-        name: "vitest",
-        icon: "logos-vitest",
-        view: loaded ? {
-          type: "iframe",
-          src: URL
-        } : {
-          type: "launch",
-          description: "Start tests along with Nuxt",
-          actions: [
-            {
-              label: promise ? "Starting..." : "Start Vitest",
-              pending: !!promise,
-              handle: () => {
-                promise = promise || start();
-                return promise;
-              }
-            }
-          ]
-        },
-        extraTabVNode: totalCount ? h("div", { style: { color: failedCount ? "orange" : "green" } }, [
-          h("span", {}, passedCount),
-          h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
-          h(
-            "span",
-            { style: { opacity: "0.8", fontSize: "0.9em" } },
-            totalCount
-          )
-        ]) : void 0
-      });
+    const vitestWrapper2 = createVitestWrapper(options, nuxt);
+    nuxt.hook("devtools:before", async () => {
+      await setupDevTools(vitestWrapper2, nuxt);
     });
     if (options.startOnBoot) {
-      promise = promise || start();
-      promise.then(updateTabs);
+      vitestWrapper2.start();
     }
   }
 });
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
+function createVitestWrapper(options, nuxt = useNuxt()) {
+  const watchMode = !isCI;
+  const wrapper = vitestWrapper({
+    cwd: nuxt.options.rootDir,
+    apiPorts: [15555],
+    logToConsole: options.logToConsole ?? false,
+    watchMode
+  });
+  wrapper.ons({
+    started({ uiUrl }) {
+      if (watchMode) {
+        logger.info(`Vitest UI starting on ${uiUrl}`);
+      }
+    },
+    exited({ exitCode }) {
+      if (watchMode) {
+        logger.info(`Vitest exited with code ${exitCode}`);
+      } else {
+        nuxt.close().finally(() => process.exit(exitCode));
+      }
+    }
+  });
+  nuxt.hooks.addHooks({
+    close: () => wrapper.stop(),
+    restart: () => wrapper.stop()
+  });
+  return wrapper;
 }
 
 export { module$1 as default };

package/dist/playwright.d.mts

@@ -1,7 +1,7 @@
 import * as _playwright_test from '@playwright/test';
 export { expect } from '@playwright/test';
 import { Response } from 'playwright-core';
-import { T as TestOptions$1, G as GotoOptions, b as TestHooks } from './shared/test-utils.20kU0tZa.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.ZByFDqps.mjs';
 import '@nuxt/schema';
 import 'tinyexec';