@nuxt/test-utils 3.20.1 → 3.22.0

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

@@ -1,19 +1,42 @@
 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 * as _testing_library_vue from '@testing-library/vue';
-import { RenderOptions as RenderOptions$1 } from '@testing-library/vue';
+import { render } from '@testing-library/vue';
 
 type Awaitable<T> = T | Promise<T>;
 type OptionalFunction<T> = T | (() => Awaitable<T>);
+/**
+ * `registerEndpoint` allows you create Nitro endpoint that returns mocked data. It can come in handy if you want to test a component that makes requests to API to display some data.
+ * @param url - endpoint name (e.g. `/test/`).
+ * @param options - factory function that returns the mocked data or an object containing the `handler`, `method`, and `once` properties.
+ * - `handler`: the event handler function
+ * - `method`: (optional) HTTP method to match (e.g., 'GET', 'POST')
+ * - `once`: (optional) if true, the handler will only be used for the first matching request and then automatically removed
+ * @example
+ * ```ts
+ * import { registerEndpoint } from '@nuxt/test-utils/runtime'
+ *
+ * registerEndpoint("/test/", () => ({
+ *  test: "test-field"
+ * }))
+ *
+ * // With once option
+ * registerEndpoint("/api/user", {
+ *   handler: () => ({ name: "Alice" }),
+ *   once: true
+ * })
+ * ```
+ * @see https://nuxt.com/docs/getting-started/testing#registerendpoint
+ */
 declare function registerEndpoint(url: string, options: EventHandler | {
     handler: EventHandler;
-    method: HTTPMethod;
+    method?: HTTPMethod;
+    once?: boolean;
 }): () => void;
 /**
  * `mockNuxtImport` allows you to mock Nuxt's auto import functionality.
- * @param _name - name of an import to mock.
+ * @param _target - name of an import to mock or mocked target.
  * @param _factory - factory function that returns mocked import.
  * @example
  * ```ts
@@ -24,10 +47,17 @@ declare function registerEndpoint(url: string, options: EventHandler | {
  *    return { value: 'mocked storage' }
  *  }
  * })
+ *
+ * // With mocked target
+ * mockNuxtImport(useStorage, () => {
+ *  return () => {
+ *    return { value: 'mocked storage' }
+ *  }
+ * })
  * ```
  * @see https://nuxt.com/docs/getting-started/testing#mocknuxtimport
  */
-declare function mockNuxtImport<T = unknown>(_name: string, _factory: () => T | Promise<T>): void;
+declare function mockNuxtImport<T = unknown>(_target: string | T, _factory: () => T | Promise<T>): void;
 /**
  * `mockComponent` allows you to mock Nuxt's component.
  * @param path - component name in PascalCase, or the relative path of the component.
@@ -65,11 +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 SetupState$1 = Record<string, any>;
+type WrapperSuspendedResult<Fn> = WrapperFnResult<Fn> & {
+    setupState: SetupState;
+};
+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:
  *
@@ -96,17 +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<ReturnType<typeof mount<T>> & {
-    setupState: SetupState$1;
-}>;
-declare global {
-    var __cleanup: Array<() => void> | undefined;
-}
+declare function mountSuspended<T>(component: T, options?: WrapperOptions$1<T>): Promise<WrapperResult$1<T>>;
 
-type RenderOptions<C = unknown> = RenderOptions$1<C> & {
-    route?: RouteLocationRaw;
-};
-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.
  *
@@ -137,13 +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?: RenderOptions<T>): Promise<_testing_library_vue.RenderResult & {
-    setupState: SetupState;
-}>;
-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 };