@nuxt/test-utils 3.20.1 → 3.21.0

package/dist/config.mjs

@@ -1,42 +1,16 @@
-import process$1 from 'node:process';
+import process from 'node:process';
 import { defineConfig } from 'vite';
 import { setupDotenv } from 'c12';
 import { defu } from 'defu';
-import { createResolver, findPath, loadNuxt, buildNuxt } from '@nuxt/kit';
-import destr from 'destr';
-import { snakeCase } from 'scule';
+import { createResolver, findPath } from '@nuxt/kit';
+import { a as applyEnv, l as loadKit } from './shared/test-utils.G1ew4kEe.mjs';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
 
-function getEnv(key, opts) {
-  const env = opts.env ?? process.env;
-  const envKey = snakeCase(key).toUpperCase();
-  return destr(
-    env[opts.prefix + envKey] ?? env[opts.altPrefix + envKey]
-  );
-}
-function _isObject(input) {
-  return typeof input === "object" && !Array.isArray(input);
-}
-function applyEnv(obj, opts, parentKey = "") {
-  for (const key in obj) {
-    const subKey = parentKey ? `${parentKey}_${key}` : key;
-    const envValue = getEnv(subKey, opts);
-    if (_isObject(obj[key])) {
-      if (_isObject(envValue)) {
-        obj[key] = { ...obj[key], ...envValue };
-        applyEnv(obj[key], opts, subKey);
-      } else if (envValue === void 0) {
-        applyEnv(obj[key], opts, subKey);
-      } else {
-        obj[key] = envValue ?? obj[key];
-      }
-    } else {
-      obj[key] = envValue ?? obj[key];
-    }
-  }
-  return obj;
-}
-
-async function startNuxtAndGetViteConfig(rootDir = process$1.cwd(), options = {}) {
+async function startNuxtAndGetViteConfig(rootDir = process.cwd(), options = {}) {
+  const { buildNuxt, loadNuxt } = await loadKit(rootDir);
   const nuxt = await loadNuxt({
     cwd: rootDir,
     dev: false,
@@ -89,7 +63,7 @@ const excludedPlugins = [
   "vite-plugin-vue-tracer"
 ];
 async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
-  const { rootDir = process$1.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
+  const { rootDir = process.cwd(), ..._overrides } = loadNuxtOptions.overrides || {};
   if (!options) {
     options = await startNuxtAndGetViteConfig(rootDir, {
       dotenv: loadNuxtOptions.dotenv,
@@ -117,7 +91,7 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
         noDiscovery: true
       },
       test: {
-        dir: process$1.cwd(),
+        dir: process.cwd(),
         environmentOptions: {
           nuxtRuntimeConfig: applyEnv(structuredClone(options.nuxt.options.runtimeConfig), {
             prefix: "NUXT_",
@@ -214,14 +188,14 @@ async function getVitestConfigFromNuxt(options, loadNuxtOptions = {}) {
   return resolvedConfig;
 }
 async function defineVitestProject(config) {
-  if (process$1.env.__NUXT_VITEST_RESOLVED__) return 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$1.env.__NUXT_VITEST_RESOLVED__) return config;
+    if (process.env.__NUXT_VITEST_RESOLVED__) return config;
     const resolvedConfig = await resolveConfig(config);
     if (resolvedConfig.test.browser?.enabled) {
       return resolvedConfig;

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.CtoalVlS.mjs';
+export { b as buildFixture, c as createBrowser, a as createPage, d as createTest, g as getBrowser, l as loadFixture, e as setup, s as setupMaps, w as waitForHydration } from './shared/test-utils.3NR-so9-.mjs';
 import { u as useTestContext } from './shared/test-utils.CtwoJP76.mjs';
 export { $ as $fetch, c as createTestContext, e as exposeContextToEnv, f as fetch, i as isDev, r as recoverContextFromEnv, s as setTestContext, a as startServer, b as stopServer, d as url } from './shared/test-utils.CtwoJP76.mjs';
 import { consola } from 'consola';
@@ -7,7 +7,11 @@ import { distDir } from '#dirs';
 import 'node:fs';
 import 'node:path';
 import 'defu';
-import '@nuxt/kit';
+import './shared/test-utils.G1ew4kEe.mjs';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/module.mjs

@@ -1,21 +1,23 @@
 import { pathToFileURL } from 'node:url';
-import { useNuxt, resolveIgnorePatterns, addVitePlugin, defineNuxtModule, createResolver, resolvePath, importModule, logger } from '@nuxt/kit';
+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 { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
+import { l as loadKit } from './shared/test-utils.G1ew4kEe.mjs';
 import { readFileSync } from 'node:fs';
-import { extname, join, dirname } from 'pathe';
 import 'node:process';
 import 'vite';
 import 'c12';
 import 'destr';
 import 'scule';
+import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
 const HELPER_MOCK_IMPORT = "mockNuxtImport";
@@ -67,16 +69,16 @@ const createMockPlugin = (ctx) => createUnplugin(() => {
               startOf(node)
             );
           }
-          const importName = node.arguments[0];
-          if (!isLiteral(importName) || typeof importName.value !== "string") {
+          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`
+                `The first argument of ${HELPER_MOCK_IMPORT}() must be a string literal or mocked target`
               ),
-              startOf(importName)
+              startOf(importTarget)
             );
           }
-          const name = importName.value;
           const importItem = ctx.imports.find((_) => name === (_.as || _.name));
           if (!importItem) {
             console.log({ imports: ctx.imports });
@@ -262,8 +264,8 @@ function endOf(node) {
   return "range" in node && node.range ? node.range[1] : "end" in node ? node.end : void 0;
 }
 
-function setupImportMocking() {
-  const nuxt = useNuxt();
+async function setupImportMocking(nuxt) {
+  const { addVitePlugin } = await loadKit(nuxt.options.rootDir);
   const ctx = {
     components: [],
     imports: []
@@ -317,7 +319,7 @@ const NuxtRootStubPlugin = createUnplugin((options) => {
 });
 
 const vitePluginBlocklist = ["vite-plugin-vue-inspector", "vite-plugin-vue-inspector:post", "vite-plugin-inspect", "nuxt:type-check"];
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/test-utils",
     configKey: "testUtils"
@@ -328,8 +330,9 @@ const module = defineNuxtModule({
   },
   async setup(options, nuxt) {
     if (nuxt.options.test || nuxt.options.dev) {
-      setupImportMocking();
+      await setupImportMocking(nuxt);
     }
+    const { addVitePlugin } = await loadKit(nuxt.options.rootDir);
     const resolver = createResolver(import.meta.url);
     addVitePlugin(NuxtRootStubPlugin.vite({
       entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
@@ -339,8 +342,15 @@ const module = defineNuxtModule({
       nuxt.options.vite.define ||= {};
       nuxt.options.vite.define["import.meta.vitest"] = "undefined";
     }
-    nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ types: "vitest/import-meta" });
+    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.*")));
+        if (nuxt.options.workspaceDir !== nuxt.options.rootDir) {
+          ctx2.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;
@@ -461,4 +471,4 @@ function toArray(value) {
   return Array.isArray(value) ? value : [value];
 }
 
-export { module as default };
+export { module$1 as default };

package/dist/playwright.mjs

@@ -1,16 +1,20 @@
 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.CtoalVlS.mjs';
+import { w as waitForHydration, d as createTest } from './shared/test-utils.3NR-so9-.mjs';
 import 'node:path';
 import 'ufo';
 import 'std-env';
 import 'consola';
 import 'node:fs';
-import '@nuxt/kit';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
 import { d as url } from './shared/test-utils.CtwoJP76.mjs';
 import 'pathe';
 import '#dirs';
+import './shared/test-utils.G1ew4kEe.mjs';
 import 'tinyexec';
 import 'get-port-please';
 import 'ofetch';

package/dist/runtime/global-setup.mjs

@@ -1,13 +1,12 @@
-import * as _kit from "@nuxt/kit";
+import { consola } from "consola";
 import { createTest, exposeContextToEnv } from "@nuxt/test-utils/e2e";
-const kit = _kit.default || _kit;
 const options = JSON.parse(process.env.NUXT_TEST_OPTIONS || "{}");
 const hooks = createTest(options);
 export const setup = async () => {
-  kit.logger.info("Building Nuxt app...");
+  consola.info("Building Nuxt app...");
   await hooks.beforeAll();
   exposeContextToEnv();
-  kit.logger.info("Running tests...");
+  consola.info("Running tests...");
 };
 export const teardown = async () => {
   await hooks.afterAll();

package/dist/runtime/shared/environment.mjs

@@ -78,9 +78,6 @@ export async function setupWindow(win, environmentOptions) {
     return _fetch(input, _init);
   };
   win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
-  win.$fetch.create = (options = {}) => {
-    return createFetch({ fetch: win.fetch, Headers: win.Headers, ...options });
-  };
   win.__registry = registry;
   win.__app = h3App;
   const timestamp = Date.now();

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

@@ -2,18 +2,41 @@ import { EventHandler, HTTPMethod } from 'h3';
 import { SetupContext, RenderFunction, ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentOptionsWithoutProps, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps } from 'vue';
 import { ComponentMountingOptions, mount } from '@vue/test-utils';
 import { RouteLocationRaw } from 'vue-router';
-import * as _testing_library_vue from '@testing-library/vue';
-import { RenderOptions as RenderOptions$1 } from '@testing-library/vue';
+import { RenderOptions, RenderResult } from '@testing-library/vue';
 
 type Awaitable<T> = T | Promise<T>;
 type OptionalFunction<T> = T | (() => Awaitable<T>);
+/**
+ * `registerEndpoint` allows you create Nitro endpoint that returns mocked data. It can come in handy if you want to test a component that makes requests to API to display some data.
+ * @param url - endpoint name (e.g. `/test/`).
+ * @param options - factory function that returns the mocked data or an object containing the `handler`, `method`, and `once` properties.
+ * - `handler`: the event handler function
+ * - `method`: (optional) HTTP method to match (e.g., 'GET', 'POST')
+ * - `once`: (optional) if true, the handler will only be used for the first matching request and then automatically removed
+ * @example
+ * ```ts
+ * import { registerEndpoint } from '@nuxt/test-utils/runtime'
+ *
+ * registerEndpoint("/test/", () => ({
+ *  test: "test-field"
+ * }))
+ *
+ * // With once option
+ * registerEndpoint("/api/user", {
+ *   handler: () => ({ name: "Alice" }),
+ *   once: true
+ * })
+ * ```
+ * @see https://nuxt.com/docs/getting-started/testing#registerendpoint
+ */
 declare function registerEndpoint(url: string, options: EventHandler | {
     handler: EventHandler;
-    method: HTTPMethod;
+    method?: HTTPMethod;
+    once?: boolean;
 }): () => void;
 /**
  * `mockNuxtImport` allows you to mock Nuxt's auto import functionality.
- * @param _name - name of an import to mock.
+ * @param _target - name of an import to mock or mocked target.
  * @param _factory - factory function that returns mocked import.
  * @example
  * ```ts
@@ -24,10 +47,17 @@ declare function registerEndpoint(url: string, options: EventHandler | {
  *    return { value: 'mocked storage' }
  *  }
  * })
+ *
+ * // With mocked target
+ * mockNuxtImport(useStorage, () => {
+ *  return () => {
+ *    return { value: 'mocked storage' }
+ *  }
+ * })
  * ```
  * @see https://nuxt.com/docs/getting-started/testing#mocknuxtimport
  */
-declare function mockNuxtImport<T = unknown>(_name: string, _factory: () => T | Promise<T>): void;
+declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: () => 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.
@@ -69,6 +99,9 @@ type MountSuspendedOptions<T> = ComponentMountingOptions<T> & {
     route?: RouteLocationRaw;
     scoped?: boolean;
 };
+type MountSuspendedResult<T> = ReturnType<typeof mount<T>> & {
+    setupState: SetupState$1;
+};
 type SetupState$1 = Record<string, any>;
 /**
  * `mountSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins. For example:
@@ -96,16 +129,17 @@ type SetupState$1 = Record<string, any>;
  * @param component the component to be tested
  * @param options optional options to set up your component
  */
-declare function mountSuspended<T>(component: T, options?: MountSuspendedOptions<T>): Promise<ReturnType<typeof mount<T>> & {
-    setupState: SetupState$1;
-}>;
+declare function mountSuspended<T>(component: T, options?: MountSuspendedOptions<T>): Promise<MountSuspendedResult<T>>;
 declare global {
     var __cleanup: Array<() => void> | undefined;
 }
 
-type RenderOptions<C = unknown> = RenderOptions$1<C> & {
+type RenderSuspendeOptions<T> = RenderOptions<T> & {
     route?: RouteLocationRaw;
 };
+type RenderSuspendeResult = RenderResult & {
+    setupState: SetupState;
+};
 type SetupState = Record<string, any>;
 /**
  * `renderSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins.
@@ -137,9 +171,7 @@ type SetupState = Record<string, any>;
  * @param component the component to be tested
  * @param options optional options to set up your component
  */
-declare function renderSuspended<T>(component: T, options?: RenderOptions<T>): Promise<_testing_library_vue.RenderResult & {
-    setupState: SetupState;
-}>;
+declare function renderSuspended<T>(component: T, options?: RenderSuspendeOptions<T>): Promise<RenderSuspendeResult>;
 declare global {
     interface Window {
         __cleanup?: Array<() => void>;

package/dist/runtime-utils/index.mjs

@@ -1,6 +1,6 @@
 import { defineEventHandler } from 'h3';
 import { mount } from '@vue/test-utils';
-import { reactive, h as h$1, Suspense, nextTick, effectScope, unref, isReadonly, getCurrentInstance, isRef, defineComponent as defineComponent$1 } from 'vue';
+import { reactive, h as h$1, Suspense, nextTick, getCurrentInstance, effectScope, defineComponent as defineComponent$1 } from 'vue';
 import { defu } from 'defu';
 import { defineComponent, useRouter, h, tryUseNuxtApp } from '#imports';
 import NuxtRoot from '#build/root-component.mjs';
@@ -11,16 +11,25 @@ function registerEndpoint(url, options) {
   if (!app) {
     throw new Error("registerEndpoint() can only be used in a `@nuxt/test-utils` runtime environment");
   }
-  const config = typeof options === "function" ? { handler: options, method: void 0 } : options;
+  const config = typeof options === "function" ? { handler: options, method: void 0, once: false } : options;
   config.handler = defineEventHandler(config.handler);
   const hasBeenRegistered = window.__registry.has(url);
   endpointRegistry[url] ||= [];
   endpointRegistry[url].push(config);
   if (!hasBeenRegistered) {
     window.__registry.add(url);
-    app.use("/_" + url, defineEventHandler((event) => {
+    app.use("/_" + url, defineEventHandler(async (event) => {
       const latestHandler = [...endpointRegistry[url] || []].reverse().find((config2) => config2.method ? event.method === config2.method : true);
-      return latestHandler?.handler(event);
+      if (!latestHandler) return;
+      const result = await latestHandler.handler(event);
+      if (!latestHandler.once) return result;
+      const index = endpointRegistry[url]?.indexOf(latestHandler);
+      if (index === void 0 || index === -1) return result;
+      endpointRegistry[url]?.splice(index, 1);
+      if (endpointRegistry[url]?.length === 0) {
+        window.__registry.delete(url);
+      }
+      return result;
     }), {
       match(_, event) {
         return endpointRegistry[url]?.some((config2) => config2.method ? event?.method === config2.method : true) ?? false;
@@ -34,7 +43,7 @@ function registerEndpoint(url, options) {
     }
   };
 }
-function mockNuxtImport(_name, _factory) {
+function mockNuxtImport(_target, _factory) {
   throw new Error(
     "mockNuxtImport() is a macro and it did not get transpiled. This may be an internal bug of @nuxt/test-utils."
   );
@@ -91,32 +100,27 @@ async function mountSuspended(component, options) {
     cleanupFunction();
   }
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, data, computed, methods } = component;
+  const { render, setup, ...componentRest } = component;
+  let wrappedInstance = null;
   let setupContext;
   let setupState;
   const setProps = reactive({});
-  let interceptedEmit = null;
-  function getInterceptedEmitFunction(emit) {
-    if (emit !== interceptedEmit) {
-      interceptedEmit = interceptedEmit ?? ((event, ...args) => {
-        emit(event, ...args);
-        setupContext.emit(event, ...args);
-      });
+  function patchInstanceAppContext() {
+    const app = getCurrentInstance()?.appContext.app;
+    if (!app) return;
+    for (const [key, value] of Object.entries(vueApp)) {
+      if (key in app) continue;
+      app[key] = value;
     }
-    return interceptedEmit;
   }
-  function interceptEmitOnCurrentInstance() {
+  let componentScope = null;
+  const wrappedSetup = async (props2, setupContext2, instanceContext) => {
     const currentInstance = getCurrentInstance();
-    if (!currentInstance) {
-      return;
+    if (currentInstance) {
+      currentInstance.emit = (event, ...args) => {
+        setupContext2.emit(event, ...args);
+      };
     }
-    currentInstance.emit = getInterceptedEmitFunction(currentInstance.emit);
-  }
-  let passedProps;
-  let componentScope = null;
-  const wrappedSetup = async (props2, setupContext2) => {
-    interceptEmitOnCurrentInstance();
-    passedProps = props2;
     if (setup) {
       let result;
       if (options?.scoped) {
@@ -131,6 +135,9 @@ async function mountSuspended(component, options) {
       } else {
         result = await setup(props2, setupContext2);
       }
+      if (wrappedInstance?.exposed) {
+        instanceContext.expose(wrappedInstance.exposed);
+      }
       setupState = result && typeof result === "object" ? result : {};
       return result;
     }
@@ -139,7 +146,11 @@ async function mountSuspended(component, options) {
     (resolve) => {
       const vm = mount(
         {
+          __cssModules: componentRest.__cssModules,
+          inheritAttrs: false,
           setup: (props2, ctx) => {
+            patchInstanceAppContext();
+            wrappedInstance = getCurrentInstance();
             setupContext = ctx;
             if (options?.scoped) {
               const scope = effectScope();
@@ -160,7 +171,7 @@ async function mountSuspended(component, options) {
               });
             }
           },
-          render: (renderContext) => h$1(
+          render: () => h$1(
             Suspense,
             {
               onResolve: () => nextTick().then(() => {
@@ -178,56 +189,12 @@ async function mountSuspended(component, options) {
                   const router = useRouter();
                   await router.replace(route);
                   const clonedComponent = {
-                    name: "MountSuspendedComponent",
+                    components: {},
                     ...component,
-                    render: render ? function(_ctx, ...args) {
-                      interceptEmitOnCurrentInstance();
-                      if (data && typeof data === "function") {
-                        const dataObject = data();
-                        for (const key in dataObject) {
-                          renderContext[key] = dataObject[key];
-                        }
-                      }
-                      for (const key in setupState || {}) {
-                        const warn = console.warn;
-                        console.warn = () => {
-                        };
-                        try {
-                          renderContext[key] = isReadonly(setupState[key]) ? unref(setupState[key]) : setupState[key];
-                        } catch {
-                        } finally {
-                          console.warn = warn;
-                        }
-                        if (key === "props") {
-                          renderContext[key] = cloneProps$1(renderContext[key]);
-                        }
-                      }
-                      const propsContext = "props" in renderContext ? renderContext.props : renderContext;
-                      for (const key in props || {}) {
-                        propsContext[key] = _ctx[key];
-                      }
-                      for (const key in passedProps || {}) {
-                        propsContext[key] = passedProps[key];
-                      }
-                      if (methods && typeof methods === "object") {
-                        for (const [key, value] of Object.entries(methods)) {
-                          renderContext[key] = value.bind(renderContext);
-                        }
-                      }
-                      if (computed && typeof computed === "object") {
-                        for (const [key, value] of Object.entries(computed)) {
-                          if ("get" in value) {
-                            renderContext[key] = value.get.call(renderContext);
-                          } else {
-                            renderContext[key] = value.call(renderContext);
-                          }
-                        }
-                      }
-                      return render.call(this, renderContext, ...args);
-                    } : void 0,
-                    setup: (props2) => wrappedSetup(props2, setupContext)
+                    name: "MountSuspendedComponent",
+                    setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
                   };
-                  return () => h$1(clonedComponent, { ...props, ...setProps, ...attrs }, slots);
+                  return () => h$1(clonedComponent, { ...props, ...setProps, ...attrs }, setupContext.slots);
                 }
               })
             }
@@ -236,11 +203,18 @@ async function mountSuspended(component, options) {
         defu(
           _options,
           {
+            props,
             slots,
             attrs,
             global: {
               config: {
-                globalProperties: vueApp.config.globalProperties
+                globalProperties: {
+                  ...vueApp.config.globalProperties,
+                  // make all properties/keys enumerable.
+                  ...Object.fromEntries(
+                    Object.getOwnPropertyNames(vueApp.config.globalProperties).map((key) => [key, vueApp.config.globalProperties[key]])
+                  )
+                }
               },
               directives: vueApp._context.directives,
               provide: vueApp._context.provides,
@@ -257,58 +231,46 @@ async function mountSuspended(component, options) {
     }
   );
 }
-function cloneProps$1(props) {
-  const newProps = reactive({});
-  for (const key in props) {
-    newProps[key] = props[key];
-  }
-  return newProps;
-}
 function wrappedMountedWrapper(wrapper) {
-  const proxy = new Proxy(wrapper, {
-    get: (target, prop, receiver) => {
-      if (prop === "element") {
-        const component = target.findComponent({ name: "MountSuspendedComponent" });
-        return component[prop];
-      } else if (prop === "vm") {
-        const vm = Reflect.get(target, prop, receiver);
-        return createVMProxy(vm, wrapper.setupState);
-      } else {
-        return Reflect.get(target, prop, receiver);
-      }
+  const component = wrapper.findComponent({ name: "MountSuspendedComponent" });
+  const wrapperProps = [
+    "setProps",
+    "emitted",
+    "setupState",
+    "unmount"
+  ];
+  return new Proxy(wrapper, {
+    get: (_, prop, receiver) => {
+      if (prop === "getCurrentComponent") return getCurrentComponentPatchedProxy;
+      const target = wrapperProps.includes(prop) ? wrapper : Reflect.has(component, prop) ? component : wrapper;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
     }
   });
-  for (const key of ["props"]) {
-    proxy[key] = new Proxy(wrapper[key], {
-      apply: (target, thisArg, args) => {
-        const component = thisArg.findComponent({ name: "MountSuspendedComponent" });
-        return component[key](...args);
+  function getCurrentComponentPatchedProxy() {
+    const currentComponent = component.getCurrentComponent();
+    return new Proxy(currentComponent, {
+      get: (target, prop, receiver) => {
+        const value = Reflect.get(target, prop, receiver);
+        if (prop === "proxy" && value) {
+          return new Proxy(value, {
+            get(o, p, r) {
+              if (!Reflect.has(currentComponent.props, p)) {
+                const setupState = wrapper.setupState;
+                if (setupState && typeof setupState === "object") {
+                  if (Reflect.has(setupState, p)) {
+                    return Reflect.get(setupState, p, r);
+                  }
+                }
+              }
+              return Reflect.get(o, p, r);
+            }
+          });
+        }
+        return value;
       }
     });
   }
-  return proxy;
-}
-function createVMProxy(vm, setupState) {
-  return new Proxy(vm, {
-    get(target, key, receiver) {
-      const value = Reflect.get(target, key, receiver);
-      if (setupState && typeof setupState === "object" && key in setupState) {
-        return unref(setupState[key]);
-      }
-      return value;
-    },
-    set(target, key, value, receiver) {
-      if (setupState && typeof setupState === "object" && key in setupState) {
-        const setupValue = setupState[key];
-        if (setupValue && isRef(setupValue)) {
-          setupValue.value = value;
-          return true;
-        }
-        return Reflect.set(setupState, key, value, receiver);
-      }
-      return Reflect.set(target, key, value, receiver);
-    }
-  });
 }
 
 const WRAPPER_EL_ID = "test-wrapper";
@@ -322,37 +284,36 @@ async function renderSuspended(component, options) {
   } = options || {};
   const { render: renderFromTestingLibrary } = await import('@testing-library/vue');
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, data, computed, methods } = component;
+  const { render, setup, ...componentRest } = component;
+  let wrappedInstance = null;
   let setupContext;
   let setupState;
-  let interceptedEmit = null;
-  function getInterceptedEmitFunction(emit) {
-    if (emit !== interceptedEmit) {
-      interceptedEmit = interceptedEmit ?? ((event, ...args) => {
-        emit(event, ...args);
-        setupContext.emit(event, ...args);
-      });
-    }
-    return interceptedEmit;
-  }
-  function interceptEmitOnCurrentInstance() {
-    const currentInstance = getCurrentInstance();
-    if (!currentInstance) {
-      return;
+  const setProps = reactive({});
+  function patchInstanceAppContext() {
+    const app = getCurrentInstance()?.appContext.app;
+    if (!app) return;
+    for (const [key, value] of Object.entries(vueApp)) {
+      if (key in app) continue;
+      app[key] = value;
     }
-    currentInstance.emit = getInterceptedEmitFunction(currentInstance.emit);
   }
   for (const fn of window.__cleanup || []) {
     fn();
   }
   document.querySelector(`#${WRAPPER_EL_ID}`)?.remove();
-  let passedProps;
-  const wrappedSetup = async (props2, setupContext2) => {
-    interceptEmitOnCurrentInstance();
-    passedProps = props2;
+  const wrappedSetup = async (props2, setupContext2, instanceContext) => {
+    const currentInstance = getCurrentInstance();
+    if (currentInstance) {
+      currentInstance.emit = (event, ...args) => {
+        setupContext2.emit(event, ...args);
+      };
+    }
     if (setup) {
       const result = await setup(props2, setupContext2);
       setupState = result && typeof result === "object" ? result : {};
+      if (wrappedInstance?.exposed) {
+        instanceContext.expose(wrappedInstance.exposed);
+      }
       return result;
     }
   };
@@ -365,7 +326,11 @@ async function renderSuspended(component, options) {
   return new Promise((resolve) => {
     const utils = renderFromTestingLibrary(
       {
+        __cssModules: componentRest.__cssModules,
+        inheritAttrs: false,
         setup: (props2, ctx) => {
+          patchInstanceAppContext();
+          wrappedInstance = getCurrentInstance();
           setupContext = ctx;
           const scope = effectScope();
           window.__cleanup ||= [];
@@ -377,7 +342,7 @@ async function renderSuspended(component, options) {
             expose: () => ({})
           }));
         },
-        render: (renderContext) => (
+        render: () => (
           // See discussions in https://github.com/testing-library/vue-testing-library/issues/230
           // we add this additional root element because otherwise testing-library breaks
           // because there's no root element while Suspense is resolving
@@ -390,6 +355,10 @@ async function renderSuspended(component, options) {
                 {
                   onResolve: () => nextTick().then(() => {
                     utils.setupState = setupState;
+                    utils.rerender = async (props2) => {
+                      Object.assign(setProps, props2);
+                      await nextTick();
+                    };
                     resolve(utils);
                   })
                 },
@@ -400,56 +369,13 @@ async function renderSuspended(component, options) {
                       const router = useRouter();
                       await router.replace(route);
                       const clonedComponent = {
-                        name: "RenderSuspendedComponent",
+                        components: {},
                         ...component,
-                        render: render ? function(_ctx, ...args) {
-                          interceptEmitOnCurrentInstance();
-                          if (data && typeof data === "function") {
-                            const dataObject = data();
-                            for (const key in dataObject) {
-                              renderContext[key] = dataObject[key];
-                            }
-                          }
-                          for (const key in setupState || {}) {
-                            const warn = console.warn;
-                            console.warn = () => {
-                            };
-                            try {
-                              renderContext[key] = isReadonly(setupState[key]) ? unref(setupState[key]) : setupState[key];
-                            } catch {
-                            } finally {
-                              console.warn = warn;
-                            }
-                            if (key === "props") {
-                              renderContext[key] = cloneProps(renderContext[key]);
-                            }
-                          }
-                          const propsContext = "props" in renderContext ? renderContext.props : renderContext;
-                          for (const key in props || {}) {
-                            propsContext[key] = _ctx[key];
-                          }
-                          for (const key in passedProps || {}) {
-                            propsContext[key] = passedProps[key];
-                          }
-                          if (methods && typeof methods === "object") {
-                            for (const [key, value] of Object.entries(methods)) {
-                              renderContext[key] = value.bind(renderContext);
-                            }
-                          }
-                          if (computed && typeof computed === "object") {
-                            for (const [key, value] of Object.entries(computed)) {
-                              if ("get" in value) {
-                                renderContext[key] = value.get.call(renderContext);
-                              } else {
-                                renderContext[key] = value.call(renderContext);
-                              }
-                            }
-                          }
-                          return render.call(this, renderContext, ...args);
-                        } : void 0,
-                        setup: (props2) => wrappedSetup(props2, setupContext)
+                        name: "RenderSuspendedComponent",
+                        render,
+                        setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
                       };
-                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...attrs }, slots);
+                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...setProps, ...attrs }, setupContext.slots);
                     }
                   })
                 }
@@ -459,11 +385,18 @@ async function renderSuspended(component, options) {
         )
       },
       defu(_options, {
+        props,
         slots,
         attrs,
         global: {
           config: {
-            globalProperties: vueApp.config.globalProperties
+            globalProperties: {
+              ...vueApp.config.globalProperties,
+              // make all properties/keys enumerable.
+              ...Object.fromEntries(
+                Object.getOwnPropertyNames(vueApp.config.globalProperties).map((key) => [key, vueApp.config.globalProperties[key]])
+              )
+            }
           },
           directives: vueApp._context.directives,
           provide: vueApp._context.provides,
@@ -473,12 +406,5 @@ async function renderSuspended(component, options) {
     );
   });
 }
-function cloneProps(props) {
-  const newProps = reactive({});
-  for (const key in props) {
-    newProps[key] = props[key];
-  }
-  return newProps;
-}
 
 export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };

package/dist/shared/{test-utils.CtoalVlS.mjs → test-utils.3NR-so9-.mjs}

@@ -2,7 +2,7 @@ import { u as useTestContext, d as url, c as createTestContext, a as startServer
 import { existsSync, promises } from 'node:fs';
 import { resolve } from 'node:path';
 import { defu } from 'defu';
-import * as _kit from '@nuxt/kit';
+import { l as loadKit } from './test-utils.G1ew4kEe.mjs';
 
 async function createBrowser() {
   const ctx = useTestContext();
@@ -57,7 +57,6 @@ async function waitForHydration(page, url2, waitUntil) {
   }
 }
 
-const kit = _kit.default || _kit;
 const isNuxtApp = (dir) => {
   return existsSync(dir) && (existsSync(resolve(dir, "pages")) || existsSync(resolve(dir, "nuxt.config.js")) || existsSync(resolve(dir, "nuxt.config.mjs")) || existsSync(resolve(dir, "nuxt.config.cjs")) || existsSync(resolve(dir, "nuxt.config.ts")) || existsSync(resolve(dir, ".config", "nuxt.js")) || existsSync(resolve(dir, ".config", "nuxt.mjs")) || existsSync(resolve(dir, ".config", "nuxt.cjs")) || existsSync(resolve(dir, ".config", "nuxt.ts")));
 };
@@ -91,7 +90,8 @@ async function loadFixture() {
     });
   }
   if (ctx.options.build) {
-    ctx.nuxt = await kit.loadNuxt({
+    const { loadNuxt } = await loadKit(ctx.options.rootDir);
+    ctx.nuxt = await loadNuxt({
       cwd: ctx.options.rootDir,
       dev: ctx.options.dev,
       overrides: ctx.options.nuxtConfig,
@@ -107,10 +107,11 @@ async function loadFixture() {
 }
 async function buildFixture() {
   const ctx = useTestContext();
-  const prevLevel = kit.logger.level;
-  kit.logger.level = ctx.options.logLevel;
-  await kit.buildNuxt(ctx.nuxt);
-  kit.logger.level = prevLevel;
+  const { buildNuxt, logger } = await loadKit(ctx.options.rootDir);
+  const prevLevel = logger.level;
+  logger.level = ctx.options.logLevel;
+  await buildNuxt(ctx.nuxt);
+  logger.level = prevLevel;
 }
 
 async function setupBun(hooks) {

package/dist/shared/test-utils.G1ew4kEe.mjs

@@ -0,0 +1,67 @@
+import destr from 'destr';
+import { snakeCase } from 'scule';
+import { pathToFileURL } from 'node:url';
+import { resolveModulePath } from 'exsolve';
+
+function getEnv(key, opts) {
+  const env = opts.env ?? process.env;
+  const envKey = snakeCase(key).toUpperCase();
+  return destr(
+    env[opts.prefix + envKey] ?? env[opts.altPrefix + envKey]
+  );
+}
+function _isObject(input) {
+  return typeof input === "object" && !Array.isArray(input);
+}
+function applyEnv(obj, opts, parentKey = "") {
+  for (const key in obj) {
+    const subKey = parentKey ? `${parentKey}_${key}` : key;
+    const envValue = getEnv(subKey, opts);
+    if (_isObject(obj[key])) {
+      if (_isObject(envValue)) {
+        obj[key] = { ...obj[key], ...envValue };
+        applyEnv(obj[key], opts, subKey);
+      } else if (envValue === void 0) {
+        applyEnv(obj[key], opts, subKey);
+      } else {
+        obj[key] = envValue ?? obj[key];
+      }
+    } else {
+      obj[key] = envValue ?? obj[key];
+    }
+  }
+  return obj;
+}
+async function loadKit(rootDir) {
+  try {
+    const kitPath = resolveModulePath("@nuxt/kit", { from: tryResolveNuxt(rootDir) || rootDir });
+    let kit = await import(pathToFileURL(kitPath).href);
+    if (!kit.writeTypes) {
+      kit = {
+        ...kit,
+        writeTypes: () => {
+          throw new Error("`writeTypes` is not available in this version of `@nuxt/kit`. Please upgrade to v3.7 or newer.");
+        }
+      };
+    }
+    return kit;
+  } catch (e) {
+    if (e.toString().includes("Cannot find module '@nuxt/kit'")) {
+      throw new Error(
+        "nuxi requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3+ or `@nuxt/bridge` first."
+      );
+    }
+    throw e;
+  }
+}
+function tryResolveNuxt(rootDir) {
+  for (const pkg of ["nuxt-nightly", "nuxt", "nuxt3", "nuxt-edge"]) {
+    const path = resolveModulePath(pkg, { from: rootDir, try: true });
+    if (path) {
+      return path;
+    }
+  }
+  return null;
+}
+
+export { applyEnv as a, loadKit as l };

package/dist/vitest-environment.mjs

@@ -83,9 +83,6 @@ async function setupWindow(win, environmentOptions) {
     return _fetch(input, _init);
   };
   win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
-  win.$fetch.create = (options = {}) => {
-    return createFetch({ fetch: win.fetch, Headers: win.Headers, ...options });
-  };
   win.__registry = registry;
   win.__app = h3App;
   const timestamp = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils",
-  "version": "3.20.1",
+  "version": "3.21.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"
@@ -67,40 +67,41 @@
     "dev:prepare": "nuxt prepare && unbuild --stub && pnpm -r dev:prepare"
   },
   "dependencies": {
-    "@nuxt/kit": "^4.1.3",
-    "c12": "^3.3.1",
+    "@nuxt/kit": "^3.20.1",
+    "c12": "^3.3.2",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "destr": "^2.0.5",
     "estree-walker": "^3.0.3",
-    "fake-indexeddb": "^6.2.4",
+    "exsolve": "^1.0.8",
+    "fake-indexeddb": "^6.2.5",
     "get-port-please": "^3.2.0",
     "h3": "^1.15.4",
     "local-pkg": "^1.1.2",
-    "magic-string": "^0.30.19",
+    "magic-string": "^0.30.21",
     "node-fetch-native": "^1.6.7",
     "node-mock-http": "^1.0.3",
-    "ofetch": "^1.4.1",
+    "ofetch": "^1.5.1",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.0.0",
     "radix3": "^1.1.2",
     "scule": "^1.3.0",
     "std-env": "^3.10.0",
-    "tinyexec": "^1.0.1",
+    "tinyexec": "^1.0.2",
     "ufo": "^1.6.1",
-    "unplugin": "^2.3.10",
+    "unplugin": "^2.3.11",
     "vitest-environment-nuxt": "^1.0.1",
-    "vue": "^3.5.22"
+    "vue": "^3.5.25"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "12.2.0",
+    "@cucumber/cucumber": "12.3.0",
     "@jest/globals": "30.2.0",
-    "@nuxt/devtools-kit": "2.6.5",
-    "@nuxt/eslint-config": "1.9.0",
-    "@nuxt/schema": "4.1.3",
-    "@playwright/test": "1.56.1",
+    "@nuxt/devtools-kit": "2.7.0",
+    "@nuxt/eslint-config": "1.11.0",
+    "@nuxt/schema": "4.2.1",
+    "@playwright/test": "1.57.0",
     "@testing-library/vue": "8.1.0",
-    "@types/bun": "1.3.0",
+    "@types/bun": "1.3.3",
     "@types/estree": "1.0.8",
     "@types/jsdom": "27.0.0",
     "@types/node": "latest",
@@ -108,22 +109,22 @@
     "@vue/test-utils": "2.4.6",
     "changelogen": "0.6.2",
     "compatx": "0.2.0",
-    "eslint": "9.38.0",
+    "eslint": "9.39.1",
     "installed-check": "9.3.0",
-    "knip": "5.66.2",
-    "nitropack": "2.12.7",
-    "nuxt": "4.1.3",
-    "pkg-pr-new": "0.0.60",
-    "playwright-core": "1.56.1",
-    "rollup": "4.52.5",
+    "knip": "5.71.0",
+    "nitropack": "2.12.9",
+    "nuxt": "4.2.1",
+    "pkg-pr-new": "0.0.62",
+    "playwright-core": "1.57.0",
+    "rollup": "4.53.3",
     "semver": "7.7.3",
     "typescript": "5.9.3",
     "unbuild": "latest",
     "unimport": "5.5.0",
-    "vite": "7.1.11",
+    "vite": "7.2.6",
     "vitest": "3.2.4",
     "vue-router": "4.6.3",
-    "vue-tsc": "3.1.1"
+    "vue-tsc": "3.1.5"
   },
   "peerDependencies": {
     "@cucumber/cucumber": "^10.3.1 || >=11.0.0",
@@ -169,31 +170,18 @@
     }
   },
   "resolutions": {
-    "@cucumber/cucumber": "12.2.0",
-    "@nuxt/kit": "^4.1.3",
-    "@nuxt/schema": "4.1.3",
+    "@cucumber/cucumber": "12.3.0",
+    "@nuxt/schema": "4.2.1",
     "@nuxt/test-utils": "workspace:*",
-    "@types/node": "22.18.8",
-    "rollup": "4.52.5",
-    "vite": "7.1.11",
-    "vite-node": "3.2.4",
+    "@types/node": "24.10.1",
+    "rollup": "4.53.3",
+    "vite": "7.2.6",
+    "vite-node": "5.2.0",
     "vitest": "3.2.4",
-    "vue": "^3.5.22"
+    "vue": "^3.5.25"
   },
   "engines": {
     "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
   },
-  "packageManager": "pnpm@10.18.3",
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "@tailwindcss/oxide",
-      "better-sqlite3"
-    ],
-    "ignoredBuiltDependencies": [
-      "esbuild",
-      "oxc-resolver",
-      "unrs-resolver",
-      "vue-demi"
-    ]
-  }
+  "packageManager": "pnpm@10.24.0"
 }