@nuxt/test-utils 3.23.0 → 4.0.1

package/README.md

@@ -1,5 +1,8 @@
 # Nuxt Test Utils
 
+[![nuxt.care health](https://img.shields.io/endpoint?url=https://nuxt.care/api/badge/test-utils)](https://nuxt.care/?search=test-utils)
+
+
 🧪 [Nuxt](https://nuxt.com/) Test Utils
 
 ## Overview

package/dist/config.d.mts

@@ -1,4 +1,4 @@
-import { NuxtConfig, Nuxt } from '@nuxt/schema';
+import { NuxtConfig, Nuxt, ViteConfig } from '@nuxt/schema';
 import { InlineConfig } from 'vitest/node';
 import { TestProjectInlineConfiguration } from 'vitest/config';
 import { DotenvOptions } from 'c12';
@@ -6,7 +6,7 @@ import { UserConfig, UserConfigFnPromise } from 'vite';
 
 interface GetVitestConfigOptions {
     nuxt: Nuxt;
-    viteConfig: UserConfig;
+    viteConfig: ViteConfig;
 }
 interface LoadNuxtOptions {
     dotenv?: Partial<DotenvOptions>;
@@ -57,11 +57,6 @@ declare module 'vitest/node' {
         nuxt?: NuxtEnvironmentOptions;
     }
 }
-declare module 'vitest' {
-    interface EnvironmentOptions {
-        nuxt?: NuxtEnvironmentOptions;
-    }
-}
 
 export { defineVitestConfig, defineVitestProject, getVitestConfigFromNuxt };
 export type { NuxtEnvironmentOptions };

package/dist/config.mjs

@@ -1,7 +1,6 @@
 import process from 'node:process';
-import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
-import { defu } from 'defu';
+import { defu, createDefu } from 'defu';
 import { createResolver, findPath } from '@nuxt/kit';
 import { resolveModulePath } from 'exsolve';
 import { getPackageInfoSync } from 'local-pkg';
@@ -107,7 +106,9 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
       break;
     }
   }
-  const h3Info = getPackageInfoSync("h3", {
+  const projectH3Path = resolveModulePath("h3/package.json", { from: rootDir, try: true });
+  const projectH3Info = projectH3Path ? getPackageInfoSync("h3", { paths: [projectH3Path] }) : void 0;
+  const h3Info = projectH3Info || getPackageInfoSync("h3", {
     paths: nitroPath ? [nitroPath] : options.nuxt.options.modulesDir
   });
   const resolver = createResolver(import.meta.url);
@@ -160,7 +161,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         },
         deps: {
           optimizer: {
-            web: {
+            client: {
               enabled: false
             }
           }
@@ -216,6 +217,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   );
   delete resolvedConfig.define["process.browser"];
   delete resolvedConfig.customLogger;
+  delete resolvedConfig.ssr;
   if (!Array.isArray(resolvedConfig.test.setupFiles)) {
     resolvedConfig.test.setupFiles = [resolvedConfig.test.setupFiles].filter(Boolean);
   }
@@ -228,8 +230,9 @@ async function defineVitestProject(config) {
   resolvedConfig.test.environment = "nuxt";
   return resolvedConfig;
 }
+const defineViteConfig = (config) => config;
 function defineVitestConfig(config = {}) {
-  return defineConfig(async () => {
+  return defineViteConfig(async () => {
     const resolvedConfig = await resolveConfig(config);
     if (resolvedConfig.test.browser?.enabled) {
       return resolvedConfig;
@@ -241,25 +244,29 @@ function defineVitestConfig(config = {}) {
     }
     const defaultEnvironment = resolvedConfig.test.environment || "node";
     if (defaultEnvironment !== "nuxt") {
-      const key = "projects" in resolvedConfig.test ? "projects" : "workspace" in resolvedConfig.test ? "workspace" : await import('vitest/package.json', { with: { type: 'json' } }).then((r) => {
-        const [major, minor] = (r.default || r).version.split(".");
-        return Number.parseInt(major, 10) > 3 || Number.parseInt(major, 10) === 3 && Number.parseInt(minor, 10) >= 2;
-      }) ? "projects" : "workspace";
-      resolvedConfig.test[key] = [];
-      resolvedConfig.test[key].push({
-        extends: true,
+      const merge = createDefu((obj, key, value) => {
+        if (Array.isArray(value) && Array.isArray(obj[key])) {
+          obj[key] = [.../* @__PURE__ */ new Set([...value, ...obj[key]])];
+          return true;
+        }
+      });
+      const nuxtProject = merge({
+        ...resolvedConfig,
         test: {
+          ...resolvedConfig.test,
           name: "nuxt",
           environment: "nuxt",
-          include: [
-            "**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
-            "{test,tests}/nuxt/**.*"
-          ]
+          include: []
         }
-      });
-      resolvedConfig.test[key].push({
-        extends: true,
+      }, resolvedConfig);
+      nuxtProject.test.include = [
+        "**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+        "{test,tests}/nuxt/**.*"
+      ];
+      const defaultProject = merge({
+        ...resolvedConfig,
         test: {
+          ...resolvedConfig.test,
           name: defaultEnvironment,
           environment: defaultEnvironment,
           exclude: [
@@ -272,7 +279,12 @@ function defineVitestConfig(config = {}) {
             "./{test,tests}/nuxt/**.*"
           ]
         }
-      });
+      }, resolvedConfig);
+      delete resolvedConfig.test.name;
+      delete resolvedConfig.test.environment;
+      delete resolvedConfig.test.include;
+      delete resolvedConfig.test.exclude;
+      resolvedConfig.test.projects = [nuxtProject, defaultProject];
     }
     return resolvedConfig;
   });

package/dist/e2e.d.mts

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

package/dist/e2e.mjs

@@ -1,4 +1,4 @@
-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.5cnw0YZR.mjs';
+export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, s as setup, e as setupMaps, w as waitForHydration } from './shared/test-utils.E_cAGA8l.mjs';
 import { u as useTestContext } from './shared/test-utils.BsmyE2FA.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.BsmyE2FA.mjs';
 import { consola } from 'consola';

package/dist/module.d.mts

@@ -1,10 +1,10 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { UserConfig } from 'vitest/node';
+import { TestUserConfig } from 'vitest/config';
 
 interface NuxtVitestOptions {
     startOnBoot?: boolean;
     logToConsole?: boolean;
-    vitestConfig?: UserConfig;
+    vitestConfig?: TestUserConfig;
 }
 declare const _default: _nuxt_schema.NuxtModule<NuxtVitestOptions, NuxtVitestOptions, false>;
 

package/dist/module.mjs

@@ -1,4 +1,5 @@
-import { resolveIgnorePatterns, logger, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath } from '@nuxt/kit';
+import { resolveIgnorePatterns, logger, addDevServerHandler, useNuxt, defineNuxtModule, createResolver, resolvePath } from '@nuxt/kit';
+import { refreshCustomTabs, addCustomTab, onDevToolsInitialized } from '@nuxt/devtools-kit';
 import { extname, join, dirname, relative, resolve } from 'pathe';
 import { isCI, hasTTY, provider } from 'std-env';
 import { walk } from 'estree-walker';
@@ -13,7 +14,7 @@ import { detectPackageManager, addDependency } from 'nypm';
 import { h } from 'vue';
 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 { l as listenCliMessages, s as sendMessageToCli, c as createVitestTestSummary } from './shared/test-utils.DDUpsMYL.mjs';
 import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
@@ -24,195 +25,193 @@ const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
 const HELPER_MOCK_IMPORT = "mockNuxtImport";
 const HELPER_MOCK_COMPONENT = "mockComponent";
 const HELPER_MOCK_HOIST = "__NUXT_VITEST_MOCKS";
+const HELPER_MOCK_HOIST_ORIGINAL = "__NUXT_VITEST_MOCKS_ORIGINAL";
 const HELPERS_NAME = [HELPER_MOCK_IMPORT, HELPER_MOCK_COMPONENT];
 const createMockPlugin = (ctx) => createUnplugin(() => {
-  function transform(code, id) {
-    if (!HELPERS_NAME.some((n) => code.includes(n))) return;
-    if (id.includes("/node_modules/")) return;
-    let ast;
-    try {
-      ast = this.parse(code, {
-        // @ts-expect-error compatibility with rollup v3
-        sourceType: "module",
-        ecmaVersion: "latest",
-        ranges: true
-      });
-    } catch {
-      return;
-    }
-    let insertionPoint = 0;
-    let hasViImport = false;
-    const s = new MagicString(code);
-    const mocksImport = [];
-    const mocksComponent = [];
-    const importPathsList = /* @__PURE__ */ new Set();
-    walk(ast, {
-      enter: (node, parent) => {
-        if (isImportDeclaration(node)) {
-          if (node.source.value === "vitest" && !hasViImport) {
-            const viImport = node.specifiers.find(
-              (i) => isImportSpecifier(i) && i.imported.type === "Identifier" && i.imported.name === "vi"
-            );
-            if (viImport) {
-              insertionPoint = endOf(node);
-              hasViImport = true;
-            }
-            return;
-          }
-        }
-        if (!isCallExpression(node)) return;
-        if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_IMPORT) {
-          if (node.arguments.length !== 2) {
-            return this.error(
-              new Error(
-                `${HELPER_MOCK_IMPORT}() should have exactly 2 arguments`
-              ),
-              startOf(node)
-            );
-          }
-          const importTarget = node.arguments[0];
-          const name = isLiteral(importTarget) ? importTarget.value : isIdentifier(importTarget) ? importTarget.name : void 0;
-          if (typeof name !== "string") {
-            return this.error(
-              new Error(
-                `The first argument of ${HELPER_MOCK_IMPORT}() must be a string literal or mocked target`
-              ),
-              startOf(importTarget)
-            );
-          }
-          const importItem = ctx.imports.find((_) => name === (_.as || _.name));
-          if (!importItem) {
-            return this.error(`Cannot find import "${name}" to mock`);
-          }
-          s.overwrite(
-            isExpressionStatement(parent) ? startOf(parent) : startOf(node.arguments[0]),
-            isExpressionStatement(parent) ? endOf(parent) : endOf(node.arguments[1]),
-            ""
-          );
-          mocksImport.push({
-            name,
-            import: importItem,
-            factory: code.slice(
-              startOf(node.arguments[1]),
-              endOf(node.arguments[1])
-            )
-          });
-        }
-        if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_COMPONENT) {
-          if (node.arguments.length !== 2) {
-            return this.error(
-              new Error(
-                `${HELPER_MOCK_COMPONENT}() should have exactly 2 arguments`
-              ),
-              startOf(node)
-            );
-          }
-          const componentName = node.arguments[0];
-          if (!isLiteral(componentName) || typeof componentName.value !== "string") {
-            return this.error(
-              new Error(
-                `The first argument of ${HELPER_MOCK_COMPONENT}() must be a string literal`
-              ),
-              startOf(componentName)
-            );
-          }
-          const pathOrName = componentName.value;
-          const component = ctx.components.find(
-            (_) => _.pascalName === pathOrName || _.kebabName === pathOrName
-          );
-          const path = component?.filePath || pathOrName;
-          s.overwrite(
-            isExpressionStatement(parent) ? startOf(parent) : startOf(node.arguments[1]),
-            isExpressionStatement(parent) ? endOf(parent) : endOf(node.arguments[1]),
-            ""
-          );
-          mocksComponent.push({
-            path,
-            factory: code.slice(
-              startOf(node.arguments[1]),
-              endOf(node.arguments[1])
-            )
+  return {
+    name: PLUGIN_NAME$1,
+    enforce: "post",
+    vite: {
+      transform(code, id) {
+        if (!HELPERS_NAME.some((n) => code.includes(n))) return;
+        if (id.includes("/node_modules/")) return;
+        let ast;
+        try {
+          ast = this.parse(code, {
+            // @ts-expect-error compatibility with rollup v3
+            sourceType: "module",
+            ecmaVersion: "latest",
+            ranges: true
           });
+        } catch {
+          return;
         }
-      }
-    });
-    if (mocksImport.length === 0 && mocksComponent.length === 0) return;
-    const mockLines = [];
-    if (mocksImport.length) {
-      const mockImportMap = /* @__PURE__ */ new Map();
-      for (const mock of mocksImport) {
-        if (!mockImportMap.has(mock.import.from)) {
-          mockImportMap.set(mock.import.from, []);
-        }
-        mockImportMap.get(mock.import.from).push(mock);
-      }
-      mockLines.push(
-        ...Array.from(mockImportMap.entries()).flatMap(
-          ([from, mocks]) => {
-            importPathsList.add(from);
-            const lines = [
-              `vi.mock(${JSON.stringify(from)}, async (importOriginal) => {`,
-              `  const mocks = globalThis.${HELPER_MOCK_HOIST}`,
-              `  if (!mocks[${JSON.stringify(from)}]) {`,
-              `    mocks[${JSON.stringify(from)}] = { ...await importOriginal(${JSON.stringify(from)}) }`,
-              `  }`
-            ];
-            for (const mock of mocks) {
-              if (mock.import.name === "default") {
-                lines.push(
-                  `  mocks[${JSON.stringify(from)}]["default"] = await (${mock.factory})();`
+        let insertionPoint = 0;
+        let hasViImport = false;
+        const s = new MagicString(code);
+        const mocksImport = [];
+        const mocksComponent = [];
+        const importPathsList = /* @__PURE__ */ new Set();
+        walk(ast, {
+          enter: (node, parent) => {
+            if (isImportDeclaration(node)) {
+              if (node.source.value === "vitest" && !hasViImport) {
+                const viImport = node.specifiers.find(
+                  (i) => isImportSpecifier(i) && i.imported.type === "Identifier" && i.imported.name === "vi"
+                );
+                if (viImport) {
+                  insertionPoint = endOf(node);
+                  hasViImport = true;
+                }
+                return;
+              }
+            }
+            if (!isCallExpression(node)) return;
+            if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_IMPORT) {
+              if (node.arguments.length !== 2) {
+                return this.error(
+                  new Error(
+                    `${HELPER_MOCK_IMPORT}() should have exactly 2 arguments`
+                  ),
+                  startOf(node)
+                );
+              }
+              const importTarget = node.arguments[0];
+              const name = isLiteral(importTarget) ? importTarget.value : isIdentifier(importTarget) ? importTarget.name : void 0;
+              if (typeof name !== "string") {
+                return this.error(
+                  new Error(
+                    `The first argument of ${HELPER_MOCK_IMPORT}() must be a string literal or mocked target`
+                  ),
+                  startOf(importTarget)
+                );
+              }
+              const importItem = ctx.imports.find((_) => name === (_.as || _.name));
+              if (!importItem) {
+                return this.error(`Cannot find import "${name}" to mock`);
+              }
+              s.overwrite(
+                isExpressionStatement(parent) ? startOf(parent) : startOf(node.arguments[0]),
+                isExpressionStatement(parent) ? endOf(parent) : endOf(node.arguments[1]),
+                ""
+              );
+              mocksImport.push({
+                name,
+                import: importItem,
+                factory: code.slice(
+                  startOf(node.arguments[1]),
+                  endOf(node.arguments[1])
+                )
+              });
+            }
+            if (isIdentifier(node.callee) && node.callee.name === HELPER_MOCK_COMPONENT) {
+              if (node.arguments.length !== 2) {
+                return this.error(
+                  new Error(
+                    `${HELPER_MOCK_COMPONENT}() should have exactly 2 arguments`
+                  ),
+                  startOf(node)
                 );
-              } else {
-                lines.push(
-                  `  mocks[${JSON.stringify(from)}][${JSON.stringify(mock.name)}] = await (${mock.factory})();`
+              }
+              const componentName = node.arguments[0];
+              if (!isLiteral(componentName) || typeof componentName.value !== "string") {
+                return this.error(
+                  new Error(
+                    `The first argument of ${HELPER_MOCK_COMPONENT}() must be a string literal`
+                  ),
+                  startOf(componentName)
                 );
               }
+              const pathOrName = componentName.value;
+              const component = ctx.components.find(
+                (_) => _.pascalName === pathOrName || _.kebabName === pathOrName
+              );
+              const path = component?.filePath || pathOrName;
+              s.overwrite(
+                isExpressionStatement(parent) ? startOf(parent) : startOf(node.arguments[1]),
+                isExpressionStatement(parent) ? endOf(parent) : endOf(node.arguments[1]),
+                ""
+              );
+              mocksComponent.push({
+                path,
+                factory: code.slice(
+                  startOf(node.arguments[1]),
+                  endOf(node.arguments[1])
+                )
+              });
             }
-            lines.push(`  return mocks[${JSON.stringify(from)}] `);
-            lines.push(`});`);
-            return lines;
           }
-        )
-      );
-    }
-    if (mocksComponent.length) {
-      mockLines.push(
-        ...mocksComponent.flatMap((mock) => {
-          return [
-            `vi.mock(${JSON.stringify(mock.path)}, async () => {`,
-            `  const factory = (${mock.factory});`,
-            `  const result = typeof factory === 'function' ? await factory() : await factory`,
-            `  return 'default' in result ? result : { default: result }`,
-            "});"
-          ];
-        })
-      );
-    }
-    if (!mockLines.length) return;
-    s.appendLeft(insertionPoint, `
+        });
+        if (mocksImport.length === 0 && mocksComponent.length === 0) return;
+        const mockLines = [];
+        if (mocksImport.length) {
+          const mockImportMap = /* @__PURE__ */ new Map();
+          for (const mock of mocksImport) {
+            if (!mockImportMap.has(mock.import.from)) {
+              mockImportMap.set(mock.import.from, []);
+            }
+            mockImportMap.get(mock.import.from).push(mock);
+          }
+          mockLines.push(
+            ...Array.from(mockImportMap.entries()).flatMap(
+              ([from, mocks]) => {
+                importPathsList.add(from);
+                const quotedFrom = JSON.stringify(from);
+                const mockModuleEntry = `globalThis.${HELPER_MOCK_HOIST}[${quotedFrom}]`;
+                const lines = [
+                  `vi.mock(${quotedFrom}, async (importOriginal) => {`,
+                  `  if (!${mockModuleEntry}) {`,
+                  `    const original = await importOriginal(${quotedFrom})`,
+                  `    ${mockModuleEntry} = { ...original }`,
+                  `    ${mockModuleEntry}.${HELPER_MOCK_HOIST_ORIGINAL} = { ...original }`,
+                  `  }`
+                ];
+                for (const mock of mocks) {
+                  const quotedName = JSON.stringify(mock.import.name === "default" ? "default" : mock.name);
+                  lines.push(
+                    `  ${mockModuleEntry}[${quotedName}] = await (${mock.factory})(${mockModuleEntry}.${HELPER_MOCK_HOIST_ORIGINAL}[${quotedName}]);`
+                  );
+                }
+                lines.push(`  return ${mockModuleEntry} `);
+                lines.push(`});`);
+                return lines;
+              }
+            )
+          );
+        }
+        if (mocksComponent.length) {
+          mockLines.push(
+            ...mocksComponent.flatMap((mock) => {
+              return [
+                `vi.mock(${JSON.stringify(mock.path)}, async () => {`,
+                `  const factory = (${mock.factory});`,
+                `  const result = typeof factory === 'function' ? await factory() : await factory`,
+                `  return 'default' in result ? result : { default: result }`,
+                "});"
+              ];
+            })
+          );
+        }
+        if (!mockLines.length) return;
+        s.appendLeft(insertionPoint, `
 vi.hoisted(() => { 
         if(!globalThis.${HELPER_MOCK_HOIST}){
           vi.stubGlobal(${JSON.stringify(HELPER_MOCK_HOIST)}, {})
         }
       });
 `);
-    if (!hasViImport) s.prepend(`import {vi} from "vitest";
+        if (!hasViImport) s.prepend(`import {vi} from "vitest";
 `);
-    s.appendLeft(insertionPoint, "\n" + mockLines.join("\n") + "\n");
-    importPathsList.forEach((p) => {
-      s.append(`
+        s.appendLeft(insertionPoint, "\n" + mockLines.join("\n") + "\n");
+        importPathsList.forEach((p) => {
+          s.append(`
  import ${JSON.stringify(p)};`);
-    });
-    return {
-      code: s.toString(),
-      map: s.generateMap()
-    };
-  }
-  return {
-    name: PLUGIN_NAME$1,
-    enforce: "post",
-    vite: {
-      transform,
+        });
+        return {
+          code: s.toString(),
+          map: s.generateMap()
+        };
+      },
       // Place Vitest's mock plugin after all Nuxt plugins
       async configResolved(config) {
         const plugins = config.plugins || [];
@@ -768,17 +767,9 @@ async function updateGitignore(nuxt, answers) {
 async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
   const iframeSrc = "/__test_utils_vitest__/";
   const updateTabs = debounce(() => {
-    nuxt.callHook("devtools:customTabs:refresh");
+    refreshCustomTabs(nuxt);
   }, 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);
-    }
-  });
+  addCustomTab(() => createVitestCustomTab(vitestWrapper, { iframeSrc }), nuxt);
   addDevServerHandler({
     route: iframeSrc,
     handler: Object.assign(() => iframeContentHtml(vitestWrapper.uiUrl), { __is_handler__: true })
@@ -961,7 +952,7 @@ function vitestWrapper(options) {
   };
 }
 
-const version = "3.23.0";
+const version = "4.0.1";
 const pkg = {
 	version: version};
 
@@ -1007,9 +998,9 @@ const module$1 = defineNuxtModule({
     if (!nuxt.options.dev) return;
     if (process.env.TEST || process.env.VITE_TEST) return;
     const vitestWrapper2 = createVitestWrapper(options, nuxt);
-    nuxt.hook("devtools:before", async () => {
+    onDevToolsInitialized(async () => {
       await setupDevTools(vitestWrapper2, nuxt);
-    });
+    }, nuxt);
     if (options.startOnBoot) {
       vitestWrapper2.start();
     }

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, a as TestHooks } from './shared/test-utils.C9GKP_T5.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.BLyxqr96.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
 import 'ofetch';

package/dist/playwright.mjs

@@ -1,10 +1,10 @@
 import defu from 'defu';
 import { test as test$1 } from '@playwright/test';
 export { expect } from '@playwright/test';
-import { w as waitForHydration, d as createTest } from './shared/test-utils.5cnw0YZR.mjs';
+import { isWindows } from 'std-env';
+import { w as waitForHydration, d as createTest } from './shared/test-utils.E_cAGA8l.mjs';
 import 'node:path';
 import 'ufo';
-import 'std-env';
 import 'consola';
 import 'node:fs';
 import 'destr';
@@ -19,6 +19,7 @@ import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';
 
+const FIXTURE_TIMEOUT = isWindows ? 12e4 : 6e4;
 const test = test$1.extend({
   nuxt: [void 0, { option: true, scope: "worker" }],
   defaults: [{ nuxt: void 0 }, { option: true, scope: "worker" }],
@@ -29,7 +30,7 @@ const test = test$1.extend({
       await use(hooks);
       await hooks.afterAll();
     },
-    { scope: "worker" }
+    { scope: "worker", timeout: FIXTURE_TIMEOUT }
   ],
   baseURL: async ({ _nuxtHooks }, use) => {
     _nuxtHooks.beforeEach();

package/dist/runtime/browser-entry.mjs

@@ -1,8 +1,5 @@
 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();
-}
+await setupWindow(window, environmentOptions);
+await setupNuxt();

package/dist/runtime/entry.mjs

@@ -1,7 +1,8 @@
-import { vi } from "vitest";
+import { beforeAll } from "vitest";
 import { setupNuxt } from "./shared/nuxt.mjs";
 if (typeof window !== "undefined" && window.__NUXT_VITEST_ENVIRONMENT__) {
-  await setupNuxt();
-  vi.resetModules();
+  beforeAll(async () => {
+    await setupNuxt();
+  });
 }
 export {};