@nuxt/test-utils 3.21.0 → 3.23.0

package/dist/playwright.d.mts

@@ -1,9 +1,10 @@
 import * as _playwright_test from '@playwright/test';
 export { expect } from '@playwright/test';
 import { Response } from 'playwright-core';
-import { T as TestOptions$1, G as GotoOptions, b as TestHooks } from './shared/test-utils.20kU0tZa.mjs';
+import { T as TestOptions$1, G as GotoOptions, a as TestHooks } from './shared/test-utils.C9GKP_T5.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
+import 'ofetch';
 
 type ConfigOptions = {
     nuxt: Partial<TestOptions$1> | undefined;

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.5cnw0YZR.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.BsmyE2FA.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/environment.mjs

@@ -1,8 +1,9 @@
 import { createFetch } from "ofetch";
 import { joinURL } from "ufo";
-import { createApp, defineEventHandler, toNodeListener } from "h3";
+import { defineEventHandler } from "./h3.mjs";
 import { createRouter as createRadixRouter, exportMatcher, toRouteMatcher } from "radix3";
-import { fetchNodeRequestHandler } from "node-mock-http";
+import { createFetchForH3V1 } from "./h3-v1.mjs";
+import { createFetchForH3V2 } from "./h3-v2.mjs";
 export async function setupWindow(win, environmentOptions) {
   win.__NUXT_VITEST_ENVIRONMENT__ = true;
   win.__NUXT__ = {
@@ -35,7 +36,6 @@ export async function setupWindow(win, environmentOptions) {
   const app = win.document.createElement("div");
   app.id = rootId;
   win.document.body.appendChild(app);
-  const h3App = createApp();
   if (!win.fetch || !("Request" in win)) {
     await import("node-fetch-native/polyfill");
     win.URLSearchParams = globalThis.URLSearchParams;
@@ -49,37 +49,11 @@ export async function setupWindow(win, environmentOptions) {
       }
     };
   }
-  const nodeHandler = toNodeListener(h3App);
-  const registry = /* @__PURE__ */ new Set();
-  const _fetch = fetch;
-  win.fetch = async (input, _init) => {
-    let url;
-    let init = _init;
-    if (typeof input === "string") {
-      url = input;
-    } else if (input instanceof URL) {
-      url = input.toString();
-    } else {
-      url = input.url;
-      init = {
-        method: init?.method ?? input.method,
-        body: init?.body ?? input.body,
-        headers: init?.headers ?? input.headers
-      };
-    }
-    const base = url.split("?")[0];
-    if (registry.has(base) || registry.has(url)) {
-      url = "/_" + url;
-    }
-    if (url.startsWith("/")) {
-      const response = await fetchNodeRequestHandler(nodeHandler, url, init);
-      return normalizeFetchResponse(response);
-    }
-    return _fetch(input, _init);
-  };
+  const res = environmentOptions.nuxt.h3Version === 2 ? await createFetchForH3V2() : await createFetchForH3V1();
+  win.fetch = res.fetch;
   win.$fetch = createFetch({ fetch: win.fetch, Headers: win.Headers });
-  win.__registry = registry;
-  win.__app = h3App;
+  win.__registry = res.registry;
+  win.__app = res.h3App;
   const timestamp = Date.now();
   const routeRulesMatcher = toRouteMatcher(
     createRadixRouter({ routes: environmentOptions.nuxtRouteRules || {} })
@@ -92,14 +66,14 @@ export async function setupWindow(win, environmentOptions) {
   );
   const manifestBaseRoutePath = joinURL("/_", manifestOutputPath);
   const buildId = win.__NUXT__.config?.app.buildId || "test";
-  h3App.use(
+  res.h3App.use(
     `${manifestBaseRoutePath}/latest.json`,
     defineEventHandler(() => ({
       id: buildId,
       timestamp
     }))
   );
-  h3App.use(
+  res.h3App.use(
     `${manifestBaseRoutePath}/meta/${buildId}.json`,
     defineEventHandler(() => ({
       id: buildId,
@@ -108,38 +82,9 @@ export async function setupWindow(win, environmentOptions) {
       prerendered: []
     }))
   );
-  registry.add(`${manifestOutputPath}/latest.json`);
-  registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
+  res.registry.add(`${manifestOutputPath}/latest.json`);
+  res.registry.add(`${manifestOutputPath}/meta/${buildId}.json`);
   return () => {
     console.info = consoleInfo;
   };
 }
-function normalizeFetchResponse(response) {
-  if (!response.headers.has("set-cookie")) {
-    return response;
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: normalizeCookieHeaders(response.headers)
-  });
-}
-function normalizeCookieHeader(header = "") {
-  return splitCookiesString(joinHeaders(header));
-}
-function normalizeCookieHeaders(headers) {
-  const outgoingHeaders = new Headers();
-  for (const [name, header] of headers) {
-    if (name === "set-cookie") {
-      for (const cookie of normalizeCookieHeader(header)) {
-        outgoingHeaders.append("set-cookie", cookie);
-      }
-    } else {
-      outgoingHeaders.set(name, joinHeaders(header));
-    }
-  }
-  return outgoingHeaders;
-}
-function joinHeaders(value) {
-  return Array.isArray(value) ? value.join(", ") : String(value);
-}

package/dist/runtime/shared/h3-v1.d.ts

@@ -0,0 +1,6 @@
+import type { GenericApp } from '../../vitest-environment';
+export declare function createFetchForH3V1(): Promise<{
+    h3App: GenericApp;
+    registry: Set<string>;
+    fetch: typeof fetch;
+}>;

package/dist/runtime/shared/h3-v1.mjs

@@ -0,0 +1,69 @@
+export async function createFetchForH3V1() {
+  const [{ createApp, toNodeListener }, { fetchNodeRequestHandler }] = await Promise.all([
+    import("h3"),
+    import("node-mock-http")
+  ]);
+  const h3App = createApp();
+  const nodeHandler = toNodeListener(h3App);
+  const registry = /* @__PURE__ */ new Set();
+  const _fetch = fetch;
+  const h3Fetch = (async (input, _init) => {
+    let url;
+    let init = _init;
+    if (typeof input === "string") {
+      url = input;
+    } else if (input instanceof URL) {
+      url = input.toString();
+    } else {
+      url = input.url;
+      init = {
+        method: init?.method ?? input.method,
+        body: init?.body ?? input.body,
+        headers: init?.headers ?? input.headers
+      };
+    }
+    const base = url.split("?")[0];
+    if (registry.has(base) || registry.has(url)) {
+      url = "/_" + url;
+    }
+    if (url.startsWith("/")) {
+      const response = await fetchNodeRequestHandler(nodeHandler, url, init);
+      return normalizeFetchResponse(response);
+    }
+    return _fetch(input, _init);
+  });
+  return {
+    h3App,
+    registry,
+    fetch: h3Fetch
+  };
+}
+function normalizeFetchResponse(response) {
+  if (!response.headers.has("set-cookie")) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: normalizeCookieHeaders(response.headers)
+  });
+}
+function normalizeCookieHeader(header = "") {
+  return splitCookiesString(joinHeaders(header));
+}
+function normalizeCookieHeaders(headers) {
+  const outgoingHeaders = new Headers();
+  for (const [name, header] of headers) {
+    if (name === "set-cookie") {
+      for (const cookie of normalizeCookieHeader(header)) {
+        outgoingHeaders.append("set-cookie", cookie);
+      }
+    } else {
+      outgoingHeaders.set(name, joinHeaders(header));
+    }
+  }
+  return outgoingHeaders;
+}
+function joinHeaders(value) {
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}

package/dist/runtime/shared/h3-v2.d.ts

@@ -0,0 +1,6 @@
+import type { GenericApp } from '../../vitest-environment';
+export declare function createFetchForH3V2(): Promise<{
+    h3App: GenericApp;
+    registry: Set<string>;
+    fetch: typeof fetch;
+}>;

package/dist/runtime/shared/h3-v2.mjs

@@ -0,0 +1,35 @@
+export async function createFetchForH3V2() {
+  const { H3 } = await import("h3-next/generic");
+  const h3App = new H3();
+  const registry = /* @__PURE__ */ new Set();
+  const _fetch = fetch;
+  const h3Fetch = (async (input, _init) => {
+    let url;
+    let init = _init;
+    if (typeof input === "string") {
+      url = input;
+    } else if (input instanceof URL) {
+      url = input.toString();
+    } else {
+      url = input.url;
+      init = {
+        method: init?.method ?? input.method,
+        body: init?.body ?? input.body,
+        headers: init?.headers ?? input.headers
+      };
+    }
+    const base = url.split("?")[0];
+    if (registry.has(base) || registry.has(url)) {
+      return h3App.fetch(new Request("/_" + url, init));
+    }
+    if (url.startsWith("/")) {
+      return new Response("Not Found", { status: 404, statusText: "Not Found" });
+    }
+    return _fetch(input, _init);
+  });
+  return {
+    h3App,
+    registry,
+    fetch: h3Fetch
+  };
+}

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

@@ -0,0 +1,3 @@
+type RawHandler = () => unknown | Promise<unknown>;
+export declare function defineEventHandler(handler: RawHandler): RawHandler;
+export {};

package/dist/runtime/shared/h3.mjs

@@ -0,0 +1,3 @@
+export function defineEventHandler(handler) {
+  return Object.assign(handler, { __is_handler__: true });
+}

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,9 @@
-import { EventHandler, HTTPMethod } from 'h3';
+import { EventHandler } from 'h3';
+import { HTTPMethod } from 'h3-next';
 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 +96,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 +142,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 +177,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 };