@nuxt/test-utils-nightly 3.21.1-20251231-210330-86b4998 → 3.22.0-20251231-210716-73de59a

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

@@ -91,7 +91,6 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         noDiscovery: true
       },
       test: {
-        dir: process.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -188,14 +187,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;

package/dist/e2e.d.mts

@@ -1,5 +1,5 @@
-import { T as TestOptions, a as TestContext, b as TestHooks } from './shared/test-utils-nightly.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-nightly.20kU0tZa.mjs';
+import { T as TestOptions, b as TestContext, a as TestHooks } from './shared/test-utils-nightly.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-nightly.ZByFDqps.mjs';
 import { LogType } from 'consola';
 import 'playwright-core';
 import '@nuxt/schema';

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-nightly.G1ew4kEe.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-nightly.DDUpsMYL.mjs';
+import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
+import 'node:url';
 import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
@@ -325,7 +323,204 @@ const NuxtRootStubPlugin = (options) => {
   };
 };
 
-const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-vue-inspector:post", "vite-plugin-inspect", "nuxt:type-check"];
+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 module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
@@ -351,133 +546,55 @@ const module$1 = defineNuxtModule({
       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;
+    const vitestWrapper2 = createVitestWrapper(options, nuxt);
+    const isDevToolsEnabled = typeof nuxt.options.devtools === "boolean" ? nuxt.options.devtools : nuxt.options.devtools.enabled;
+    if (isDevToolsEnabled) {
+      await setupDevTools(vitestWrapper2, nuxt);
     }
-    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
-      });
-    });
     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-nightly.20kU0tZa.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils-nightly.ZByFDqps.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
 

package/dist/shared/test-utils-nightly.DDUpsMYL.mjs

@@ -0,0 +1,32 @@
+function isMessage(message) {
+  return message !== null && typeof message === "object" && "type" in message && message.type !== null && typeof message.type === "string" && "payload" in message && message.payload !== null && typeof message.payload === "object";
+}
+function createVitestTestSummary() {
+  return {
+    failedCount: 0,
+    passedCount: 0,
+    totalCount: 0
+  };
+}
+function sendMessageToHost(type, payload) {
+  process.send?.({ type, payload });
+}
+function listenHostMessages(listener) {
+  process.on("message", (message) => {
+    if (isMessage(message)) {
+      listener(message);
+    }
+  });
+}
+function sendMessageToCli(cli, type, payload) {
+  cli.send({ type, payload });
+}
+function listenCliMessages(cli, listener) {
+  cli.on("message", (message) => {
+    if (isMessage(message)) {
+      listener(message);
+    }
+  });
+}
+
+export { listenHostMessages as a, sendMessageToHost as b, createVitestTestSummary as c, listenCliMessages as l, sendMessageToCli as s };

package/dist/shared/{test-utils-nightly.20kU0tZa.d.mts → test-utils-nightly.ZByFDqps.d.mts}

@@ -116,4 +116,4 @@ interface TestHooks {
 }
 
 export { $fetch as $, createBrowser as c, createPage as d, stopServer as e, fetch as f, getBrowser as g, startServer as s, url as u, waitForHydration as w };
-export type { GotoOptions as G, NuxtPage as N, StartServerOptions as S, TestOptions as T, TestContext as a, TestHooks as b, TestRunner as h };
+export type { GotoOptions as G, NuxtPage as N, StartServerOptions as S, TestOptions as T, TestHooks as a, TestContext as b, TestRunner as h };

package/dist/vitest-wrapper/cli.d.mts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/vitest-wrapper/cli.mjs

@@ -0,0 +1,78 @@
+import { importModule } from 'local-pkg';
+import { getPort } from 'get-port-please';
+import { a as listenHostMessages, b as sendMessageToHost } from '../shared/test-utils-nightly.DDUpsMYL.mjs';
+
+function createCustomReporter(onVitestInit) {
+  let ctx = void 0;
+  function getVitestUiUrl() {
+    if (!ctx.config.ui) return void 0;
+    const protocol = ctx.vite.config.server.https ? "https:" : "http:";
+    const host = ctx.config.api.host || "localhost";
+    const port = ctx.config.api.port;
+    const uiBase = ctx.config.uiBase;
+    return `${protocol}//${host}:${port}${uiBase}`;
+  }
+  function toUpdatedResult() {
+    const files = ctx.state.getFiles();
+    return {
+      failedCount: files.filter((f) => f.result?.state === "fail").length ?? 0,
+      passedCount: files.filter((f) => f.result?.state === "pass").length ?? 0,
+      totalCount: files.length ?? 0
+    };
+  }
+  function toFinishedResult() {
+    return toUpdatedResult();
+  }
+  return {
+    onInit(_ctx) {
+      ctx = _ctx;
+      onVitestInit(ctx);
+      sendMessageToHost("started", { uiUrl: getVitestUiUrl() });
+    },
+    onTestRunStart() {
+      sendMessageToHost("updated", toUpdatedResult());
+    },
+    onTaskUpdate() {
+      sendMessageToHost("updated", toUpdatedResult());
+    },
+    onFinished() {
+      sendMessageToHost("finished", toFinishedResult());
+    }
+  };
+}
+async function main() {
+  const {
+    apiPorts,
+    watchMode
+  } = await new Promise((resolve) => {
+    listenHostMessages(({ type, payload }) => {
+      if (type === "start") resolve(payload);
+    });
+  });
+  const port = apiPorts ? await getPort({ ports: apiPorts }) : void 0;
+  const { startVitest } = await importModule("vitest/node");
+  const customReporter = createCustomReporter((vitest2) => {
+    listenHostMessages(async ({ type, payload }) => {
+      if (type === "stop") {
+        await vitest2.exit(payload.force);
+        process.exit();
+      }
+    });
+  });
+  const vitest = await startVitest("test", [], watchMode ? {
+    passWithNoTests: true,
+    ui: true,
+    watch: true,
+    open: false,
+    api: { port }
+  } : { ui: false, watch: false }, {
+    test: {
+      reporters: ["default", customReporter]
+    }
+  });
+  if (!watchMode) {
+    await vitest.exit();
+    process.exit();
+  }
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils-nightly",
-  "version": "3.21.1-20251231-210330-86b4998",
+  "version": "3.22.0-20251231-210716-73de59a",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"