@nuxt/test-utils 3.20.1 → 3.22.0

package/dist/module.mjs

@@ -1,21 +1,21 @@
-import { pathToFileURL } from 'node:url';
-import { useNuxt, resolveIgnorePatterns, addVitePlugin, 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 { getVitestConfigFromNuxt } from './config.mjs';
+import { resolveIgnorePatterns, useNuxt, addDevServerHandler, defineNuxtModule, createResolver, resolvePath, logger } from '@nuxt/kit';
+import { extname, join, dirname, resolve, relative } from 'pathe';
+import { provider, isCI } from 'std-env';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
 import { createUnplugin } from 'unplugin';
+import { l as loadKit } from './shared/test-utils.BIY9XRkB.mjs';
 import { readFileSync } from 'node:fs';
-import { extname, join, dirname } from 'pathe';
-import 'node:process';
-import 'vite';
-import 'c12';
+import { h } from 'vue';
+import { defineEventHandler } from 'h3';
+import { debounce } from 'perfect-debounce';
+import { fork } from 'node:child_process';
+import { c as createVitestTestSummary, l as listenCliMessages, s as sendMessageToCli } from './shared/test-utils.DDUpsMYL.mjs';
+import { distDir } from '#dirs';
 import 'destr';
 import 'scule';
+import 'node:url';
+import 'exsolve';
 
 const PLUGIN_NAME$1 = "nuxt:vitest:mock-transform";
 const HELPER_MOCK_IMPORT = "mockNuxtImport";
@@ -67,16 +67,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 +262,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: []
@@ -295,29 +295,233 @@ function setupImportMocking() {
 
 const PLUGIN_NAME = "nuxt:vitest:nuxt-root-stub";
 const STUB_ID = "nuxt-vitest-app-entry";
-const NuxtRootStubPlugin = createUnplugin((options) => {
-  const STUB_ID_WITH_EXT = STUB_ID + extname(options.entry);
+const NuxtRootStubPlugin = (options) => {
+  const extension = extname(options.entry);
+  const escapedExt = extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const entryPath = join(dirname(options.entry), STUB_ID + extension);
+  const idFilter = new RegExp(`${STUB_ID}(?:${escapedExt})?$`);
   return {
     name: PLUGIN_NAME,
     enforce: "pre",
-    vite: {
-      async resolveId(id, importer) {
-        if (id.endsWith(STUB_ID) || id.endsWith(STUB_ID_WITH_EXT)) {
-          return importer?.endsWith("index.html") ? id : join(dirname(options.entry), STUB_ID_WITH_EXT);
-        }
+    resolveId: {
+      filter: {
+        id: idFilter
+      },
+      async handler(id, importer) {
+        return importer?.endsWith("index.html") ? id : entryPath;
+      }
+    },
+    load: {
+      filter: {
+        id: idFilter
       },
-      async load(id) {
-        if (id.endsWith(STUB_ID) || id.endsWith(STUB_ID_WITH_EXT)) {
-          const entryContents = readFileSync(options.entry, "utf-8");
-          return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+      async handler() {
+        const entryContents = readFileSync(options.entry, "utf-8");
+        return entryContents.replace("#build/root-component.mjs", options.rootStubPath);
+      }
+    }
+  };
+};
+
+async function setupDevTools(vitestWrapper, nuxt = useNuxt()) {
+  const iframeSrc = "/__test_utils_vitest__/";
+  const updateTabs = debounce(() => {
+    nuxt.callHook("devtools:customTabs:refresh");
+  }, 100);
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    const tab = createVitestCustomTab(vitestWrapper, { iframeSrc });
+    const index = tabs.findIndex(({ name }) => tab.name === name);
+    if (index === -1) {
+      tabs.push(tab);
+    } else {
+      tabs.splice(index, 1, tab);
+    }
+  });
+  addDevServerHandler({
+    route: iframeSrc,
+    handler: defineEventHandler(
+      () => iframeContentHtml(vitestWrapper.uiUrl)
+    )
+  });
+  vitestWrapper.ons({
+    started() {
+      updateTabs();
+    },
+    updated() {
+      updateTabs();
+    },
+    finished() {
+      updateTabs();
+    },
+    exited() {
+      updateTabs();
+    }
+  });
+}
+function createVitestCustomTab(vitest, { iframeSrc }) {
+  const launchView = {
+    type: "launch",
+    description: "Start tests along with Nuxt",
+    actions: [
+      {
+        get label() {
+          switch (vitest.status) {
+            case "starting":
+              return "Starting...";
+            case "running":
+              return "Running Vitest";
+            case "stopped":
+              return "Start Vitest";
+            case "finished":
+              return "Start Vitest";
+          }
+        },
+        get pending() {
+          return vitest.status === "starting" || vitest.status === "running";
+        },
+        handle: () => {
+          vitest.start();
         }
       }
+    ]
+  };
+  const uiView = {
+    type: "iframe",
+    persistent: false,
+    src: iframeSrc
+  };
+  const tab = {
+    title: "Vitest",
+    name: "vitest",
+    icon: "logos-vitest",
+    get view() {
+      if (vitest.status === "stopped" || vitest.status === "starting" || !vitest.uiUrl) {
+        return launchView;
+      } else {
+        return uiView;
+      }
+    },
+    extraTabVNode: vitest.testSummary.totalCount ? h("div", { style: { color: vitest.testSummary.failedCount ? "orange" : "green" } }, [
+      h("span", {}, vitest.testSummary.passedCount),
+      h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
+      h(
+        "span",
+        { style: { opacity: "0.8", fontSize: "0.9em" } },
+        vitest.testSummary.totalCount
+      )
+    ]) : void 0
+  };
+  return tab;
+}
+function iframeContentHtml(uiUrl) {
+  return [
+    "<html><head><script>",
+    `(${function redirect(uiUrl2, provider2) {
+      if (typeof window === "undefined") return;
+      if (!uiUrl2) return;
+      if (provider2 === "stackblitz") {
+        const url = new URL(window.location.href);
+        const newUrl = new URL(uiUrl2);
+        newUrl.host = url.host.replace(/--\d+--/, `--${newUrl.port}--`);
+        newUrl.protocol = url.protocol;
+        newUrl.port = url.port;
+        uiUrl2 = newUrl.toString();
+      }
+      window.location.replace(uiUrl2);
+    }})(${JSON.stringify(uiUrl)}, ${JSON.stringify(provider)})`,
+    "<\/script></head></html>"
+  ].join("\n");
+}
+
+function vitestWrapper(options) {
+  const { cwd, ...startOptions } = options;
+  let _status = "stopped";
+  let _uiUrl;
+  let _process;
+  let _testSummary = createVitestTestSummary();
+  const _handlers = {
+    started: [({ uiUrl }) => {
+      _uiUrl = uiUrl;
+      _status = "running";
+      _testSummary = createVitestTestSummary();
+    }],
+    updated: [(summary) => {
+      _testSummary = summary;
+    }],
+    finished: [(summary) => {
+      _status = "finished";
+      _testSummary = summary;
+    }],
+    exited: [clear]
+  };
+  function clear() {
+    _status = "stopped";
+    _uiUrl = void 0;
+    _process = void 0;
+    _testSummary = createVitestTestSummary();
+  }
+  function on(name, handler) {
+    _handlers[name] ??= [];
+    _handlers[name]?.push(handler);
+  }
+  function ons(handlers) {
+    for (const [name, handler] of Object.entries(handlers)) {
+      if (typeof handler === "function") {
+        on(name, handler);
+      }
+    }
+  }
+  async function stop() {
+    const vitest = _process;
+    if (!vitest || vitest.exitCode !== null) return;
+    return new Promise((resolve2) => {
+      vitest.once("exit", () => resolve2());
+      sendMessageToCli(vitest, "stop", { force: true });
+    });
+  }
+  async function start() {
+    if (_process) return false;
+    const vitest = fork(resolve(distDir, "./vitest-wrapper/cli.mjs"), {
+      cwd,
+      env: {
+        ...process.env,
+        NODE_ENV: "test",
+        MODE: "test"
+      },
+      stdio: startOptions.logToConsole ? void 0 : ["ignore", "ignore", "inherit", "ipc"]
+    });
+    _status = "starting";
+    _process = vitest;
+    vitest.once("exit", () => {
+      _handlers.exited.forEach((fn) => fn({ exitCode: vitest.exitCode ?? 0 }));
+    });
+    listenCliMessages(vitest, ({ type, payload }) => {
+      _handlers[type].forEach((fn) => fn(payload));
+    });
+    sendMessageToCli(vitest, "start", startOptions);
+    return true;
+  }
+  return {
+    on,
+    ons,
+    stop,
+    start,
+    get uiUrl() {
+      return _uiUrl;
+    },
+    get options() {
+      return options;
+    },
+    get status() {
+      return _status;
+    },
+    get testSummary() {
+      return { ..._testSummary };
     }
   };
-});
+}
 
-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,137 +532,68 @@ 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 }),
-      rootStubPath: await resolvePath(resolver.resolve("./runtime/nuxt-root"))
-    }));
+    if (nuxt.options.test || nuxt.options.dev) {
+      addVitePlugin(NuxtRootStubPlugin({
+        entry: await resolvePath("#app/entry", { alias: nuxt.options.alias }),
+        rootStubPath: await resolvePath(resolver.resolve("./runtime/nuxt-root"))
+      }));
+    }
     if (!nuxt.options.test && !nuxt.options.dev) {
       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", (ctx) => {
+      ctx.references.push({ types: "vitest/import-meta" });
+      if (ctx.nodeTsConfig) {
+        ctx.nodeTsConfig.include ||= [];
+        ctx.nodeTsConfig.include.push(relative(nuxt.options.buildDir, join(nuxt.options.rootDir, "vitest.config.*")));
+        if (nuxt.options.workspaceDir !== nuxt.options.rootDir) {
+          ctx.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;
-    const rawViteConfigPromise = new Promise((resolve) => {
-      nuxt.hook("app:resolve", () => {
-        nuxt.hook("vite:configResolved", (config, { isClient }) => {
-          if (isClient) resolve(config);
-        });
-      });
-    });
-    let loaded = false;
-    let promise;
-    let ctx = void 0;
-    let testFiles = null;
-    const updateTabs = debounce(() => {
-      nuxt.callHook("devtools:customTabs:refresh");
-    }, 100);
-    let URL;
-    async function start() {
-      const { mergeConfig } = await importModule("vite", { paths: nuxt.options.modulesDir });
-      const rawViteConfig = mergeConfig({}, await rawViteConfigPromise);
-      const viteConfig = await getVitestConfigFromNuxt({ nuxt, viteConfig: defu({ test: options.vitestConfig }, rawViteConfig) });
-      viteConfig.plugins = (viteConfig.plugins || []).filter((p) => {
-        return !p || !("name" in p) || !vitePluginBlocklist.includes(p.name);
-      });
-      viteConfig.test.environmentMatchGlobs ||= [];
-      viteConfig.test.environmentMatchGlobs.push(
-        ["**/*.nuxt.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}", "nuxt"],
-        ["{test,tests}/nuxt/**.*", "nuxt"]
-      );
-      process.env.__NUXT_VITEST_RESOLVED__ = "true";
-      const { startVitest } = await import(pathToFileURL(await resolvePath("vitest/node")).href);
-      const customReporter = {
-        onInit(_ctx) {
-          ctx = _ctx;
-        },
-        onTaskUpdate() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        },
-        onFinished() {
-          testFiles = ctx.state.getFiles();
-          updateTabs();
-        }
-      };
-      const watchMode = !process.env.NUXT_VITEST_DEV_TEST && !isCI;
-      const PORT = await getPort({ port: 15555 });
-      const PROTOCOL = nuxt.options.devServer.https ? "https" : "http";
-      URL = `${PROTOCOL}://localhost:${PORT}/__vitest__/`;
-      const overrides = watchMode ? {
-        passWithNoTests: true,
-        reporters: options.logToConsole ? [
-          ...toArray(options.vitestConfig?.reporters ?? ["default"]),
-          customReporter
-        ] : [customReporter],
-        // do not report to console
-        watch: true,
-        ui: true,
-        open: false,
-        api: {
-          port: PORT
-        }
-      } : { watch: false };
-      const promise2 = startVitest("test", [], defu(overrides, viteConfig.test), viteConfig);
-      promise2.catch(() => process.exit(1));
-      if (watchMode) {
-        logger.info(`Vitest UI starting on ${URL}`);
-        nuxt.hook("close", () => promise2.then((v) => v?.close()));
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      } else {
-        promise2.then((v) => nuxt.close().then(() => v?.close()).then(() => process.exit()));
-      }
-      loaded = true;
-    }
-    nuxt.hook("devtools:customTabs", (tabs) => {
-      const failedCount = testFiles?.filter((f) => f.result?.state === "fail").length ?? 0;
-      const passedCount = testFiles?.filter((f) => f.result?.state === "pass").length ?? 0;
-      const totalCount = testFiles?.length ?? 0;
-      tabs.push({
-        title: "Vitest",
-        name: "vitest",
-        icon: "logos-vitest",
-        view: loaded ? {
-          type: "iframe",
-          src: URL
-        } : {
-          type: "launch",
-          description: "Start tests along with Nuxt",
-          actions: [
-            {
-              label: promise ? "Starting..." : "Start Vitest",
-              pending: !!promise,
-              handle: () => {
-                promise = promise || start();
-                return promise;
-              }
-            }
-          ]
-        },
-        extraTabVNode: totalCount ? h("div", { style: { color: failedCount ? "orange" : "green" } }, [
-          h("span", {}, passedCount),
-          h("span", { style: { opacity: "0.5", fontSize: "0.9em" } }, "/"),
-          h(
-            "span",
-            { style: { opacity: "0.8", fontSize: "0.9em" } },
-            totalCount
-          )
-        ]) : void 0
-      });
+    const vitestWrapper2 = createVitestWrapper(options, nuxt);
+    nuxt.hook("devtools:before", async () => {
+      await setupDevTools(vitestWrapper2, nuxt);
     });
     if (options.startOnBoot) {
-      promise = promise || start();
-      promise.then(updateTabs);
+      vitestWrapper2.start();
     }
   }
 });
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
+function createVitestWrapper(options, nuxt = useNuxt()) {
+  const watchMode = !isCI;
+  const wrapper = vitestWrapper({
+    cwd: nuxt.options.rootDir,
+    apiPorts: [15555],
+    logToConsole: options.logToConsole ?? false,
+    watchMode
+  });
+  wrapper.ons({
+    started({ uiUrl }) {
+      if (watchMode) {
+        logger.info(`Vitest UI starting on ${uiUrl}`);
+      }
+    },
+    exited({ exitCode }) {
+      if (watchMode) {
+        logger.info(`Vitest exited with code ${exitCode}`);
+      } else {
+        nuxt.close().finally(() => process.exit(exitCode));
+      }
+    }
+  });
+  nuxt.hooks.addHooks({
+    close: () => wrapper.stop(),
+    restart: () => wrapper.stop()
+  });
+  return wrapper;
 }
 
-export { module as default };
+export { module$1 as default };

package/dist/playwright.d.mts

@@ -1,7 +1,7 @@
 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.ZByFDqps.mjs';
 import '@nuxt/schema';
 import 'tinyexec';
 

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.D2ZzXztg.mjs';
 import 'node:path';
 import 'ufo';
 import 'std-env';
 import 'consola';
 import 'node:fs';
-import '@nuxt/kit';
-import { d as url } from './shared/test-utils.CtwoJP76.mjs';
+import 'destr';
+import 'scule';
+import 'node:url';
+import 'exsolve';
+import { d as url } from './shared/test-utils.C_clWQBc.mjs';
 import 'pathe';
 import '#dirs';
+import './shared/test-utils.BIY9XRkB.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/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;
+}