msw 0.20.5 → 0.21.3

package/lib/types/rest.d.ts

@@ -1,8 +1,9 @@
-import { RequestHandler, ResponseResolver, MockedRequest } from './handlers/requestHandler';
+import { RequestHandler, ResponseResolver, MockedRequest, DefaultRequestBodyType, RequestParams } from './utils/handlers/requestHandler';
 import { Mask } from './setupWorker/glossary';
 import { set } from './context/set';
-import { matchRequestUrl } from './utils/matching/matchRequest';
+import { matchRequestUrl } from './utils/matching/matchRequestUrl';
 export declare enum RESTMethods {
+    HEAD = "HEAD",
     GET = "GET",
     POST = "POST",
     PUT = "PUT",
@@ -12,23 +13,164 @@ export declare enum RESTMethods {
 }
 export declare const restContext: {
     set: typeof set;
-    status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer;
-    cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer;
-    body: <T>(value: T) => import("./response").ResponseTransformer;
-    text: (body: string) => import("./response").ResponseTransformer;
-    json: (body: Record<string, any>) => import("./response").ResponseTransformer;
-    xml: (body: string) => import("./response").ResponseTransformer;
-    delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer;
-    fetch: <ResponseType_1 = any>(input: string | MockedRequest, requestInit?: RequestInit) => Promise<ResponseType_1>;
+    status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+    cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+    body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+    text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+    json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+    xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+    delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+    fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
 };
 export interface ParsedRestRequest {
     match: ReturnType<typeof matchRequestUrl>;
 }
 export declare const rest: {
-    get: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
-    post: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
-    put: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
-    delete: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
-    patch: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
-    options: (mask: Mask, resolver: ResponseResolver<MockedRequest, typeof restContext>) => RequestHandler<MockedRequest, typeof restContext, ParsedRestRequest>;
+    head: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
+    get: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
+    post: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
+    put: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
+    delete: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
+    patch: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
+    options: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any, RequestParamsType extends RequestParams = RequestParams>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType, RequestParamsType>, {
+        set: typeof set;
+        status: (statusCode: number, statusText?: string | undefined) => import("./response").ResponseTransformer<any>;
+        cookie: (name: string, value: string, options?: import("cookie").CookieSerializeOptions | undefined) => import("./response").ResponseTransformer<any>;
+        body: <BodyType extends string | Blob | ArrayBufferView | ArrayBuffer | ReadableStream<any> | FormData>(value: BodyType) => import("./response").ResponseTransformer<BodyType>;
+        text: <BodyType_1 extends string>(body: BodyType_1) => import("./response").ResponseTransformer<BodyType_1>;
+        json: <BodyType_2>(body: BodyType_2) => import("./response").ResponseTransformer<BodyType_2>;
+        xml: <BodyType_3 extends string>(body: BodyType_3) => import("./response").ResponseTransformer<BodyType_3>;
+        delay: (durationMs?: number | undefined) => import("./response").ResponseTransformer<any>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
 };

package/lib/types/setupWorker/glossary.d.ts

@@ -1,5 +1,5 @@
 import { HeadersList } from 'headers-utils';
-import { RequestHandler } from '../handlers/requestHandler';
+import { RequestHandler } from '../utils/handlers/requestHandler';
 import { MockedResponse } from '../response';
 import { SharedOptions } from '../sharedOptions';
 import { ServiceWorkerMessage } from '../utils/createBroadcastChannel';
@@ -9,6 +9,7 @@ export interface SetupWorkerInternalContext {
     worker: ServiceWorker | null;
     registration: ServiceWorkerRegistration | null;
     requestHandlers: RequestHandler<any, any>[];
+    keepAliveInterval?: number;
     events: {
         /**
          * Adds an event listener on the given target.
@@ -25,7 +26,11 @@ export interface SetupWorkerInternalContext {
         once<T>(type: string): Promise<ServiceWorkerMessage<T>>;
     };
 }
-export declare type ServiceWorkerInstanceTuple = [ServiceWorker | null, ServiceWorkerRegistration];
+export declare type ServiceWorkerInstanceTuple = [
+    ServiceWorker | null,
+    ServiceWorkerRegistration
+];
+export declare type FindWorker = (scriptUrl: string, mockServiceWorkerUrl: string) => boolean;
 export declare type StartOptions = SharedOptions & {
     serviceWorker?: {
         url?: string;
@@ -41,8 +46,13 @@ export declare type StartOptions = SharedOptions & {
      * instance is ready. Defaults to `true`.
      */
     waitUntilReady?: boolean;
+    /**
+     * A custom lookup function to find a Mock Service Worker in the list
+     * of all registered Service Workers on the page.
+     */
+    findWorker?: FindWorker;
 };
-export declare type RequestHandlersList = RequestHandler<any, any>[];
-export declare type ResponseWithSerializedHeaders = Omit<MockedResponse, 'headers'> & {
+export declare type RequestHandlersList = RequestHandler<any, any, any, any, any>[];
+export declare type ResponseWithSerializedHeaders<BodyType = any> = Omit<MockedResponse<BodyType>, 'headers'> & {
     headers: HeadersList;
 };

package/lib/types/setupWorker/start/utils/getWorkerByRegistration.d.ts

@@ -1,5 +1,6 @@
+import { FindWorker } from '../../glossary';
 /**
  * Attempts to resolve a Service Worker instance from a given registration,
  * regardless of its state (active, installing, waiting).
  */
-export declare const getWorkerByRegistration: (registration: ServiceWorkerRegistration, absoluteWorkerUrl: string) => ServiceWorker | null;
+export declare const getWorkerByRegistration: (registration: ServiceWorkerRegistration, absoluteWorkerUrl: string, findWorker: FindWorker) => ServiceWorker | null;

package/lib/types/setupWorker/start/utils/getWorkerInstance.d.ts

@@ -1,6 +1,6 @@
-import { ServiceWorkerInstanceTuple } from '../../glossary';
+import { ServiceWorkerInstanceTuple, FindWorker } from '../../glossary';
 /**
  * Returns an active Service Worker instance.
  * When not found, registers a new Service Worker.
  */
-export declare const getWorkerInstance: (url: string, options?: RegistrationOptions | undefined) => Promise<ServiceWorkerInstanceTuple | null>;
+export declare const getWorkerInstance: (url: string, options: RegistrationOptions | undefined, findWorker: FindWorker) => Promise<ServiceWorkerInstanceTuple | null>;

package/lib/types/sharedOptions.d.ts

@@ -1,4 +1,4 @@
-import { OnUnhandledRequest } from './onUnhandledRequest';
+import { OnUnhandledRequest } from './utils/request/onUnhandledRequest';
 export interface SharedOptions {
     /**
      * Specifies how to react to a request that has no corresponding

package/lib/types/utils/getResponse.d.ts

@@ -1,5 +1,5 @@
 import { RequestHandlersList } from '../setupWorker/glossary';
-import { RequestHandler, MockedRequest } from '../handlers/requestHandler';
+import { RequestHandler, MockedRequest } from './handlers/requestHandler';
 import { MockedResponse } from '../response';
 interface ResponsePayload {
     response: MockedResponse | null;
@@ -10,5 +10,5 @@ interface ResponsePayload {
 /**
  * Returns a mocked response for a given request using following request handlers.
  */
-export declare const getResponse: <R extends MockedRequest, H extends RequestHandlersList>(req: R, handlers: H) => Promise<ResponsePayload>;
+export declare const getResponse: <R extends MockedRequest<import("./handlers/requestHandler").DefaultRequestBodyType, import("./handlers/requestHandler").RequestParams>, H extends RequestHandlersList>(req: R, handlers: H) => Promise<ResponsePayload>;
 export {};

package/lib/types/utils/handlers/requestHandler.d.ts

@@ -0,0 +1,74 @@
+import { Headers } from 'headers-utils';
+import { ResponseWithSerializedHeaders } from '../../setupWorker/glossary';
+import { ResponseComposition, MockedResponse } from '../../response';
+import { set } from '../../context/set';
+export declare const defaultContext: {
+    status: (statusCode: number, statusText?: string | undefined) => import("../../response").ResponseTransformer<any>;
+    set: typeof set;
+    delay: (durationMs?: number | undefined) => import("../../response").ResponseTransformer<any>;
+    fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+};
+export declare type DefaultRequestBodyType = Record<string, any> | string | undefined;
+export interface MockedRequest<BodyType = DefaultRequestBodyType, RequestParamsType = RequestParams> {
+    url: URL;
+    method: Request['method'];
+    headers: Headers;
+    cookies: Record<string, string>;
+    mode: Request['mode'];
+    keepalive: Request['keepalive'];
+    cache: Request['cache'];
+    destination: Request['destination'];
+    integrity: Request['integrity'];
+    credentials: Request['credentials'];
+    redirect: Request['redirect'];
+    referrer: Request['referrer'];
+    referrerPolicy: Request['referrerPolicy'];
+    body: BodyType;
+    bodyUsed: Request['bodyUsed'];
+    params: RequestParamsType;
+}
+export declare type RequestQuery = {
+    [queryName: string]: any;
+};
+export declare type RequestParams = {
+    [paramName: string]: any;
+};
+export declare type ResponseResolverReturnType<R> = R | undefined | void;
+export declare type AsyncResponseResolverReturnType<R> = Promise<ResponseResolverReturnType<R>> | ResponseResolverReturnType<R>;
+export declare type ResponseResolver<RequestType = MockedRequest, ContextType = typeof defaultContext, BodyType = any> = (req: RequestType, res: ResponseComposition<BodyType>, context: ContextType) => AsyncResponseResolverReturnType<MockedResponse<BodyType>>;
+export interface RequestHandler<RequestType = MockedRequest, ContextType = typeof defaultContext, ParsedRequest = any, PublicRequest = RequestType, ResponseBodyType = any> {
+    /**
+     * Parses a captured request to retrieve additional
+     * information meant for internal usage in the request handler.
+     */
+    parse?: (req: RequestType) => ParsedRequest | null;
+    /**
+     * Returns a modified request with necessary public properties appended.
+     */
+    getPublicRequest?: (req: RequestType, parsedRequest: ParsedRequest) => PublicRequest;
+    /**
+     * Predicate function that decides whether a Request should be mocked.
+     */
+    predicate: (req: RequestType, parsedRequest: ParsedRequest) => boolean;
+    /**
+     * Returns a mocked response object to the captured request.
+     */
+    resolver: ResponseResolver<RequestType, ContextType, ResponseBodyType>;
+    /**
+     * Returns a map of context utility functions available
+     * under the `ctx` argument of request handler.
+     */
+    defineContext?: (req: PublicRequest) => ContextType;
+    /**
+     * Prints out a mocked request/response information
+     * upon each request capture into browser's console.
+     */
+    log: (req: PublicRequest, res: ResponseWithSerializedHeaders, handler: RequestHandler<RequestType, ContextType, ParsedRequest, PublicRequest, ResponseBodyType>, parsedRequest: ParsedRequest) => void;
+    /**
+     * Describes whether this request handler should be skipped
+     * when dealing with any subsequent matching requests.
+     */
+    shouldSkip?: boolean;
+}
+declare const _default: null;
+export default _default;

package/lib/types/utils/{requestHandlerUtils.d.ts → handlers/requestHandlerUtils.d.ts}

@@ -1,4 +1,4 @@
-import { RequestHandlersList } from '../setupWorker/glossary';
+import { RequestHandlersList } from '../../setupWorker/glossary';
 export declare function use(currentHandlers: RequestHandlersList, ...handlers: RequestHandlersList): void;
 export declare function restoreHandlers(handlers: RequestHandlersList): void;
-export declare function resetHandlers(initialHandlers: RequestHandlersList, ...nextHandlers: RequestHandlersList): import("..").RequestHandler<any, any, any, any>[];
+export declare function resetHandlers(initialHandlers: RequestHandlersList, ...nextHandlers: RequestHandlersList): import("./requestHandler").RequestHandler<any, any, any, any, any>[];

package/lib/types/utils/{isNodeProcess.d.ts → internal/isNodeProcess.d.ts}

@@ -1,4 +1,5 @@
 /**
  * Returns a boolean indicating if the current process is running in NodeJS environment.
+ * @see https://github.com/mswjs/msw/pull/255
  */
 export declare function isNodeProcess(): boolean | undefined;

package/lib/types/utils/internal/mergeRight.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Deeply merges two given objects with the right one
+ * having a priority during property assignment.
+ */
+export declare function mergeRight(a: Record<string, any>, b: Record<string, any>): Record<string, any>;

package/lib/types/utils/{logger → logging}/prepareRequest.d.ts

@@ -1,4 +1,4 @@
-import { MockedRequest } from '../../handlers/requestHandler';
+import { MockedRequest } from '../handlers/requestHandler';
 /**
  * Formats a mocked request for introspection in browser's console.
  */
@@ -16,7 +16,7 @@ export declare function prepareRequest(req: MockedRequest): {
     redirect: RequestRedirect;
     referrer: string;
     referrerPolicy: ReferrerPolicy;
-    body: string | Record<string, any> | undefined;
+    body: import("../handlers/requestHandler").DefaultRequestBodyType;
     bodyUsed: boolean;
-    params: import("../../handlers/requestHandler").RequestParams;
+    params: import("../handlers/requestHandler").RequestParams;
 };

package/lib/types/utils/{logger → logging}/prepareResponse.d.ts

@@ -2,8 +2,8 @@ import { ResponseWithSerializedHeaders } from '../../setupWorker/glossary';
 /**
  * Formats a mocked response for introspection in browser's console.
  */
-export declare function prepareResponse(res: ResponseWithSerializedHeaders): {
-    body: any;
+export declare function prepareResponse(res: ResponseWithSerializedHeaders<any>): {
+    body: import("../handlers/requestHandler").DefaultRequestBodyType;
     status: number;
     statusText: string;
     once: boolean;

package/lib/types/utils/request/getPublicUrlFromRequest.d.ts

@@ -0,0 +1,6 @@
+import { MockedRequest } from '../handlers/requestHandler';
+/**
+ * Returns a relative URL if the given request URL is relative to the current origin.
+ * Otherwise returns an absolute URL.
+ */
+export declare const getPublicUrlFromRequest: (request: MockedRequest) => string;

package/lib/types/utils/request/getRequestCookies.d.ts

@@ -1,4 +1,4 @@
-import { MockedRequest } from '../../handlers/requestHandler';
+import { MockedRequest } from '../handlers/requestHandler';
 /**
  * Returns relevant document cookies based on the request `credentials` option.
  */

package/lib/types/{onUnhandledRequest.d.ts → utils/request/onUnhandledRequest.d.ts}

@@ -1,4 +1,4 @@
-import { MockedRequest } from './handlers/requestHandler';
+import { MockedRequest } from '../handlers/requestHandler';
 declare type UnhandledRequestCallback = (req: MockedRequest) => void;
 export declare type OnUnhandledRequest = 'bypass' | 'warn' | 'error' | UnhandledRequestCallback;
 export declare function onUnhandledRequest(request: MockedRequest, onUnhandledRequest?: OnUnhandledRequest): void;

package/lib/types/utils/request/parseBody.d.ts

@@ -0,0 +1,5 @@
+import { MockedRequest } from '../handlers/requestHandler';
+/**
+ * Parses a given request/response body based on the `Content-Type` header.
+ */
+export declare function parseBody(body?: MockedRequest['body'], headers?: Headers): import("../handlers/requestHandler").DefaultRequestBodyType;

package/lib/types/utils/url/getAbsoluteUrl.d.ts

@@ -0,0 +1,6 @@
+import { Mask } from '../../setupWorker/glossary';
+/**
+ * Returns an absolute URL based on the given relative URL, if possible.
+ * Ignores regular expressions.
+ */
+export declare const getAbsoluteUrl: <T extends Mask>(mask: T) => T;

package/lib/types/utils/url/getUrlByMask.d.ts

@@ -0,0 +1,5 @@
+import { Mask } from '../../setupWorker/glossary';
+/**
+ * Converts a given request handler mask into a URL, if given a valid URL string.
+ */
+export declare function getUrlByMask(mask: Mask): URL | Mask;