@nuxt/test-utils 4.0.0 → 4.0.2

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>;

package/dist/config.mjs

@@ -1,7 +1,6 @@
 import process from 'node:process';
-import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
-import { createDefu, defu } from 'defu';
+import { defu, createDefu } from 'defu';
 import { createResolver, findPath } from '@nuxt/kit';
 import { resolveModulePath } from 'exsolve';
 import { getPackageInfoSync } from 'local-pkg';
@@ -33,7 +32,8 @@ async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {})
   const { buildNuxt, loadNuxt } = await loadKit(rootDir);
   const nuxt = await loadNuxt({
     cwd: rootDir,
-    dev: false,
+    // https://github.com/nuxt/nuxt/blob/d52a4fdd7ad5feb035dcf3f56c3b2d0ab059b1d4/packages/kit/src/loader/nuxt.ts#L24
+    dev: options.overrides?.dev ?? false,
     dotenv: defu(options.dotenv, {
       cwd: rootDir,
       fileName: ".env.test"
@@ -107,7 +107,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 +162,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         },
         deps: {
           optimizer: {
-            web: {
+            client: {
               enabled: false
             }
           }
@@ -216,6 +218,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 +231,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;
@@ -277,9 +281,11 @@ function defineVitestConfig(config = {}) {
           ]
         }
       }, resolvedConfig);
-      resolvedConfig.test = {
-        projects: [nuxtProject, defaultProject]
-      };
+      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/module.mjs

@@ -28,191 +28,190 @@ 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])
-            )
+  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 (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)
-            );
+        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])
+                )
+              });
+            }
           }
-          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)
-            );
+        });
+        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);
           }
-          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])
+          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 (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, []);
+        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 }`,
+                "});"
+              ];
+            })
+          );
         }
-        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, `
+        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 || [];
@@ -953,7 +952,7 @@ function vitestWrapper(options) {
   };
 }
 
-const version = "4.0.0";
+const version = "4.0.2";
 const pkg = {
 	version: version};
 

package/dist/runtime/nuxt-root.mjs

@@ -6,12 +6,12 @@ export default defineComponent({
     const nuxtApp = useNuxtApp();
     provide(PageRouteSymbol, useRoute());
     const done = nuxtApp.deferHydration();
-    const results = nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup");
+    const results = nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup", []);
     if (import.meta.dev && results && results.some((i) => i && "then" in i)) {
       console.error("[nuxt] Error in `vue:setup`. Callbacks must be synchronous.");
     }
     onErrorCaptured((err, target, info) => {
-      nuxtApp.hooks.callHook("vue:error", err, target, info).catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
+      nuxtApp.hooks.callHook("vue:error", err, target, info)?.catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
       if (isNuxtError(err) && (err.fatal || err.unhandled)) {
         return false;
       }

package/dist/runtime/shared/vue-wrapper-plugin.d.ts

@@ -1,50 +1,5 @@
-import type { VueWrapper } from '@vue/test-utils';
-type Options = ReturnType<typeof createPluginOptions>;
-export declare function getVueWrapperPlugin(): Options;
-declare function createPluginOptions(): {
-    _name: string;
-    _instances: WeakRef<VueWrapper>[];
-    readonly instances: VueWrapper<unknown, {
-        $: import("vue").ComponentInternalInstance;
-        $data: {};
-        $props: {};
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import("vue").Slot<any> | undefined;
-        }>;
-        $root: import("vue").ComponentPublicInstance | null;
-        $parent: import("vue").ComponentPublicInstance | null;
-        $host: Element | null;
-        $emit: (event: string, ...args: any[]) => void;
-        $el: any;
-        $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions> & {
-            beforeCreate?: (() => void) | (() => void)[];
-            created?: (() => void) | (() => void)[];
-            beforeMount?: (() => void) | (() => void)[];
-            mounted?: (() => void) | (() => void)[];
-            beforeUpdate?: (() => void) | (() => void)[];
-            updated?: (() => void) | (() => void)[];
-            activated?: (() => void) | (() => void)[];
-            deactivated?: (() => void) | (() => void)[];
-            beforeDestroy?: (() => void) | (() => void)[];
-            beforeUnmount?: (() => void) | (() => void)[];
-            destroyed?: (() => void) | (() => void)[];
-            unmounted?: (() => void) | (() => void)[];
-            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof import("vue").nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
-    } & Readonly<{}> & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {}>[];
-    addInstance(instance: VueWrapper): void;
+interface Options {
     hasNuxtPage(): boolean;
-    _hasComponent(componentName: string): boolean;
-};
+}
+export declare function getVueWrapperPlugin(): Options;
 export {};

package/dist/runtime/shared/vue-wrapper-plugin.mjs

@@ -1,6 +1,11 @@
-import { config } from "@vue/test-utils";
 const PLUGIN_NAME = "nuxt-test-utils";
+const config = await import("@vue/test-utils").then((r) => r.config).catch(() => void 0);
 export function getVueWrapperPlugin() {
+  if (!config) {
+    return {
+      hasNuxtPage: () => false
+    };
+  }
   const installed = config.plugins.VueWrapper.installedPlugins.find(({ options: options2 }) => options2?._name === PLUGIN_NAME);
   if (installed) return installed.options;
   const options = createPluginOptions();

package/dist/runtime-utils/index.d.mts

@@ -56,9 +56,23 @@ declare function registerEndpoint(url: string, options: EventHandler | {
  *  }
  * })
  * ```
+ * @example
+ * ```ts
+ * // Making partial mock with original implementation
+ * mockNuxtImport(useRoute, original => vi.fn(original))
+ * // or (with name based)
+ * mockNuxtImport('useRoute', original => vi.fn(original))
+ * // or (with name based, type parameter)
+ * mockNuxtImport<typeof useRoute>('useRoute', original => vi.fn(original))
+ *
+ * // Override in test
+ * vi.mocked(useRoute).mockImplementation(
+ *  (...args) => ({ ...vi.mocked(useRoute).getMockImplementation()!(...args), path: '/mocked' }),
+ * )
+ * ```
  * @see https://nuxt.com/docs/getting-started/testing#mocknuxtimport
  */
-declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: (original: T) => T | Promise<T>): void;
+declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: T extends string ? (original: any) => any : (original: T) => T | Promise<T>): void;
 /**
  * `mockComponent` allows you to mock Nuxt's component.
  * @param path - component name in PascalCase, or the relative path of the component.

package/dist/runtime-utils/index.mjs

@@ -1,6 +1,5 @@
 import { mount } from '@vue/test-utils';
 import { reactive, h as h$1, Suspense, nextTick, getCurrentInstance, onErrorCaptured, effectScope } from 'vue';
-import { defu } from 'defu';
 import { defineComponent, useRouter, h, tryUseNuxtApp } from '#imports';
 import NuxtRoot from '#build/root-component.mjs';
 
@@ -231,8 +230,9 @@ function wrapperSuspended(component, options, {
           }
         ))
       },
-      defu(wrapperFnOptions, {
-        global: {
+      {
+        ...wrapperFnOptions,
+        global: mergeComponentMountingGlobalOptions(wrapperFnOptions.global, {
           config: {
             globalProperties: makeAllPropertiesEnumerable(
               vueApp.config.globalProperties
@@ -246,11 +246,38 @@ function wrapperSuspended(component, options, {
             [ClonedComponent.name]: false
           },
           components: { ...vueApp._context.components, RouterLink }
-        }
-      })
+        })
+      }
     );
   });
 }
+function mergeComponentMountingGlobalOptions(options = {}, defaults = {}) {
+  return {
+    ...options,
+    mixins: [...defaults.mixins || [], ...options.mixins || []],
+    stubs: {
+      ...defaults.stubs,
+      ...Array.isArray(options.stubs) ? Object.fromEntries(options.stubs.map((n) => [n, true])) : options.stubs
+    },
+    plugins: [...defaults.plugins || [], ...options.plugins || []],
+    components: { ...defaults.components, ...options.components },
+    provide: { ...defaults.provide, ...options.provide },
+    mocks: { ...defaults.mocks, ...options.mocks },
+    config: {
+      ...defaults.config,
+      ...options.config,
+      compilerOptions: {
+        ...defaults.config?.compilerOptions,
+        ...options.config?.compilerOptions
+      },
+      globalProperties: {
+        ...defaults.config?.globalProperties,
+        ...options.config?.globalProperties
+      }
+    },
+    directives: { ...defaults.directives, ...options.directives }
+  };
+}
 function makeAllPropertiesEnumerable(target) {
   return {
     ...target,

package/dist/vitest-environment.mjs

@@ -1,10 +1,9 @@
+import { resolveModulePath } from 'exsolve';
 import { indexedDB } from 'fake-indexeddb';
 import { joinURL } from 'ufo';
 import defu from 'defu';
-import { populateGlobal } from 'vitest/environments';
 import { createFetch } from 'ofetch';
 import { toRouteMatcher, createRouter, exportMatcher } from 'radix3';
-import { importModule } from 'local-pkg';
 
 function defineEventHandler(handler) {
   return Object.assign(handler, { __is_handler__: true });
@@ -192,7 +191,7 @@ async function setupWindow(win, environmentOptions) {
 }
 
 const happyDom = (async function(_, { happyDom = {} }) {
-  const { Window, GlobalWindow } = await importModule("happy-dom");
+  const { Window, GlobalWindow } = await import('happy-dom');
   const window = new (GlobalWindow || Window)(happyDom);
   return {
     window,
@@ -203,7 +202,7 @@ const happyDom = (async function(_, { happyDom = {} }) {
 });
 
 const jsdom = (async function(global, { jsdom = {} }) {
-  const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await importModule("jsdom");
+  const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
   const jsdomOptions = defu(jsdom, {
     html: "<!DOCTYPE html>",
     url: "http://localhost:3000",
@@ -217,7 +216,7 @@ const jsdom = (async function(global, { jsdom = {} }) {
   const virtualConsole = jsdomOptions.console && global.console ? new VirtualConsole() : void 0;
   const window = new JSDOM(jsdomOptions.html, {
     ...jsdomOptions,
-    resources: jsdomOptions.resources ?? (jsdomOptions.userAgent ? new ResourceLoader({ userAgent: jsdomOptions.userAgent }) : void 0),
+    resources: jsdomOptions.resources ?? (jsdomOptions.userAgent ? ResourceLoader ? new ResourceLoader({ userAgent: jsdomOptions.userAgent }) : { userAgent: jsdomOptions.userAgent } : void 0),
     virtualConsole: virtualConsole ? "sendTo" in virtualConsole ? virtualConsole.sendTo(global.console) : virtualConsole.forwardTo(global.console) : void 0,
     cookieJar: jsdomOptions.cookieJar ? new CookieJar() : void 0
   }).window;
@@ -239,6 +238,7 @@ const index = {
   name: "nuxt",
   viteEnvironment: "client",
   async setup(global, environmentOptions) {
+    const { populateGlobal } = await importVitestEnvironments();
     const url = joinURL(
       environmentOptions.nuxt?.url ?? "http://localhost:3000",
       environmentOptions.nuxtRuntimeConfig?.app?.baseURL || "/"
@@ -274,6 +274,10 @@ const index = {
     };
   }
 };
+async function importVitestEnvironments() {
+  const pkg = resolveModulePath("vitest/runtime", { try: true }) ? "vitest/runtime" : "vitest/environments";
+  return await import(pkg);
+}
 class IntersectionObserver {
   observe() {
   }

package/dist/vitest-wrapper/cli.mjs

@@ -1,4 +1,3 @@
-import { importModule } from 'local-pkg';
 import { getPort } from 'get-port-please';
 import { a as listenHostMessages, b as sendMessageToHost } from '../shared/test-utils.DDUpsMYL.mjs';
 
@@ -56,7 +55,7 @@ async function main() {
     });
   });
   const port = apiPorts ? await getPort({ ports: apiPorts }) : void 0;
-  const { startVitest } = await importModule("vitest/node");
+  const { startVitest } = await import('vitest/node');
   const customReporter = createCustomReporter((vitest2) => {
     listenHostMessages(async ({ type, payload }) => {
       if (type === "stop") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"
@@ -53,24 +53,11 @@
     "dist",
     "dirs.js"
   ],
-  "scripts": {
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "test": "pnpm test:types && pnpm test:unit && pnpm test:examples",
-    "test:examples": "pnpm --filter '!@nuxt/test-utils' --filter '!example-app-cucumber' --filter '!example-app-jest' --filter '!example-app-bun' -r test && pnpm --filter example-app-cucumber -r test",
-    "test:knip": "knip",
-    "test:engines": "pnpm installed-check --no-workspaces --ignore-dev",
-    "test:types": "vue-tsc --noEmit",
-    "test:unit": "vitest test/unit --run",
-    "build": "unbuild",
-    "prepack": "unbuild",
-    "dev:prepare": "nuxt prepare && unbuild --stub && pnpm -r dev:prepare"
-  },
   "dependencies": {
-    "@clack/prompts": "1.0.0",
+    "@clack/prompts": "1.2.0",
     "@nuxt/devtools-kit": "^2.7.0",
-    "@nuxt/kit": "^3.21.0",
-    "c12": "^3.3.3",
+    "@nuxt/kit": "^3.21.2",
+    "c12": "^3.3.4",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
@@ -78,58 +65,58 @@
     "exsolve": "^1.0.8",
     "fake-indexeddb": "^6.2.5",
     "get-port-please": "^3.2.0",
-    "h3": "^1.15.5",
-    "h3-next": "npm:h3@2.0.1-rc.11",
+    "h3": "^1.15.11",
+    "h3-next": "npm:h3@2.0.1-rc.20",
     "local-pkg": "^1.1.2",
     "magic-string": "^0.30.21",
     "node-fetch-native": "^1.6.7",
     "node-mock-http": "^1.0.4",
-    "nypm": "^0.6.4",
+    "nypm": "^0.6.5",
     "ofetch": "^1.5.1",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.1.0",
     "radix3": "^1.1.2",
     "scule": "^1.3.0",
-    "std-env": "^3.10.0",
-    "tinyexec": "^1.0.2",
+    "std-env": "^4.0.0",
+    "tinyexec": "^1.1.1",
     "ufo": "^1.6.3",
     "unplugin": "^3.0.0",
-    "vitest-environment-nuxt": "^1.0.1",
-    "vue": "^3.5.27"
+    "vue": "^3.5.32",
+    "vitest-environment-nuxt": "2.0.0"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "12.6.0",
-    "@jest/globals": "30.2.0",
-    "@nuxt/eslint-config": "1.13.0",
-    "@nuxt/schema": "4.3.0",
-    "@playwright/test": "1.58.1",
+    "@cucumber/cucumber": "12.7.0",
+    "@jest/globals": "30.3.0",
+    "@nuxt/eslint-config": "1.15.2",
+    "@nuxt/schema": "4.4.2",
+    "@playwright/test": "1.59.1",
     "@testing-library/vue": "8.1.0",
-    "@types/bun": "1.3.8",
+    "@types/bun": "1.3.11",
     "@types/estree": "1.0.8",
-    "@types/jsdom": "27.0.0",
+    "@types/jsdom": "28.0.1",
     "@types/node": "latest",
     "@types/semver": "7.7.1",
-    "@vitest/browser-playwright": "4.0.18",
+    "@vitest/browser-playwright": "4.1.2",
     "@vue/test-utils": "2.4.6",
     "changelogen": "0.6.2",
     "compatx": "0.2.0",
-    "eslint": "9.39.2",
-    "installed-check": "9.3.0",
-    "knip": "5.83.0",
-    "nitropack": "2.13.1",
-    "nuxt": "4.3.0",
-    "oxc-parser": "0.112.0",
-    "pkg-pr-new": "0.0.63",
-    "playwright-core": "1.58.1",
-    "rollup": "4.57.1",
-    "semver": "7.7.3",
-    "typescript": "5.9.3",
+    "eslint": "10.2.0",
+    "installed-check": "10.0.1",
+    "knip": "6.3.0",
+    "nitropack": "2.13.3",
+    "nuxt": "4.4.2",
+    "oxc-parser": "0.124.0",
+    "pkg-pr-new": "0.0.66",
+    "playwright-core": "1.59.1",
+    "rollup": "4.60.1",
+    "semver": "7.7.4",
+    "typescript": "6.0.2",
     "unbuild": "latest",
-    "unimport": "5.6.0",
-    "vite": "7.3.1",
-    "vitest": "4.0.18",
-    "vue-router": "5.0.2",
-    "vue-tsc": "3.2.4"
+    "unimport": "6.0.2",
+    "vite": "8.0.5",
+    "vitest": "4.1.2",
+    "vue-router": "5.0.4",
+    "vue-tsc": "3.2.6"
   },
   "peerDependencies": {
     "@cucumber/cucumber": ">=11.0.0",
@@ -175,19 +162,30 @@
     }
   },
   "resolutions": {
-    "@cucumber/cucumber": "12.6.0",
-    "@nuxt/schema": "4.3.0",
+    "@cucumber/cucumber": "12.7.0",
+    "@nuxt/schema": "4.4.2",
     "@nuxt/test-utils": "workspace:*",
-    "@types/node": "24.10.9",
+    "@types/node": "24.12.2",
     "nitro": "https://pkg.pr.new/nitrojs/nitro@00598a8",
-    "rollup": "4.57.1",
-    "vite": "7.3.1",
-    "vite-node": "5.3.0",
-    "vitest": "4.0.18",
-    "vue": "^3.5.27"
+    "rollup": "4.60.1",
+    "vite": "8.0.5",
+    "vite-node": "6.0.0",
+    "vitest": "4.1.2",
+    "vue": "^3.5.32"
   },
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
   },
-  "packageManager": "pnpm@10.28.2"
-}
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "pnpm test:types && pnpm test:unit && pnpm test:examples",
+    "test:examples": "pnpm --filter '!@nuxt/test-utils' --filter '!example-app-cucumber' --filter '!example-app-jest' --filter '!example-app-bun' -r test && pnpm --filter example-app-cucumber -r test",
+    "test:knip": "knip",
+    "test:engines": "pnpm installed-check --no-workspaces --ignore-dev",
+    "test:types": "vue-tsc --noEmit && vitest --dir ./test/types --typecheck.only --run",
+    "test:unit": "vitest --dir ./test/unit --run",
+    "build": "unbuild",
+    "dev:prepare": "nuxt prepare && unbuild --stub && pnpm -r dev:prepare"
+  }
+}