@nuxt/test-utils 3.21.0 → 3.22.0

package/dist/playwright.mjs

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

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

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

package/dist/runtime/shared/nuxt.mjs

@@ -1,7 +1,15 @@
+import { getVueWrapperPlugin } from "./vue-wrapper-plugin.mjs";
 export async function setupNuxt() {
   const { useRouter } = await import("#app/composables/router");
   await import("#app/nuxt-vitest-app-entry").then((r) => r.default());
   const nuxtApp = useNuxtApp();
-  await nuxtApp.callHook("page:finish");
-  useRouter().afterEach(() => nuxtApp.callHook("page:finish"));
+  function sync() {
+    return nuxtApp._route.sync ? nuxtApp._route.sync() : nuxtApp.callHook("page:finish");
+  }
+  const { hasNuxtPage } = getVueWrapperPlugin();
+  useRouter().afterEach(() => {
+    if (hasNuxtPage()) return;
+    return sync();
+  });
+  return sync();
 }

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

@@ -0,0 +1,50 @@
+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;
+    hasNuxtPage(): boolean;
+    _hasComponent(componentName: string): boolean;
+};
+export {};

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

@@ -0,0 +1,41 @@
+import { config } from "@vue/test-utils";
+const PLUGIN_NAME = "nuxt-test-utils";
+export function getVueWrapperPlugin() {
+  const installed = config.plugins.VueWrapper.installedPlugins.find(({ options: options2 }) => options2._name === PLUGIN_NAME);
+  if (installed) return installed.options;
+  const options = createPluginOptions();
+  config.plugins.VueWrapper.install((instance, options2) => {
+    options2.addInstance(instance);
+    return {};
+  }, options);
+  return options;
+}
+function createPluginOptions() {
+  const options = {
+    _name: PLUGIN_NAME,
+    _instances: [],
+    get instances() {
+      const instances = [];
+      options._instances = options._instances.filter((ref) => {
+        const instance = ref.deref();
+        if (!instance) return false;
+        instances.push(instance);
+        return true;
+      });
+      return instances;
+    },
+    addInstance(instance) {
+      if (options.instances.includes(instance)) return;
+      options._instances.push(new WeakRef(instance));
+    },
+    hasNuxtPage() {
+      return options._hasComponent("NuxtPage");
+    },
+    _hasComponent(componentName) {
+      return options.instances.some(
+        (v) => v.exists() && v.findComponent({ name: componentName }).exists()
+      );
+    }
+  };
+  return options;
+}

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

@@ -1,8 +1,8 @@
 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 { mount } from '@vue/test-utils';
 import { RouteLocationRaw } from 'vue-router';
-import { RenderOptions, RenderResult } from '@testing-library/vue';
+import { render } from '@testing-library/vue';
 
 type Awaitable<T> = T | Promise<T>;
 type OptionalFunction<T> = T | (() => Awaitable<T>);
@@ -95,14 +95,26 @@ declare function mockComponent<Props = {}, RawBindings = {}, D = {}, C extends C
 declare function mockComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
 declare function mockComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(path: string, options: OptionalFunction<ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>>): void;
 
-type MountSuspendedOptions<T> = ComponentMountingOptions<T> & {
-    route?: RouteLocationRaw;
+type SetupState = Record<string, any>;
+type WrapperFnComponent<Fn> = Fn extends (c: infer C, o: infer _) => infer _ ? C : never;
+type WrapperFnOption<Fn> = Fn extends (c: WrapperFnComponent<Fn>, o: infer O) => infer _ ? O : never;
+type WrapperFnResult<Fn> = Fn extends (c: WrapperFnComponent<Fn>, o: WrapperFnOption<Fn>) => infer R ? R : never;
+type WrapperSuspendedOptions<Fn> = WrapperFnOption<Fn> & {
+    route?: RouteLocationRaw | false;
     scoped?: boolean;
 };
-type MountSuspendedResult<T> = ReturnType<typeof mount<T>> & {
-    setupState: SetupState$1;
+type WrapperSuspendedResult<Fn> = WrapperFnResult<Fn> & {
+    setupState: SetupState;
 };
-type SetupState$1 = Record<string, any>;
+declare global {
+    interface Window {
+        __cleanup?: Array<() => void>;
+    }
+}
+
+type WrapperFn$1<C> = typeof mount<C>;
+type WrapperOptions$1<C> = WrapperSuspendedOptions<WrapperFn$1<C>>;
+type WrapperResult$1<C> = WrapperSuspendedResult<WrapperFn$1<C>>;
 /**
  * `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:
  *
@@ -129,18 +141,11 @@ 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<MountSuspendedResult<T>>;
-declare global {
-    var __cleanup: Array<() => void> | undefined;
-}
+declare function mountSuspended<T>(component: T, options?: WrapperOptions$1<T>): Promise<WrapperResult$1<T>>;
 
-type RenderSuspendeOptions<T> = RenderOptions<T> & {
-    route?: RouteLocationRaw;
-};
-type RenderSuspendeResult = RenderResult & {
-    setupState: SetupState;
-};
-type SetupState = Record<string, any>;
+type WrapperFn<C> = typeof render<C>;
+type WrapperOptions<C> = WrapperSuspendedOptions<WrapperFn<C>>;
+type WrapperResult<C> = WrapperSuspendedResult<WrapperFn<C>>;
 /**
  * `renderSuspended` allows you to mount any vue component within the Nuxt environment, allowing async setup and access to injections from your Nuxt plugins.
  *
@@ -171,11 +176,6 @@ 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?: RenderSuspendeOptions<T>): Promise<RenderSuspendeResult>;
-declare global {
-    interface Window {
-        __cleanup?: Array<() => void>;
-    }
-}
+declare function renderSuspended<T>(component: T, options?: WrapperOptions<T>): Promise<WrapperResult<T>>;
 
 export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };

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, getCurrentInstance, effectScope, defineComponent as defineComponent$1 } from 'vue';
+import { reactive, h as h$1, Suspense, nextTick as nextTick$1, getCurrentInstance, onErrorCaptured, effectScope } from 'vue';
 import { defu } from 'defu';
 import { defineComponent, useRouter, h, tryUseNuxtApp } from '#imports';
 import NuxtRoot from '#build/root-component.mjs';
@@ -88,19 +88,34 @@ const RouterLink = defineComponent({
   }
 });
 
-async function mountSuspended(component, options) {
-  const {
-    props = {},
-    attrs = {},
-    slots = {},
-    route = "/",
-    ..._options
-  } = options || {};
-  for (const cleanupFunction of globalThis.__cleanup || []) {
-    cleanupFunction();
+function cleanupAll() {
+  for (const fn of (window.__cleanup || []).splice(0)) {
+    fn();
   }
+}
+function addCleanup(fn) {
+  window.__cleanup ||= [];
+  window.__cleanup.push(fn);
+}
+function runEffectScope(fn) {
+  const scope = effectScope();
+  addCleanup(() => scope.stop());
+  return scope.run(fn);
+}
+function wrapperSuspended(component, options, {
+  wrapperFn,
+  wrappedRender = (fn) => fn,
+  suspendedHelperName,
+  clonedComponentName
+}) {
+  const { props = {}, attrs = {} } = options;
+  const { route = "/", scoped = false, ...wrapperFnOptions } = options;
   const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, ...componentRest } = component;
+  const {
+    render: componentRender,
+    setup: componentSetup,
+    ...componentRest
+  } = component;
   let wrappedInstance = null;
   let setupContext;
   let setupState;
@@ -113,28 +128,19 @@ async function mountSuspended(component, options) {
       app[key] = value;
     }
   }
-  let componentScope = null;
-  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) {
-        componentScope = effectScope();
-        globalThis.__cleanup ||= [];
-        globalThis.__cleanup.push(() => {
-          componentScope?.stop();
-        });
-        result = await componentScope?.run(async () => {
-          return await setup(props2, setupContext2);
-        });
-      } else {
-        result = await setup(props2, setupContext2);
+  const ClonedComponent = {
+    components: {},
+    ...component,
+    name: clonedComponentName,
+    async setup(props2, instanceContext) {
+      const currentInstance = getCurrentInstance();
+      if (currentInstance) {
+        currentInstance.emit = (event, ...args) => {
+          setupContext.emit(event, ...args);
+        };
       }
+      if (!componentSetup) return;
+      const result = scoped ? await runEffectScope(() => componentSetup(props2, setupContext)) : await componentSetup(props2, setupContext);
       if (wrappedInstance?.exposed) {
         instanceContext.expose(wrappedInstance.exposed);
       }
@@ -142,97 +148,110 @@ async function mountSuspended(component, options) {
       return result;
     }
   };
-  return new Promise(
-    (resolve) => {
-      const vm = mount(
-        {
-          __cssModules: componentRest.__cssModules,
-          inheritAttrs: false,
-          setup: (props2, ctx) => {
-            patchInstanceAppContext();
-            wrappedInstance = getCurrentInstance();
-            setupContext = ctx;
-            if (options?.scoped) {
-              const scope = effectScope();
-              globalThis.__cleanup ||= [];
-              globalThis.__cleanup.push(() => {
-                scope.stop();
-              });
-              return scope.run(() => NuxtRoot.setup(props2, {
-                ...ctx,
-                expose: () => {
-                }
-              }));
-            } else {
-              return NuxtRoot.setup(props2, {
-                ...ctx,
-                expose: () => {
-                }
-              });
-            }
-          },
-          render: () => h$1(
-            Suspense,
-            {
-              onResolve: () => nextTick().then(() => {
-                vm.setupState = setupState;
-                vm.__setProps = (props2) => {
-                  Object.assign(setProps, props2);
-                };
-                resolve(wrappedMountedWrapper(vm));
-              })
-            },
-            {
-              default: () => h$1({
-                name: "MountSuspendedHelper",
-                async setup() {
-                  const router = useRouter();
-                  await router.replace(route);
-                  const clonedComponent = {
-                    components: {},
-                    ...component,
-                    name: "MountSuspendedComponent",
-                    setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
-                  };
-                  return () => h$1(clonedComponent, { ...props, ...setProps, ...attrs }, setupContext.slots);
-                }
-              })
+  const SuspendedHelper = {
+    name: suspendedHelperName,
+    render: () => "",
+    async setup() {
+      if (route) {
+        const router = useRouter();
+        await router.replace(route);
+      }
+      return () => h$1(ClonedComponent, { ...props, ...setProps, ...attrs }, setupContext.slots);
+    }
+  };
+  return new Promise((resolve, reject) => {
+    let isMountSettled = false;
+    const wrapper = wrapperFn(
+      {
+        inheritAttrs: false,
+        __cssModules: componentRest.__cssModules,
+        setup: (props2, ctx) => {
+          patchInstanceAppContext();
+          wrappedInstance = getCurrentInstance();
+          setupContext = ctx;
+          const nuxtRootSetupResult = runEffectScope(
+            () => NuxtRoot.setup(props2, {
+              ...ctx,
+              expose: () => {
+              }
+            })
+          );
+          onErrorCaptured((error, ...args) => {
+            if (isMountSettled) return;
+            isMountSettled = true;
+            try {
+              wrappedInstance?.appContext.config.errorHandler?.(error, ...args);
+              reject(error);
+            } catch (error2) {
+              reject(error2);
             }
-          )
+            return false;
+          });
+          return nuxtRootSetupResult;
         },
-        defu(
-          _options,
+        render: wrappedRender(() => h$1(
+          Suspense,
           {
-            props,
-            slots,
-            attrs,
-            global: {
-              config: {
-                globalProperties: {
-                  ...vueApp.config.globalProperties,
-                  // make all properties/keys enumerable.
-                  ...Object.fromEntries(
-                    Object.getOwnPropertyNames(vueApp.config.globalProperties).map((key) => [key, vueApp.config.globalProperties[key]])
-                  )
+            onResolve: () => nextTick$1().then(() => {
+              if (isMountSettled) return;
+              isMountSettled = true;
+              wrapper.setupState = setupState;
+              resolve({
+                wrapper,
+                setProps: (props2) => {
+                  Object.assign(setProps, props2);
                 }
-              },
-              directives: vueApp._context.directives,
-              provide: vueApp._context.provides,
-              stubs: {
-                Suspense: false,
-                MountSuspendedHelper: false,
-                [component && typeof component === "object" && "name" in component && typeof component.name === "string" ? component.name : "MountSuspendedComponent"]: false
-              },
-              components: { ...vueApp._context.components, RouterLink }
-            }
+              });
+            })
+          },
+          {
+            default: () => h$1(SuspendedHelper)
           }
-        )
-      );
-    }
-  );
+        ))
+      },
+      defu(wrapperFnOptions, {
+        global: {
+          config: {
+            globalProperties: makeAllPropertiesEnumerable(
+              vueApp.config.globalProperties
+            )
+          },
+          directives: vueApp._context.directives,
+          provide: vueApp._context.provides,
+          stubs: {
+            Suspense: false,
+            [SuspendedHelper.name]: false,
+            [ClonedComponent.name]: false
+          },
+          components: { ...vueApp._context.components, RouterLink }
+        }
+      })
+    );
+  });
+}
+function makeAllPropertiesEnumerable(target) {
+  return {
+    ...target,
+    ...Object.fromEntries(
+      Object.getOwnPropertyNames(target).map((key) => [key, target[key]])
+    )
+  };
+}
+
+async function mountSuspended(component, options = {}) {
+  const suspendedHelperName = "MountSuspendedHelper";
+  const clonedComponentName = "MountSuspendedComponent";
+  cleanupAll();
+  const { wrapper, setProps } = await wrapperSuspended(component, options, {
+    wrapperFn: mount,
+    suspendedHelperName,
+    clonedComponentName
+  });
+  Object.assign(wrapper, { __setProps: setProps });
+  const clonedComponent = wrapper.findComponent({ name: clonedComponentName });
+  return wrappedMountedWrapper(wrapper, clonedComponent);
 }
-function wrappedMountedWrapper(wrapper) {
-  const component = wrapper.findComponent({ name: "MountSuspendedComponent" });
+function wrappedMountedWrapper(wrapper, component) {
   const wrapperProps = [
     "setProps",
     "emitted",
@@ -273,138 +292,27 @@ function wrappedMountedWrapper(wrapper) {
   }
 }
 
-const WRAPPER_EL_ID = "test-wrapper";
-async function renderSuspended(component, options) {
-  const {
-    props = {},
-    attrs = {},
-    slots = {},
-    route = "/",
-    ..._options
-  } = options || {};
-  const { render: renderFromTestingLibrary } = await import('@testing-library/vue');
-  const vueApp = tryUseNuxtApp()?.vueApp || globalThis.__unctx__.get("nuxt-app").tryUse().vueApp;
-  const { render, setup, ...componentRest } = component;
-  let wrappedInstance = null;
-  let setupContext;
-  let setupState;
-  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;
-    }
-  }
-  for (const fn of window.__cleanup || []) {
-    fn();
-  }
-  document.querySelector(`#${WRAPPER_EL_ID}`)?.remove();
-  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;
-    }
-  };
-  const WrapperComponent = defineComponent$1({
-    inheritAttrs: false,
-    render() {
-      return h$1("div", { id: WRAPPER_EL_ID }, this.$slots.default?.());
-    }
-  });
-  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 ||= [];
-          window.__cleanup.push(() => {
-            scope.stop();
-          });
-          return scope.run(() => NuxtRoot.setup(props2, {
-            ...ctx,
-            expose: () => ({})
-          }));
-        },
-        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
-          h$1(
-            WrapperComponent,
-            {},
-            {
-              default: () => h$1(
-                Suspense,
-                {
-                  onResolve: () => nextTick().then(() => {
-                    utils.setupState = setupState;
-                    utils.rerender = async (props2) => {
-                      Object.assign(setProps, props2);
-                      await nextTick();
-                    };
-                    resolve(utils);
-                  })
-                },
-                {
-                  default: () => h$1({
-                    name: "RenderHelper",
-                    async setup() {
-                      const router = useRouter();
-                      await router.replace(route);
-                      const clonedComponent = {
-                        components: {},
-                        ...component,
-                        name: "RenderSuspendedComponent",
-                        render,
-                        setup: (props2, ctx) => wrappedSetup(props2, setupContext, ctx)
-                      };
-                      return () => h$1(clonedComponent, { ...props && typeof props === "object" ? props : {}, ...setProps, ...attrs }, setupContext.slots);
-                    }
-                  })
-                }
-              )
-            }
-          )
-        )
-      },
-      defu(_options, {
-        props,
-        slots,
-        attrs,
-        global: {
-          config: {
-            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,
-          components: { RouterLink }
-        }
-      })
-    );
+async function renderSuspended(component, options = {}) {
+  const wrapperId = "test-wrapper";
+  const suspendedHelperName = "RenderHelper";
+  const clonedComponentName = "RenderSuspendedComponent";
+  const { render: wrapperFn } = await import('@testing-library/vue');
+  cleanupAll();
+  document.getElementById(wrapperId)?.remove();
+  const { wrapper, setProps } = await wrapperSuspended(component, options, {
+    wrapperFn,
+    wrappedRender: (render) => () => h$1({
+      inheritAttrs: false,
+      render: () => h$1("div", { id: wrapperId }, render())
+    }),
+    suspendedHelperName,
+    clonedComponentName
   });
+  wrapper.rerender = async (props) => {
+    setProps(props);
+    await nextTick();
+  };
+  return wrapper;
 }
 
 export { mockComponent, mockNuxtImport, mountSuspended, registerEndpoint, renderSuspended };