@nuxt/test-utils-nightly 3.20.2-20251204-114711-db7a66f → 3.20.2-20251204-130215-72cf241

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

@@ -2,8 +2,7 @@ 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>);
@@ -93,6 +92,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:
@@ -120,16 +122,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.
@@ -161,9 +164,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';
@@ -100,27 +100,11 @@ async function mountSuspended(component, options) {
     cleanupFunction();
   }
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, data, computed, methods, ...componentRest } = 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);
-      });
-    }
-    return interceptedEmit;
-  }
-  function interceptEmitOnCurrentInstance() {
-    const currentInstance = getCurrentInstance();
-    if (!currentInstance) {
-      return;
-    }
-    currentInstance.emit = getInterceptedEmitFunction(currentInstance.emit);
-  }
   function patchInstanceAppContext() {
     const app = getCurrentInstance()?.appContext.app;
     if (!app) return;
@@ -129,11 +113,14 @@ async function mountSuspended(component, options) {
       app[key] = value;
     }
   }
-  let passedProps;
   let componentScope = null;
-  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) {
       let result;
       if (options?.scoped) {
@@ -148,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;
     }
@@ -157,8 +147,10 @@ async function mountSuspended(component, options) {
       const vm = mount(
         {
           __cssModules: componentRest.__cssModules,
+          inheritAttrs: false,
           setup: (props2, ctx) => {
             patchInstanceAppContext();
+            wrappedInstance = getCurrentInstance();
             setupContext = ctx;
             if (options?.scoped) {
               const scope = effectScope();
@@ -179,7 +171,7 @@ async function mountSuspended(component, options) {
               });
             }
           },
-          render: (renderContext) => h$1(
+          render: () => h$1(
             Suspense,
             {
               onResolve: () => nextTick().then(() => {
@@ -197,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);
                 }
               })
             }
@@ -255,6 +203,7 @@ async function mountSuspended(component, options) {
         defu(
           _options,
           {
+            props,
             slots,
             attrs,
             global: {
@@ -282,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";
@@ -347,27 +284,11 @@ 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, ...componentRest } = 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);
-      });
-    }
-    return interceptedEmit;
-  }
-  function interceptEmitOnCurrentInstance() {
-    const currentInstance = getCurrentInstance();
-    if (!currentInstance) {
-      return;
-    }
-    currentInstance.emit = getInterceptedEmitFunction(currentInstance.emit);
-  }
   function patchInstanceAppContext() {
     const app = getCurrentInstance()?.appContext.app;
     if (!app) return;
@@ -380,13 +301,19 @@ async function renderSuspended(component, options) {
     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;
     }
   };
@@ -400,8 +327,10 @@ async function renderSuspended(component, options) {
     const utils = renderFromTestingLibrary(
       {
         __cssModules: componentRest.__cssModules,
+        inheritAttrs: false,
         setup: (props2, ctx) => {
           patchInstanceAppContext();
+          wrappedInstance = getCurrentInstance();
           setupContext = ctx;
           const scope = effectScope();
           window.__cleanup ||= [];
@@ -413,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
@@ -440,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 : {}, ...setProps, ...attrs }, slots);
+                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...setProps, ...attrs }, setupContext.slots);
                     }
                   })
                 }
@@ -499,6 +385,7 @@ async function renderSuspended(component, options) {
         )
       },
       defu(_options, {
+        props,
         slots,
         attrs,
         global: {
@@ -519,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/test-utils-nightly",
-  "version": "3.20.2-20251204-114711-db7a66f",
+  "version": "3.20.2-20251204-130215-72cf241",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/test-utils.git"