@nuxt/test-utils 3.18.0 → 3.19.1

package/dist/config.d.mts

@@ -1,23 +1,25 @@
 import * as vite from 'vite';
-import { InlineConfig } from 'vite';
+import { UserConfig } from 'vite';
 import { NuxtConfig, Nuxt } from '@nuxt/schema';
-import { InlineConfig as InlineConfig$1 } from 'vitest/node';
+import { InlineConfig } from 'vitest/node';
+import { TestProjectInlineConfiguration } from 'vitest/config';
 import { DotenvOptions } from 'c12';
 
 interface GetVitestConfigOptions {
     nuxt: Nuxt;
-    viteConfig: InlineConfig;
+    viteConfig: UserConfig;
 }
 interface LoadNuxtOptions {
     dotenv?: Partial<DotenvOptions>;
     overrides?: Partial<NuxtConfig>;
 }
-declare function getVitestConfigFromNuxt(options?: GetVitestConfigOptions, loadNuxtOptions?: LoadNuxtOptions): Promise<InlineConfig & {
-    test: InlineConfig$1;
+declare function getVitestConfigFromNuxt(options?: GetVitestConfigOptions, loadNuxtOptions?: LoadNuxtOptions): Promise<UserConfig & {
+    test: InlineConfig;
 }>;
-declare function defineVitestConfig(config?: InlineConfig & {
-    test?: InlineConfig$1;
-}): vite.UserConfig & Promise<vite.UserConfig> & vite.UserConfigFnObject & vite.UserConfigFnPromise & vite.UserConfigFn;
+declare function defineVitestProject(config: TestProjectInlineConfiguration): Promise<TestProjectInlineConfiguration>;
+declare function defineVitestConfig(config?: UserConfig & {
+    test?: InlineConfig;
+}): vite.UserConfigFnPromise;
 interface NuxtEnvironmentOptions {
     rootDir?: string;
     /**
@@ -61,4 +63,5 @@ declare module 'vitest' {
     }
 }
 
-export { defineVitestConfig, getVitestConfigFromNuxt };
+export { defineVitestConfig, defineVitestProject, getVitestConfigFromNuxt };
+export type { NuxtEnvironmentOptions };

package/dist/config.mjs

@@ -1,7 +1,8 @@
+import process$1 from 'node:process';
 import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
-import { createResolver, findPath } from '@nuxt/kit';
+import { createResolver, findPath, loadNuxt, buildNuxt } from '@nuxt/kit';
 import destr from 'destr';
 import { snakeCase } from 'scule';
 
@@ -35,8 +36,7 @@ function applyEnv(obj, opts, parentKey = "") {
   return obj;
 }
 
-async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {}) {
-  const { loadNuxt, buildNuxt } = await import('@nuxt/kit');
+async function startNuxtAndGetViteConfig(rootDir = process$1.cwd(), options = {}) {
   const nuxt = await loadNuxt({
     cwd: rootDir,
     dev: false,
@@ -82,10 +82,14 @@ async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {})
 const excludedPlugins = [
   "nuxt:import-protection",
   "nuxt:import-conditions",
-  "vite-plugin-checker"
+  "nuxt:devtools:rpc",
+  "nuxt:devtools:config-retriever",
+  "vite-plugin-checker",
+  "vite-plugin-inspect",
+  "vite-plugin-vue-tracer"
 ];
 async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
-  const { rootDir = process.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
+  const { rootDir = process$1.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
   if (!options) {
     options = await startNuxtAndGetViteConfig(rootDir, {
       dotenv: loadNuxtOptions.dotenv,
@@ -96,14 +100,24 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
     });
   }
   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(
     // overrides
     {
       define: {
         "process.env.NODE_ENV": '"test"'
       },
+      resolve: {
+        alias: {
+          "@vue/devtools-kit": resolver.resolve("./runtime/mocks/vue-devtools"),
+          "@vue/devtools-core": resolver.resolve("./runtime/mocks/vue-devtools")
+        }
+      },
+      optimizeDeps: {
+        noDiscovery: true
+      },
       test: {
-        dir: process.cwd(),
+        dir: process$1.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -118,10 +132,6 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
             options.nuxt.options.nitro?.routeRules
           )
         },
-        environmentMatchGlobs: [
-          ["**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "nuxt"],
-          ["{test,tests}/nuxt/**.*", "nuxt"]
-        ],
         server: {
           deps: {
             inline: [
@@ -152,6 +162,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
       server: { middlewareMode: false },
       plugins: [
         {
+          // TODO: prefix with 'nuxt:test-utils:' in next major version
           name: "disable-auto-execute",
           enforce: "pre",
           transform(code, id) {
@@ -162,6 +173,17 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
               );
             }
           }
+        },
+        {
+          name: "nuxt:test-utils:browser-conditions",
+          enforce: "pre",
+          config() {
+            return {
+              resolve: {
+                conditions: ["web", "import", "module", "default"]
+              }
+            };
+          }
         }
       ]
     },
@@ -187,27 +209,84 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   if (!Array.isArray(resolvedConfig.test.setupFiles)) {
     resolvedConfig.test.setupFiles = [resolvedConfig.test.setupFiles].filter(Boolean);
   }
-  const resolver = createResolver(import.meta.url);
   const entryPath = resolver.resolve("./runtime/entry");
   resolvedConfig.test.setupFiles.unshift(await findPath(entryPath) ?? entryPath);
   return resolvedConfig;
 }
+async function defineVitestProject(config) {
+  if (process$1.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 overrides = config.test?.environmentOptions?.nuxt?.overrides || {};
-    overrides.rootDir = config.test?.environmentOptions?.nuxt?.rootDir;
-    if (config.test?.setupFiles && !Array.isArray(config.test.setupFiles)) {
-      config.test.setupFiles = [config.test.setupFiles].filter(Boolean);
+    if (process$1.env.__NUXT_VITEST_RESOLVED__) return config;
+    const resolvedConfig = await resolveConfig(config);
+    if (resolvedConfig.test.browser?.enabled) {
+      return resolvedConfig;
     }
-    return defu(
-      config,
-      await getVitestConfigFromNuxt(void 0, {
-        dotenv: config.test?.environmentOptions?.nuxt?.dotenv,
-        overrides: structuredClone(overrides)
-      })
-    );
+    if ("workspace" in resolvedConfig.test) {
+      throw new Error(
+        "The `workspace` option is not supported with `defineVitestConfig`. Instead, use `defineVitestProject` to define each workspace project that uses the Nuxt environment."
+      );
+    }
+    const defaultEnvironment = resolvedConfig.test.environment || "node";
+    if (defaultEnvironment !== "nuxt") {
+      resolvedConfig.test.workspace = [];
+      resolvedConfig.test.workspace.push({
+        extends: true,
+        test: {
+          name: "nuxt",
+          environment: "nuxt",
+          include: [
+            "**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+            "{test,tests}/nuxt/**.*"
+          ]
+        }
+      });
+    }
+    return resolvedConfig;
   });
 }
+async function resolveConfig(config) {
+  const overrides = config.test?.environmentOptions?.nuxt?.overrides || {};
+  overrides.rootDir = config.test?.environmentOptions?.nuxt?.rootDir;
+  if (config.test?.setupFiles && !Array.isArray(config.test.setupFiles)) {
+    config.test.setupFiles = [config.test.setupFiles].filter(Boolean);
+  }
+  const resolvedConfig = defu(
+    config,
+    await getVitestConfigFromNuxt(void 0, {
+      dotenv: config.test?.environmentOptions?.nuxt?.dotenv,
+      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 || {})}`;
+      }
+    }
+  });
+  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);
+      const resolver = createResolver(import.meta.url);
+      const browserEntry = await findPath(resolver.resolve("./runtime/browser-entry")) || resolver.resolve("./runtime/browser-entry");
+      resolvedConfig.test.setupFiles.unshift(browserEntry);
+    }
+  }
+  return resolvedConfig;
+}
 
-export { defineVitestConfig, getVitestConfigFromNuxt };
+export { defineVitestConfig, defineVitestProject, getVitestConfigFromNuxt };

package/dist/module.mjs

@@ -12,6 +12,7 @@ import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
 import { readFileSync } from 'node:fs';
 import { extname, join, dirname } from 'pathe';
+import 'node:process';
 import 'c12';
 import 'destr';
 import 'scule';
@@ -364,6 +365,11 @@ const module = defineNuxtModule({
       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 = {

package/dist/runtime/browser-entry.d.ts

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

package/dist/runtime/browser-entry.mjs

@@ -0,0 +1,8 @@
+import environmentOptions from "nuxt-vitest-environment-options";
+import { setupNuxt } from "./shared/nuxt.mjs";
+import { setupWindow } from "./shared/environment.mjs";
+const el = document.querySelector(environmentOptions.nuxt.rootId || "nuxt-test");
+if (!el) {
+  await setupWindow(window, environmentOptions);
+  await setupNuxt();
+}

package/dist/runtime/entry.mjs

@@ -1,10 +1,7 @@
 import { vi } from "vitest";
+import { setupNuxt } from "./shared/nuxt.mjs";
 if (typeof window !== "undefined" && window.__NUXT_VITEST_ENVIRONMENT__) {
-  const { useRouter } = await import("#app/composables/router");
-  await import("#app/nuxt-vitest-app-entry").then((r) => r.default());
-  const nuxtApp = useNuxtApp();
-  await nuxtApp.callHook("page:finish");
-  useRouter().afterEach(() => nuxtApp.callHook("page:finish"));
+  await setupNuxt();
   vi.resetModules();
 }
 export {};

package/dist/runtime/mocks/vue-devtools.d.ts

@@ -0,0 +1,5 @@
+export declare const functions: never[];
+export declare function createRpcServer(): void;
+export declare const devtools: {
+    init(): void;
+};

package/dist/runtime/mocks/vue-devtools.mjs

@@ -0,0 +1,7 @@
+export const functions = [];
+export function createRpcServer() {
+}
+export const devtools = {
+  init() {
+  }
+};

package/dist/runtime/shared/environment.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtWindow } from '../../vitest-environment';
+import type { NuxtEnvironmentOptions } from '../../config';
+export declare function setupWindow(win: NuxtWindow, environmentOptions: {
+    nuxt: NuxtEnvironmentOptions;
+    nuxtRuntimeConfig?: Record<string, any>;
+    nuxtRouteRules?: Record<string, any>;
+}): Promise<() => void>;

package/dist/runtime/shared/environment.mjs

@@ -0,0 +1,123 @@
+import { createFetch } from "ofetch";
+import { joinURL } from "ufo";
+import { createApp, defineEventHandler, toNodeListener } from "h3";
+import { createRouter as createRadixRouter, exportMatcher, toRouteMatcher } from "radix3";
+import { fetchNodeRequestHandler } from "node-mock-http";
+export async function setupWindow(win, environmentOptions) {
+  win.__NUXT_VITEST_ENVIRONMENT__ = true;
+  win.__NUXT__ = {
+    serverRendered: false,
+    config: {
+      public: {},
+      app: { baseURL: "/" },
+      ...environmentOptions?.nuxtRuntimeConfig
+    },
+    data: {},
+    state: {}
+  };
+  const rootId = environmentOptions.nuxt.rootId || "nuxt-test";
+  let el;
+  try {
+    el = win.document.querySelector(rootId);
+  } catch {
+  }
+  if (el) {
+    return () => {
+    };
+  }
+  const consoleInfo = console.info;
+  console.info = (...args) => {
+    if (args[0] === "<Suspense> is an experimental feature and its API will likely change.") {
+      return;
+    }
+    return consoleInfo(...args);
+  };
+  const app = win.document.createElement("div");
+  app.id = rootId;
+  win.document.body.appendChild(app);
+  const h3App = createApp();
+  if (!win.fetch) {
+    await import("node-fetch-native/polyfill");
+    win.URLSearchParams = globalThis.URLSearchParams;
+  }
+  const nodeHandler = toNodeListener(h3App);
+  const registry = /* @__PURE__ */ new Set();
+  win.fetch = async (url, init) => {
+    if (typeof url === "string") {
+      const base = url.split("?")[0];
+      if (registry.has(base) || registry.has(url)) {
+        url = "/_" + url;
+      }
+      if (url.startsWith("/")) {
+        const response = await fetchNodeRequestHandler(nodeHandler, url, init);
+        return normalizeFetchResponse(response);
+      }
+    }
+    return fetch(url, init);
+  };
+  win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
+  win.__registry = registry;
+  win.__app = h3App;
+  const timestamp = Date.now();
+  const routeRulesMatcher = toRouteMatcher(
+    createRadixRouter({ routes: environmentOptions.nuxtRouteRules || {} })
+  );
+  const matcher = exportMatcher(routeRulesMatcher);
+  const manifestOutputPath = joinURL(
+    environmentOptions?.nuxtRuntimeConfig?.app?.baseURL || "/",
+    environmentOptions?.nuxtRuntimeConfig?.app?.buildAssetsDir || "_nuxt",
+    "builds"
+  );
+  const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
+  const buildId = win.__NUXT__.config?.app.buildId || "test";
+  h3App.use(
+    `${manifestBaseRoutePath}/latest.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp
+    }))
+  );
+  h3App.use(
+    `${manifestBaseRoutePath}/meta/${buildId}.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp,
+      matcher,
+      prerendered: []
+    }))
+  );
+  registry.add(`${manifestOutputPath}/latest.json`);
+  registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
+  return () => {
+    console.info = consoleInfo;
+  };
+}
+function normalizeFetchResponse(response) {
+  if (!response.headers.has("set-cookie")) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: normalizeCookieHeaders(response.headers)
+  });
+}
+function normalizeCookieHeader(header = "") {
+  return splitCookiesString(joinHeaders(header));
+}
+function normalizeCookieHeaders(headers) {
+  const outgoingHeaders = new Headers();
+  for (const [name, header] of headers) {
+    if (name === "set-cookie") {
+      for (const cookie of normalizeCookieHeader(header)) {
+        outgoingHeaders.append("set-cookie", cookie);
+      }
+    } else {
+      outgoingHeaders.set(name, joinHeaders(header));
+    }
+  }
+  return outgoingHeaders;
+}
+function joinHeaders(value) {
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}

package/dist/runtime/shared/nuxt.d.ts

@@ -0,0 +1 @@
+export declare function setupNuxt(): Promise<void>;

package/dist/runtime/shared/nuxt.mjs

@@ -0,0 +1,7 @@
+export async function setupNuxt() {
+  const { useRouter } = await import("#app/composables/router");
+  await import("#app/nuxt-vitest-app-entry").then((r) => r.default());
+  const nuxtApp = useNuxtApp();
+  await nuxtApp.callHook("page:finish");
+  useRouter().afterEach(() => nuxtApp.callHook("page:finish"));
+}

package/dist/vitest-environment.mjs

@@ -1,13 +1,132 @@
-import { createFetch } from 'ofetch';
 import { indexedDB } from 'fake-indexeddb';
 import { joinURL } from 'ufo';
-import { createApp, toNodeListener, defineEventHandler, splitCookiesString } from 'h3';
 import defu from 'defu';
-import { toRouteMatcher, createRouter, exportMatcher } from 'radix3';
 import { populateGlobal } from 'vitest/environments';
+import { createFetch } from 'ofetch';
+import { createApp, toNodeListener, defineEventHandler } from 'h3';
+import { toRouteMatcher, createRouter, exportMatcher } from 'radix3';
 import { fetchNodeRequestHandler } from 'node-mock-http';
 import { importModule } from 'local-pkg';
 
+async function setupWindow(win, environmentOptions) {
+  win.__NUXT_VITEST_ENVIRONMENT__ = true;
+  win.__NUXT__ = {
+    serverRendered: false,
+    config: {
+      public: {},
+      app: { baseURL: "/" },
+      ...environmentOptions?.nuxtRuntimeConfig
+    },
+    data: {},
+    state: {}
+  };
+  const rootId = environmentOptions.nuxt.rootId || "nuxt-test";
+  let el;
+  try {
+    el = win.document.querySelector(rootId);
+  } catch {
+  }
+  if (el) {
+    return () => {
+    };
+  }
+  const consoleInfo = console.info;
+  console.info = (...args) => {
+    if (args[0] === "<Suspense> is an experimental feature and its API will likely change.") {
+      return;
+    }
+    return consoleInfo(...args);
+  };
+  const app = win.document.createElement("div");
+  app.id = rootId;
+  win.document.body.appendChild(app);
+  const h3App = createApp();
+  if (!win.fetch) {
+    await import('node-fetch-native/polyfill');
+    win.URLSearchParams = globalThis.URLSearchParams;
+  }
+  const nodeHandler = toNodeListener(h3App);
+  const registry = /* @__PURE__ */ new Set();
+  win.fetch = async (url, init) => {
+    if (typeof url === "string") {
+      const base = url.split("?")[0];
+      if (registry.has(base) || registry.has(url)) {
+        url = "/_" + url;
+      }
+      if (url.startsWith("/")) {
+        const response = await fetchNodeRequestHandler(nodeHandler, url, init);
+        return normalizeFetchResponse(response);
+      }
+    }
+    return fetch(url, init);
+  };
+  win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
+  win.__registry = registry;
+  win.__app = h3App;
+  const timestamp = Date.now();
+  const routeRulesMatcher = toRouteMatcher(
+    createRouter({ routes: environmentOptions.nuxtRouteRules || {} })
+  );
+  const matcher = exportMatcher(routeRulesMatcher);
+  const manifestOutputPath = joinURL(
+    environmentOptions?.nuxtRuntimeConfig?.app?.baseURL || "/",
+    environmentOptions?.nuxtRuntimeConfig?.app?.buildAssetsDir || "_nuxt",
+    "builds"
+  );
+  const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
+  const buildId = win.__NUXT__.config?.app.buildId || "test";
+  h3App.use(
+    `${manifestBaseRoutePath}/latest.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp
+    }))
+  );
+  h3App.use(
+    `${manifestBaseRoutePath}/meta/${buildId}.json`,
+    defineEventHandler(() => ({
+      id: buildId,
+      timestamp,
+      matcher,
+      prerendered: []
+    }))
+  );
+  registry.add(`${manifestOutputPath}/latest.json`);
+  registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
+  return () => {
+    console.info = consoleInfo;
+  };
+}
+function normalizeFetchResponse(response) {
+  if (!response.headers.has("set-cookie")) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: normalizeCookieHeaders(response.headers)
+  });
+}
+function normalizeCookieHeader(header = "") {
+  return splitCookiesString(joinHeaders(header));
+}
+function normalizeCookieHeaders(headers) {
+  const outgoingHeaders = new Headers();
+  for (const [name, header] of headers) {
+    if (name === "set-cookie") {
+      for (const cookie of normalizeCookieHeader(header)) {
+        outgoingHeaders.append("set-cookie", cookie);
+      }
+    } else {
+      outgoingHeaders.set(name, joinHeaders(header));
+    }
+  }
+  return outgoingHeaders;
+}
+function joinHeaders(value) {
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}
+
 const happyDom = (async function(_, { happyDom = {} }) {
   const { Window, GlobalWindow } = await importModule("happy-dom");
   const window = new (GlobalWindow || Window)(happyDom);
@@ -58,33 +177,12 @@ const index = {
       environmentOptions?.nuxt.url ?? "http://localhost:3000",
       environmentOptions?.nuxtRuntimeConfig.app?.baseURL || "/"
     );
-    const consoleInfo = console.info;
-    console.info = (...args) => {
-      if (args[0] === "<Suspense> is an experimental feature and its API will likely change.") {
-        return;
-      }
-      return consoleInfo(...args);
-    };
     const environmentName = environmentOptions.nuxt.domEnvironment;
     const environment = environmentMap[environmentName] || environmentMap["happy-dom"];
     const { window: win, teardown } = await environment(global, defu(environmentOptions, {
       happyDom: { url },
       jsdom: { url }
     }));
-    win.__NUXT_VITEST_ENVIRONMENT__ = true;
-    win.__NUXT__ = {
-      serverRendered: false,
-      config: {
-        public: {},
-        app: { baseURL: "/" },
-        ...environmentOptions?.nuxtRuntimeConfig
-      },
-      data: {},
-      state: {}
-    };
-    const app = win.document.createElement("div");
-    app.id = environmentOptions.nuxt.rootId;
-    win.document.body.appendChild(app);
     if (environmentOptions?.nuxt?.mock?.intersectionObserver) {
       win.IntersectionObserver = win.IntersectionObserver || class IntersectionObserver {
         observe() {
@@ -98,101 +196,20 @@ const index = {
     if (environmentOptions?.nuxt?.mock?.indexedDb) {
       win.indexedDB = indexedDB;
     }
-    const h3App = createApp();
-    if (!win.fetch) {
-      await import('node-fetch-native/polyfill');
-      win.URLSearchParams = globalThis.URLSearchParams;
-    }
-    const nodeHandler = toNodeListener(h3App);
-    const registry = /* @__PURE__ */ new Set();
-    win.fetch = async (url2, init) => {
-      if (typeof url2 === "string") {
-        const base = url2.split("?")[0];
-        if (registry.has(base) || registry.has(url2)) {
-          url2 = "/_" + url2;
-        }
-        if (url2.startsWith("/")) {
-          const response = await fetchNodeRequestHandler(nodeHandler, url2, init);
-          return normalizeFetchResponse(response);
-        }
-      }
-      return fetch(url2, init);
-    };
-    win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
-    win.__registry = registry;
-    win.__app = h3App;
+    const teardownWindow = await setupWindow(win, environmentOptions);
     const { keys, originals } = populateGlobal(global, win, {
       bindFunctions: true
     });
-    const timestamp = Date.now();
-    const routeRulesMatcher = toRouteMatcher(
-      createRouter({ routes: environmentOptions.nuxtRouteRules || {} })
-    );
-    const matcher = exportMatcher(routeRulesMatcher);
-    const manifestOutputPath = joinURL(
-      environmentOptions?.nuxtRuntimeConfig.app?.baseURL || "/",
-      environmentOptions?.nuxtRuntimeConfig.app?.buildAssetsDir || "_nuxt",
-      "builds"
-    );
-    const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
-    const buildId = win.__NUXT__.config.app.buildId || "test";
-    h3App.use(
-      `${manifestBaseRoutePath}/latest.json`,
-      defineEventHandler(() => ({
-        id: buildId,
-        timestamp
-      }))
-    );
-    h3App.use(
-      `${manifestBaseRoutePath}/meta/${buildId}.json`,
-      defineEventHandler(() => ({
-        id: buildId,
-        timestamp,
-        matcher,
-        prerendered: []
-      }))
-    );
-    registry.add(`${manifestOutputPath}/latest.json`);
-    registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
     return {
       // called after all tests with this env have been run
       teardown() {
         keys.forEach((key) => delete global[key]);
-        console.info = consoleInfo;
+        teardownWindow();
         originals.forEach((v, k) => global[k] = v);
         teardown();
       }
     };
   }
 };
-function normalizeFetchResponse(response) {
-  if (!response.headers.has("set-cookie")) {
-    return response;
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: normalizeCookieHeaders(response.headers)
-  });
-}
-function normalizeCookieHeader(header = "") {
-  return splitCookiesString(joinHeaders(header));
-}
-function normalizeCookieHeaders(headers) {
-  const outgoingHeaders = new Headers();
-  for (const [name, header] of headers) {
-    if (name === "set-cookie") {
-      for (const cookie of normalizeCookieHeader(header)) {
-        outgoingHeaders.append("set-cookie", cookie);
-      }
-    } else {
-      outgoingHeaders.set(name, joinHeaders(header));
-    }
-  }
-  return outgoingHeaders;
-}
-function joinHeaders(value) {
-  return Array.isArray(value) ? value.join(", ") : String(value);
-}
 
 export { index as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils",
-  "version": "3.18.0",
+  "version": "3.19.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"
@@ -63,14 +63,14 @@
     "dev:prepare": "nuxi prepare && unbuild --stub && pnpm -r dev:prepare"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.17.1",
-    "@nuxt/schema": "^3.17.1",
-    "c12": "^3.0.3",
+    "@nuxt/kit": "^3.17.4",
+    "@nuxt/schema": "^3.17.4",
+    "c12": "^3.0.4",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
     "estree-walker": "^3.0.3",
-    "fake-indexeddb": "^6.0.0",
+    "fake-indexeddb": "^6.0.1",
     "get-port-please": "^3.1.2",
     "h3": "^1.15.3",
     "local-pkg": "^1.1.1",
@@ -85,39 +85,39 @@
     "std-env": "^3.9.0",
     "tinyexec": "^1.0.1",
     "ufo": "^1.6.1",
-    "unplugin": "^2.3.2",
-    "vite": "^6.3.4",
+    "unplugin": "^2.3.4",
+    "vite": "^6.3.5",
     "vitest-environment-nuxt": "^1.0.1",
-    "vue": "^3.5.13"
+    "vue": "^3.5.14"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "11.2.0",
+    "@cucumber/cucumber": "11.3.0",
     "@jest/globals": "29.7.0",
-    "@nuxt/devtools-kit": "2.4.0",
-    "@nuxt/eslint-config": "1.3.0",
+    "@nuxt/devtools-kit": "2.4.1",
+    "@nuxt/eslint-config": "1.4.0",
     "@playwright/test": "1.52.0",
     "@testing-library/vue": "8.1.0",
-    "@types/bun": "1.2.11",
+    "@types/bun": "1.2.13",
     "@types/estree": "1.0.7",
     "@types/jsdom": "21.1.7",
-    "@types/node": "22.15.3",
+    "@types/node": "22.15.19",
     "@types/semver": "7.7.0",
     "@vue/test-utils": "2.4.6",
     "changelogen": "0.6.1",
     "compatx": "0.2.0",
-    "eslint": "9.26.0",
+    "eslint": "9.27.0",
     "installed-check": "9.3.0",
-    "knip": "5.53.0",
-    "nitropack": "2.11.11",
-    "nuxt": "3.17.1",
-    "pkg-pr-new": "0.0.43",
+    "knip": "5.56.0",
+    "nitropack": "2.11.12",
+    "nuxt": "3.17.4",
+    "pkg-pr-new": "0.0.50",
     "playwright-core": "1.52.0",
-    "rollup": "4.40.1",
-    "semver": "7.7.1",
+    "rollup": "4.41.0",
+    "semver": "7.7.2",
     "typescript": "5.8.3",
     "unbuild": "latest",
-    "unimport": "5.0.0",
-    "vitest": "3.1.2",
+    "unimport": "5.0.1",
+    "vitest": "3.1.4",
     "vue-router": "4.5.1",
     "vue-tsc": "2.2.10"
   },
@@ -165,21 +165,20 @@
     }
   },
   "resolutions": {
-    "@cucumber/cucumber": "11.2.0",
-    "@nuxt/devtools": "1.0.8",
-    "@nuxt/kit": "^3.17.1",
-    "@nuxt/schema": "^3.17.1",
+    "@cucumber/cucumber": "11.3.0",
+    "@nuxt/kit": "^3.17.4",
+    "@nuxt/schema": "^3.17.4",
     "@nuxt/test-utils": "workspace:*",
-    "rollup": "4.40.1",
-    "vite": "^6.3.4",
-    "vite-node": "3.1.2",
-    "vitest": "3.1.2",
-    "vue": "^3.5.13"
+    "rollup": "4.41.0",
+    "vite": "^6.3.5",
+    "vite-node": "3.1.4",
+    "vitest": "3.1.4",
+    "vue": "^3.5.14"
   },
   "engines": {
     "node": "^18.20.5 || ^20.9.0 || ^22.0.0 || >=23.0.0"
   },
-  "packageManager": "pnpm@10.10.0",
+  "packageManager": "pnpm@10.11.0",
   "pnpm": {
     "onlyBuiltDependencies": [
       "better-sqlite3"