@nuxt/test-utils 3.21.0 → 3.23.0

package/dist/runtime-utils/index.mjs

@@ -1,6 +1,5 @@
-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';
@@ -12,30 +11,11 @@ function registerEndpoint(url, options) {
     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, once: false } : options;
-  config.handler = defineEventHandler(config.handler);
-  const hasBeenRegistered = window.__registry.has(url);
+  config.handler = Object.assign(config.handler, { __is_handler__: true });
   endpointRegistry[url] ||= [];
   endpointRegistry[url].push(config);
-  if (!hasBeenRegistered) {
-    window.__registry.add(url);
-    app.use("/_" + url, defineEventHandler(async (event) => {
-      const latestHandler = [...endpointRegistry[url] || []].reverse().find((config2) => config2.method ? event.method === config2.method : true);
-      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;
-      }
-    });
-  }
+  window.__registry.add(url);
+  app._registered ||= registerGlobalHandler(app);
   return () => {
     endpointRegistry[url]?.splice(endpointRegistry[url].indexOf(config), 1);
     if (endpointRegistry[url]?.length === 0) {
@@ -53,6 +33,31 @@ function mockComponent(_path, _component) {
     "mockComponent() is a macro and it did not get transpiled. This may be an internal bug of @nuxt/test-utils."
   );
 }
+const handler = Object.assign(async (event) => {
+  const url = "url" in event && event.url ? event.url.pathname.replace(/^\/_/, "") : event.path.replace(/[?#].*$/, "").replace(/^\/_/, "");
+  const latestHandler = [...endpointRegistry[url] || []].reverse().find((config) => config.method ? event.method === config.method : true);
+  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;
+}, { __is_handler__: true });
+function registerGlobalHandler(app) {
+  app.use(handler, {
+    match: (...args) => {
+      const [eventOrPath, _event = eventOrPath] = args;
+      const url = typeof eventOrPath === "string" ? eventOrPath.replace(/^\/_/, "").replace(/[?#].*$/, "") : eventOrPath.url.pathname.replace(/^\/_/, "");
+      const event = _event;
+      return endpointRegistry[url]?.some((config) => config.method ? event?.method === config.method : true) ?? false;
+    }
+  });
+  return true;
+}
 
 const RouterLink = defineComponent({
   functional: true,
@@ -88,19 +93,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 +133,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 +153,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]])
+    )
+  };
 }
-function wrappedMountedWrapper(wrapper) {
-  const component = wrapper.findComponent({ name: "MountSuspendedComponent" });
+
+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, component) {
   const wrapperProps = [
     "setProps",
     "emitted",
@@ -273,138 +297,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 };

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

@@ -1,8 +1,8 @@
-import { u as useTestContext, d as url, c as createTestContext, a as startServer, b as stopServer, s as setTestContext } from './test-utils.CtwoJP76.mjs';
+import { u as useTestContext, d as url, c as createTestContext, a as startServer, b as stopServer, s as setTestContext } from './test-utils.BsmyE2FA.mjs';
 import { existsSync, promises } from 'node:fs';
 import { resolve } from 'node:path';
 import { defu } from 'defu';
-import { l as loadKit } from './test-utils.G1ew4kEe.mjs';
+import { l as loadKit } from './test-utils.BIY9XRkB.mjs';
 
 async function createBrowser() {
   const ctx = useTestContext();

package/dist/shared/{test-utils.G1ew4kEe.mjs → test-utils.BIY9XRkB.mjs}

@@ -48,7 +48,7 @@ async function loadKit(rootDir) {
   } 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."
+        "`@nuxt/test-utils` requires `@nuxt/kit` to be installed in your project. Try installing `nuxt` v3+ or `@nuxt/bridge` first."
       );
     }
     throw e;

package/dist/shared/{test-utils.CtwoJP76.mjs → test-utils.BsmyE2FA.mjs}

@@ -1,6 +1,6 @@
 import { x } from 'tinyexec';
 import { getRandomPort, waitForPort } from 'get-port-please';
-import { $fetch as $fetch$1, fetch as fetch$1 } from 'ofetch';
+import { createFetch, fetch as fetch$1 } from 'ofetch';
 import { resolve as resolve$1 } from 'pathe';
 import { withTrailingSlash, joinURL } from 'ufo';
 import { resolve } from 'node:path';
@@ -72,6 +72,7 @@ function exposeContextToEnv() {
   process.env.NUXT_TEST_CONTEXT = JSON.stringify({ options, browser, url });
 }
 
+const globalFetch = globalThis.fetch || fetch$1;
 async function startServer(options = {}) {
   const ctx = useTestContext();
   await stopServer();
@@ -91,8 +92,8 @@ async function startServer(options = {}) {
           PORT: String(port),
           HOST: host,
           NODE_ENV: "development",
-          ...options.env,
-          ...ctx.options.env
+          ...ctx.options.env,
+          ...options.env
         }
       }
     });
@@ -128,8 +129,8 @@ async function startServer(options = {}) {
             PORT: String(port),
             HOST: host,
             NODE_ENV: "test",
-            ...options.env,
-            ...ctx.options.env
+            ...ctx.options.env,
+            ...options.env
           }
         }
       }
@@ -144,10 +145,11 @@ async function stopServer() {
   }
 }
 function fetch(path, options) {
-  return fetch$1(url(path), options);
+  return globalFetch(url(path), options);
 }
-const $fetch = function(path, options) {
-  return $fetch$1(url(path), options);
+const _$fetch = createFetch({ fetch: globalFetch });
+const $fetch = function $fetch2(path, options) {
+  return _$fetch(url(path), options);
 };
 function url(path) {
   const ctx = useTestContext();

package/dist/shared/{test-utils.20kU0tZa.d.mts → test-utils.C9GKP_T5.d.mts}

@@ -1,6 +1,7 @@
 import { Browser, Page, Response as Response$1, BrowserContextOptions, LaunchOptions } from 'playwright-core';
 import { NuxtConfig, Nuxt } from '@nuxt/schema';
 import { exec } from 'tinyexec';
+import { $Fetch } from 'ofetch';
 
 declare function createBrowser(): Promise<void>;
 declare function getBrowser(): Promise<Browser>;
@@ -20,7 +21,7 @@ interface StartServerOptions {
 declare function startServer(options?: StartServerOptions): Promise<void>;
 declare function stopServer(): Promise<void>;
 declare function fetch(path: string, options?: RequestInit): Promise<Response>;
-declare const $fetch: (typeof globalThis)["$fetch"];
+declare const $fetch: "$fetch" extends keyof typeof globalThis ? typeof globalThis.$fetch : $Fetch;
 declare function url(path: string): string;
 
 type TestRunner = 'vitest' | 'jest' | 'cucumber' | 'bun';
@@ -116,4 +117,4 @@ interface TestHooks {
 }
 
 export { $fetch as $, createBrowser as c, createPage as d, stopServer as e, fetch as f, getBrowser as g, startServer as s, url as u, waitForHydration as w };
-export type { GotoOptions as G, NuxtPage as N, StartServerOptions as S, TestOptions as T, TestContext as a, TestHooks as b, TestRunner as h };
+export type { GotoOptions as G, NuxtPage as N, StartServerOptions as S, TestOptions as T, TestHooks as a, TestContext as b, TestRunner as h };

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

@@ -0,0 +1,32 @@
+function isMessage(message) {
+  return message !== null && typeof message === "object" && "type" in message && message.type !== null && typeof message.type === "string" && "payload" in message && message.payload !== null && typeof message.payload === "object";
+}
+function createVitestTestSummary() {
+  return {
+    failedCount: 0,
+    passedCount: 0,
+    totalCount: 0
+  };
+}
+function sendMessageToHost(type, payload) {
+  process.send?.({ type, payload });
+}
+function listenHostMessages(listener) {
+  process.on("message", (message) => {
+    if (isMessage(message)) {
+      listener(message);
+    }
+  });
+}
+function sendMessageToCli(cli, type, payload) {
+  cli.send({ type, payload });
+}
+function listenCliMessages(cli, listener) {
+  cli.on("message", (message) => {
+    if (isMessage(message)) {
+      listener(message);
+    }
+  });
+}
+
+export { listenHostMessages as a, sendMessageToHost as b, createVitestTestSummary as c, listenCliMessages as l, sendMessageToCli as s };

package/dist/vitest-environment.d.mts

@@ -1,13 +1,25 @@
 import { Environment } from 'vitest/environments';
-import { App } from 'h3';
+import { H3Event as H3Event$1 } from 'h3';
+import { H3Event } from 'h3-next';
 import { $Fetch } from 'nitropack';
 import { JSDOMOptions, HappyDOMOptions } from 'vitest/node';
 
 declare const _default: Environment;
 
 type NuxtBuiltinEnvironment = 'happy-dom' | 'jsdom';
+interface GenericAppUse {
+    (route: string, handler: (event: H3Event | H3Event$1) => unknown, options?: {
+        match: (...args: [string, H3Event$1 | undefined] | [H3Event]) => boolean;
+    }): void;
+    (handler: (event: H3Event | H3Event$1) => unknown, options?: {
+        match: (...args: [string, H3Event$1 | undefined] | [H3Event]) => boolean;
+    }): void;
+}
+interface GenericApp {
+    use: GenericAppUse;
+}
 interface NuxtWindow extends Window {
-    __app: App;
+    __app?: GenericApp;
     __registry: Set<string>;
     __NUXT_VITEST_ENVIRONMENT__?: boolean;
     __NUXT__: Record<string, unknown>;
@@ -26,4 +38,4 @@ type EnvironmentNuxt = (global: typeof globalThis, options: EnvironmentNuxtOptio
 }>;
 
 export { _default as default };
-export type { EnvironmentNuxt, EnvironmentNuxtOptions, NuxtBuiltinEnvironment, NuxtWindow };
+export type { EnvironmentNuxt, EnvironmentNuxtOptions, GenericApp, NuxtBuiltinEnvironment, NuxtWindow };