msw 0.33.2 → 0.36.0

package/lib/iife/mockServiceWorker.js

@@ -2,13 +2,13 @@
 /* tslint:disable */
 
 /**
- * Mock Service Worker (0.33.2).
+ * Mock Service Worker (0.36.0).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.
  */
 
-const INTEGRITY_CHECKSUM = 'a615cd395ea10f948a628bce3857a385'
+const INTEGRITY_CHECKSUM = '02f4ad4a2797f85668baf196e553d929'
 const bypassHeaderName = 'x-msw-bypass'
 const activeClientIds = new Set()
 
@@ -83,11 +83,11 @@ self.addEventListener('message', async function (event) {
   }
 })
 
-// Resolve the "master" client for the given event.
+// Resolve the "main" client for the given event.
 // Client that issues a request doesn't necessarily equal the client
 // that registered the worker. It's with the latter the worker should
 // communicate with during the response resolving phase.
-async function resolveMasterClient(event) {
+async function resolveMainClient(event) {
   const client = await self.clients.get(event.clientId)
 
   if (client.frameType === 'top-level') {
@@ -109,7 +109,7 @@ async function resolveMasterClient(event) {
 }
 
 async function handleRequest(event, requestId) {
-  const client = await resolveMasterClient(event)
+  const client = await resolveMainClient(event)
   const response = await getResponse(event, client, requestId)
 
   // Send back the response clone for the "response:*" life-cycle events.
@@ -221,13 +221,11 @@ async function getResponse(event, client, requestId) {
 
       console.error(
         `\
-[MSW] Request handler function for "%s %s" has thrown the following exception:
+[MSW] Uncaught exception in the request handler for "%s %s":
 
-${parsedBody.errorType}: ${parsedBody.message}
-(see more detailed error stack trace in the mocked response body)
+${parsedBody.location}
 
-This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error.
-If you wish to mock an error response, please refer to this guide: https://mswjs.io/docs/recipes/mocking-error-responses\
+This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/recipes/mocking-error-responses\
 `,
         request.method,
         request.url,
@@ -271,11 +269,22 @@ self.addEventListener('fetch', function (event) {
 
   return event.respondWith(
     handleRequest(event, requestId).catch((error) => {
+      if (error.name === 'NetworkError') {
+        console.warn(
+          '[MSW] Successfully emulated a network error for the "%s %s" request.',
+          request.method,
+          request.url,
+        )
+        return
+      }
+
+      // At this point, any exception indicates an issue with the original request/response.
       console.error(
-        '[MSW] Failed to mock a "%s" request to "%s": %s',
+        `\
+[MSW] Caught an exception from the "%s %s" request (%s). This is probably not a problem with Mock Service Worker. There is likely an additional logging output above.`,
         request.method,
         request.url,
-        error,
+        `${error.name}: ${error.message}`,
       )
     }),
   )

package/lib/types/context/data.d.ts

@@ -1,9 +1,8 @@
-import { ResponseTransformer } from '../response';
-export declare type DataContext<T> = (payload: T) => ResponseTransformer;
+import { GraphQLPayloadContext } from '../typeUtils';
 /**
  * Sets a given payload as a GraphQL response body.
  * @example
  * res(ctx.data({ user: { firstName: 'John' }}))
  * @see {@link https://mswjs.io/docs/api/context/data `ctx.data()`}
  */
-export declare const data: DataContext<Record<string, unknown>>;
+export declare const data: GraphQLPayloadContext<Record<string, unknown>>;

package/lib/types/context/extensions.d.ts

@@ -0,0 +1,8 @@
+import { GraphQLPayloadContext } from '../typeUtils';
+/**
+ * Sets the GraphQL extensions on a given response.
+ * @example
+ * res(ctx.extensions({ tracing: { version: 1 }}))
+ * @see {@link https://mswjs.io/docs/api/context/extensions `ctx.extensions()`}
+ */
+export declare const extensions: GraphQLPayloadContext<Record<string, unknown>>;

package/lib/types/context/index.d.ts

@@ -3,6 +3,7 @@ export { set } from './set';
 export { cookie } from './cookie';
 export { body } from './body';
 export { data } from './data';
+export { extensions } from './extensions';
 export { delay } from './delay';
 export { errors } from './errors';
 export { fetch } from './fetch';

package/lib/types/graphql.d.ts

@@ -1,12 +1,13 @@
 import { DocumentNode } from 'graphql';
-import { Path } from 'node-match-path';
 import { ResponseResolver } from './handlers/RequestHandler';
 import { GraphQLHandler, GraphQLContext, GraphQLRequest, GraphQLVariables, GraphQLHandlerNameSelector } from './handlers/GraphQLHandler';
+import { Path } from './utils/matching/matchRequestUrl';
 export interface TypedDocumentNode<Result = {
     [key: string]: any;
 }, Variables = {
     [key: string]: any;
 }> extends DocumentNode {
+    __apiType?: (variables: Variables) => Result;
     __resultType?: Result;
     __variablesType?: Variables;
 }

package/lib/types/handlers/GraphQLHandler.d.ts

@@ -1,23 +1,24 @@
 import { DocumentNode, OperationTypeNode } from 'graphql';
-import { Path } from 'node-match-path';
 import { SerializedResponse } from '../setupWorker/glossary';
 import { set } from '../context/set';
 import { status } from '../context/status';
 import { delay } from '../context/delay';
 import { fetch } from '../context/fetch';
-import { DataContext } from '../context/data';
 import { errors } from '../context/errors';
+import { GraphQLPayloadContext } from '../typeUtils';
 import { cookie } from '../context/cookie';
 import { MockedRequest, RequestHandler, ResponseResolver } from './RequestHandler';
+import { Path } from '../utils/matching/matchRequestUrl';
 import { ParsedGraphQLRequest, GraphQLMultipartRequestBody } from '../utils/internal/parseGraphQLRequest';
 export declare type ExpectedOperationTypeNode = OperationTypeNode | 'all';
 export declare type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
-export declare type GraphQLContext<QueryType> = {
+export declare type GraphQLContext<QueryType extends Record<string, unknown>> = {
     set: typeof set;
     status: typeof status;
     delay: typeof delay;
     fetch: typeof fetch;
-    data: DataContext<QueryType>;
+    data: GraphQLPayloadContext<QueryType>;
+    extensions: GraphQLPayloadContext<QueryType>;
     errors: typeof errors;
     cookie: typeof cookie;
 };

package/lib/types/handlers/RequestHandler.d.ts

@@ -10,7 +10,7 @@ export declare const defaultContext: {
     fetch: (input: string | MockedRequest<DefaultRequestBody>, requestInit?: RequestInit) => Promise<Response>;
 };
 export declare type DefaultRequestMultipartBody = Record<string, string | File | (string | File)[]>;
-export declare type DefaultRequestBody = Record<string, any> | DefaultRequestMultipartBody | string | undefined;
+export declare type DefaultRequestBody = Record<string, any> | DefaultRequestMultipartBody | string | number | undefined;
 export interface MockedRequest<Body = DefaultRequestBody> {
     id: string;
     url: URL;

package/lib/types/handlers/RestHandler.d.ts

@@ -1,10 +1,11 @@
-import { Match, Path } from 'node-match-path';
 import { body, cookie, delay, fetch, json, set, status, text, xml } from '../context';
 import { SerializedResponse } from '../setupWorker/glossary';
 import { ResponseResolutionContext } from '../utils/getResponse';
+import { Match, Path, PathParams } from '../utils/matching/matchRequestUrl';
 import { DefaultRequestBody, MockedRequest, RequestHandler, ResponseResolver } from './RequestHandler';
+declare type RestHandlerMethod = string | RegExp;
 interface RestHandlerInfo {
-    method: string;
+    method: RestHandlerMethod;
     path: Path;
 }
 export declare enum RESTMethods {
@@ -28,13 +29,10 @@ export declare type RestContext = {
     fetch: typeof fetch;
 };
 export declare const restContext: RestContext;
-export declare type RequestParams = {
-    [paramName: string]: any;
-};
 export declare type RequestQuery = {
-    [queryName: string]: any;
+    [queryName: string]: string;
 };
-export interface RestRequest<BodyType extends DefaultRequestBody = DefaultRequestBody, ParamsType extends RequestParams = Record<string, any>> extends MockedRequest<BodyType> {
+export interface RestRequest<BodyType extends DefaultRequestBody = DefaultRequestBody, ParamsType extends PathParams = PathParams> extends MockedRequest<BodyType> {
     params: ParamsType;
 }
 export declare type ParsedRestRequest = Match;
@@ -42,11 +40,11 @@ export declare type ParsedRestRequest = Match;
  * Request handler for REST API requests.
  * Provides request matching based on method and URL.
  */
-export declare class RestHandler<RequestType extends MockedRequest<DefaultRequestBody> = MockedRequest<DefaultRequestBody>> extends RequestHandler<RestHandlerInfo, RequestType, ParsedRestRequest, RestRequest<RequestParams>> {
-    constructor(method: string, path: Path, resolver: ResponseResolver<any, any>);
+export declare class RestHandler<RequestType extends MockedRequest<DefaultRequestBody> = MockedRequest<DefaultRequestBody>> extends RequestHandler<RestHandlerInfo, RequestType, ParsedRestRequest, RestRequest<RequestType extends MockedRequest<infer RequestBodyType> ? RequestBodyType : any, PathParams>> {
+    constructor(method: RestHandlerMethod, path: Path, resolver: ResponseResolver<any, any>);
     private checkRedundantQueryParameters;
     parse(request: RequestType, resolutionContext?: ResponseResolutionContext): Match;
-    protected getPublicRequest(request: RequestType, parsedResult: ParsedRestRequest): RestRequest<any, RequestParams>;
+    protected getPublicRequest(request: RequestType, parsedResult: ParsedRestRequest): RestRequest<any, PathParams>;
     predicate(request: RequestType, parsedResult: ParsedRestRequest): boolean;
     log(request: RequestType, response: SerializedResponse): void;
 }

package/lib/types/index.d.ts

@@ -1,16 +1,26 @@
 import * as context from './context';
 export { context };
 export { setupWorker } from './setupWorker/setupWorker';
-export { SetupWorkerApi } from './setupWorker/glossary';
-export { response, defaultResponse, createResponseComposition, MockedResponse, ResponseTransformer, ResponseComposition, ResponseCompositionOptions, ResponseFunction, } from './response';
-export { RequestHandler, MockedRequest, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, DefaultRequestBody, DefaultRequestMultipartBody, defaultContext, } from './handlers/RequestHandler';
+export { response, defaultResponse, createResponseComposition, } from './response';
+export { RequestHandler, defaultContext } from './handlers/RequestHandler';
 export { rest } from './rest';
-export { RestHandler, RESTMethods, RestContext, RequestParams, RequestQuery, RestRequest, ParsedRestRequest, restContext, } from './handlers/RestHandler';
+export { RestHandler, RESTMethods, restContext } from './handlers/RestHandler';
 export { graphql } from './graphql';
-export { GraphQLHandler, GraphQLContext, GraphQLVariables, GraphQLRequest, GraphQLRequestBody, GraphQLJsonRequestBody, graphqlContext, } from './handlers/GraphQLHandler';
+export { GraphQLHandler, graphqlContext } from './handlers/GraphQLHandler';
 export { matchRequestUrl } from './utils/matching/matchRequestUrl';
 export { compose } from './utils/internal/compose';
-export { DelayMode } from './context/delay';
-export { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest';
 export * from './utils/handleRequest';
 export * from './utils/request/parseIsomorphicRequest';
+export { cleanUrl } from './utils/url/cleanUrl';
+/**
+ * Type definitions.
+ */
+export type { SetupWorkerApi, StartOptions } from './setupWorker/glossary';
+export type { SharedOptions } from './sharedOptions';
+export type { MockedRequest, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, DefaultRequestBody, DefaultRequestMultipartBody, } from './handlers/RequestHandler';
+export type { MockedResponse, ResponseTransformer, ResponseComposition, ResponseCompositionOptions, ResponseFunction, } from './response';
+export type { RestContext, RequestQuery, RestRequest, ParsedRestRequest, } from './handlers/RestHandler';
+export type { GraphQLContext, GraphQLVariables, GraphQLRequest, GraphQLRequestBody, GraphQLJsonRequestBody, } from './handlers/GraphQLHandler';
+export type { Path, PathParams, Match } from './utils/matching/matchRequestUrl';
+export type { DelayMode } from './context/delay';
+export { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest';

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

@@ -1,15 +1,8 @@
 import { PartialDeep } from 'type-fest';
 import { IsomorphicResponse } from '@mswjs/interceptors';
-import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
-import { SharedOptions } from '../sharedOptions';
-export interface ServerLifecycleEventsMap {
-    'request:start': (request: MockedRequest) => void;
-    'request:match': (request: MockedRequest) => void;
-    'request:unhandled': (request: MockedRequest) => void;
-    'request:end': (request: MockedRequest) => void;
-    'response:mocked': (response: IsomorphicResponse, requestId: string) => void;
-    'response:bypass': (response: IsomorphicResponse, requestId: string) => void;
-}
+import { RequestHandler } from '../handlers/RequestHandler';
+import { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions } from '../sharedOptions';
+export declare type ServerLifecycleEventsMap = LifeCycleEventsMap<IsomorphicResponse>;
 export interface SetupServerApi {
     /**
      * Starts requests interception based on the previously provided request handlers.
@@ -41,8 +34,5 @@ export interface SetupServerApi {
      * @see {@link https://mswjs.io/docs/api/setup-server/print-handlers `server.print-handlers()`}
      */
     printHandlers(): void;
-    /**
-     * Attaches a listener to one of the life-cycle events.
-     */
-    on<EventType extends keyof ServerLifecycleEventsMap>(eventType: EventType, listener: ServerLifecycleEventsMap[EventType]): void;
+    events: LifeCycleEventEmitter<ServerLifecycleEventsMap>;
 }

package/lib/types/node/index.d.ts

@@ -1,2 +1,2 @@
 export { setupServer } from './setupServer';
-export { SetupServerApi } from './glossary';
+export type { SetupServerApi } from './glossary';

package/lib/types/rest.d.ts

@@ -1,12 +1,13 @@
-import { Path } from 'node-match-path';
 import { DefaultRequestBody, ResponseResolver } from './handlers/RequestHandler';
-import { RestContext, RestHandler, RestRequest, RequestParams } from './handlers/RestHandler';
+import { RestContext, RestHandler, RestRequest } from './handlers/RestHandler';
+import { Path, PathParams } from './utils/matching/matchRequestUrl';
 export declare const rest: {
-    head: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
-    get: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
-    post: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
-    put: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
-    delete: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
-    patch: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
-    options: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, ResponseBody extends DefaultRequestBody = any, Params extends RequestParams = RequestParams>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    all: <RequestBodyType extends DefaultRequestBody = DefaultRequestBody, Params extends PathParams = PathParams, ResponseBody extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType, Params>, RestContext, ResponseBody>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    head: <RequestBodyType_1 extends DefaultRequestBody = DefaultRequestBody, Params_1 extends PathParams = PathParams, ResponseBody_1 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<never, Params_1>, RestContext, ResponseBody_1>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    get: <RequestBodyType_2 extends DefaultRequestBody = DefaultRequestBody, Params_2 extends PathParams = PathParams, ResponseBody_2 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<never, Params_2>, RestContext, ResponseBody_2>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    post: <RequestBodyType_3 extends DefaultRequestBody = DefaultRequestBody, Params_3 extends PathParams = PathParams, ResponseBody_3 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_3, Params_3>, RestContext, ResponseBody_3>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    put: <RequestBodyType_4 extends DefaultRequestBody = DefaultRequestBody, Params_4 extends PathParams = PathParams, ResponseBody_4 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_4, Params_4>, RestContext, ResponseBody_4>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    delete: <RequestBodyType_5 extends DefaultRequestBody = DefaultRequestBody, Params_5 extends PathParams = PathParams, ResponseBody_5 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_5, Params_5>, RestContext, ResponseBody_5>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    patch: <RequestBodyType_6 extends DefaultRequestBody = DefaultRequestBody, Params_6 extends PathParams = PathParams, ResponseBody_6 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_6, Params_6>, RestContext, ResponseBody_6>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
+    options: <RequestBodyType_7 extends DefaultRequestBody = DefaultRequestBody, Params_7 extends PathParams = PathParams, ResponseBody_7 extends DefaultRequestBody = DefaultRequestBody>(path: Path, resolver: ResponseResolver<RestRequest<RequestBodyType_7, Params_7>, RestContext, ResponseBody_7>) => RestHandler<import("./handlers/RequestHandler").MockedRequest<DefaultRequestBody>>;
 };

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

@@ -1,11 +1,11 @@
-import { Path } from 'node-match-path';
-import { PartialDeep } from 'type-fest';
 import { FlatHeadersObject } from 'headers-utils';
 import { StrictEventEmitter } from 'strict-event-emitter';
-import { SharedOptions } from '../sharedOptions';
+import { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions } from '../sharedOptions';
 import { ServiceWorkerMessage } from '../utils/createBroadcastChannel';
-import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
+import { RequestHandler } from '../handlers/RequestHandler';
 import { InterceptorApi } from '@mswjs/interceptors';
+import { Path } from '../utils/matching/matchRequestUrl';
+import { RequiredDeep } from '../typeUtils';
 export declare type ResolvedPath = Path | URL;
 declare type RequestWithoutMethods = Omit<Request, 'text' | 'body' | 'json' | 'blob' | 'arrayBuffer' | 'formData' | 'clone' | 'signal' | 'isHistoryNavigation' | 'isReloadNavigation'>;
 /**
@@ -45,16 +45,9 @@ export declare type ServiceWorkerOutgoingEventTypes = 'MOCK_ACTIVATE' | 'MOCK_DE
  * only as a part of a single `fetch` event handler.
  */
 export declare type ServiceWorkerFetchEventTypes = 'MOCK_SUCCESS' | 'MOCK_NOT_FOUND' | 'NETWORK_ERROR' | 'INTERNAL_ERROR';
-export interface WorkerLifecycleEventsMap {
-    'request:start': (request: MockedRequest) => void;
-    'request:match': (request: MockedRequest) => void;
-    'request:unhandled': (request: MockedRequest) => void;
-    'request:end': (request: MockedRequest) => void;
-    'response:mocked': (response: Response, requestId: string) => void;
-    'response:bypass': (response: Response, requestId: string) => void;
-}
+export declare type WorkerLifecycleEventsMap = LifeCycleEventsMap<Response>;
 export interface SetupWorkerInternalContext {
-    startOptions?: StartOptions;
+    startOptions?: RequiredDeep<StartOptions>;
     worker: ServiceWorker | null;
     registration: ServiceWorkerRegistration | null;
     requestHandlers: RequestHandler[];
@@ -72,7 +65,7 @@ export interface SetupWorkerInternalContext {
          * Adds an event listener on the given target.
          * Returns a clean-up function that removes that listener.
          */
-        addListener<E extends Event>(target: EventTarget, eventType: string, listener: (event: E) => void): () => void;
+        addListener<EventType extends Event = Event>(target: EventTarget, eventType: string, listener: (event: EventType) => void): () => void;
         /**
          * Removes all currently attached listeners.
          */
@@ -94,25 +87,25 @@ export interface StartOptions extends SharedOptions {
     /**
      * Service Worker instance options.
      */
-    serviceWorker: {
-        url: string;
-        options: RegistrationOptions;
+    serviceWorker?: {
+        url?: string;
+        options?: RegistrationOptions;
     };
     /**
      * Disables the logging of captured requests
      * into browser's console.
      */
-    quiet: boolean;
+    quiet?: boolean;
     /**
      * Defers any network requests until the Service Worker
      * instance is ready. Defaults to `true`.
      */
-    waitUntilReady: boolean;
+    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;
+    findWorker?: FindWorker;
 }
 export interface SerializedResponse<BodyType = any> {
     status: number;
@@ -121,14 +114,14 @@ export interface SerializedResponse<BodyType = any> {
     body: BodyType;
 }
 export declare type StartReturnType = Promise<ServiceWorkerRegistration | undefined>;
-export declare type StartHandler = (options: StartOptions, initialOptions: PartialDeep<StartOptions>) => StartReturnType;
+export declare type StartHandler = (options: RequiredDeep<StartOptions>, initialOptions: StartOptions) => StartReturnType;
 export declare type StopHandler = () => void;
 export interface SetupWorkerApi {
     /**
      * Registers and activates the mock Service Worker.
      * @see {@link https://mswjs.io/docs/api/setup-worker/start `worker.start()`}
      */
-    start: (options?: PartialDeep<StartOptions>) => StartReturnType;
+    start: (options?: StartOptions) => StartReturnType;
     /**
      * Stops requests interception for the current client.
      * @see {@link https://mswjs.io/docs/api/setup-worker/stop `worker.stop()`}
@@ -156,9 +149,6 @@ export interface SetupWorkerApi {
      * @see {@link https://mswjs.io/docs/api/setup-worker/print-handlers `worker.printHandlers()`}
      */
     printHandlers: () => void;
-    /**
-     * Attaches a listener to one of the life-cycle events.
-     */
-    on<EventType extends keyof WorkerLifecycleEventsMap>(eventType: EventType, listener: WorkerLifecycleEventsMap[EventType]): void;
+    events: LifeCycleEventEmitter<WorkerLifecycleEventsMap>;
 }
 export {};

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

@@ -1,9 +1,9 @@
-import { PartialDeep } from 'type-fest';
+import { RequiredDeep } from '../../../typeUtils';
 import { SetupWorkerApi, SetupWorkerInternalContext, StartHandler, StartOptions } from '../../glossary';
-export declare const DEFAULT_START_OPTIONS: StartOptions;
+export declare const DEFAULT_START_OPTIONS: RequiredDeep<StartOptions>;
 /**
  * Returns resolved worker start options, merging the default options
  * with the given custom options.
  */
-export declare function resolveStartOptions(initialOptions?: PartialDeep<StartOptions>): StartOptions;
+export declare function resolveStartOptions(initialOptions?: StartOptions): RequiredDeep<StartOptions>;
 export declare function prepareStartHandler(handler: StartHandler, context: SetupWorkerInternalContext): SetupWorkerApi['start'];

package/lib/types/sharedOptions.d.ts

@@ -1,3 +1,5 @@
+import { StrictEventEmitter } from 'strict-event-emitter';
+import { MockedRequest } from './handlers/RequestHandler';
 import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest';
 export interface SharedOptions {
     /**
@@ -8,5 +10,14 @@ export interface SharedOptions {
      * @example worker.start({ onUnhandledRequest: 'warn' })
      * @example server.listen({ onUnhandledRequest: 'error' })
      */
-    onUnhandledRequest: UnhandledRequestStrategy;
+    onUnhandledRequest?: UnhandledRequestStrategy;
 }
+export interface LifeCycleEventsMap<ResponseType> {
+    'request:start': (request: MockedRequest) => void;
+    'request:match': (request: MockedRequest) => void;
+    'request:unhandled': (request: MockedRequest) => void;
+    'request:end': (request: MockedRequest) => void;
+    'response:mocked': (response: ResponseType, requestId: string) => void;
+    'response:bypass': (response: ResponseType, requestId: string) => void;
+}
+export declare type LifeCycleEventEmitter<ResponseType> = Pick<StrictEventEmitter<ResponseType>, 'on' | 'removeListener' | 'removeAllListeners'>;

package/lib/types/typeUtils.d.ts

@@ -1,5 +1,7 @@
+import { ResponseTransformer } from './response';
 declare type Fn = (...arg: any[]) => any;
-export declare type DeepRequired<T, U extends Record<string, any> | Fn | undefined = undefined> = T extends Record<string, any> ? {
-    [P in keyof T]-?: NonNullable<T[P]> extends NonNullable<U | Fn> ? NonNullable<T[P]> : DeepRequired<NonNullable<T[P]>, U>;
-} : T;
+export declare type RequiredDeep<Type, U extends Record<string, unknown> | Fn | undefined = undefined> = Type extends Fn ? Type : Type extends Record<string, any> ? {
+    [Key in keyof Type]-?: NonNullable<Type[Key]> extends NonNullable<U> ? NonNullable<Type[Key]> : RequiredDeep<NonNullable<Type[Key]>, U>;
+} : Type;
+export declare type GraphQLPayloadContext<QueryType extends Record<string, unknown>> = (payload: QueryType) => ResponseTransformer;
 export {};

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

@@ -3,7 +3,7 @@ import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
 import { ServerLifecycleEventsMap } from '../node/glossary';
 import { MockedResponse } from '../response';
 import { SharedOptions } from '../sharedOptions';
-import { DeepRequired } from '../typeUtils';
+import { RequiredDeep } from '../typeUtils';
 import { ResponseLookupResult } from './getResponse';
 export interface HandleRequestOptions<ResponseType> {
     /**
@@ -24,11 +24,11 @@ export interface HandleRequestOptions<ResponseType> {
     /**
      * Invoked when the mocked response is ready to be sent.
      */
-    onMockedResponse?(response: ResponseType, handler: DeepRequired<ResponseLookupResult>): void;
+    onMockedResponse?(response: ResponseType, handler: RequiredDeep<ResponseLookupResult>): void;
     /**
      * Invoked when the mocked response is sent.
      * Respects the response delay duration.
      */
-    onMockedResponseSent?(response: ResponseType, handler: DeepRequired<ResponseLookupResult>): void;
+    onMockedResponseSent?(response: ResponseType, handler: RequiredDeep<ResponseLookupResult>): void;
 }
-export declare function handleRequest<ResponseType extends Record<string, any> = MockedResponse<string>>(request: MockedRequest, handlers: RequestHandler[], options: SharedOptions, emitter: StrictEventEmitter<ServerLifecycleEventsMap>, handleRequestOptions?: HandleRequestOptions<ResponseType>): Promise<ResponseType | undefined>;
+export declare function handleRequest<ResponseType extends Record<string, any> = MockedResponse<string>>(request: MockedRequest, handlers: RequestHandler[], options: RequiredDeep<SharedOptions>, emitter: StrictEventEmitter<ServerLifecycleEventsMap>, handleRequestOptions?: HandleRequestOptions<ResponseType>): Promise<ResponseType | undefined>;

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

@@ -1,4 +1,4 @@
 /**
  * Return the stack trace frame of a function's invocation.
  */
-export declare function getCallFrame(): string | undefined;
+export declare function getCallFrame(error: Error): string | undefined;

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

@@ -1,5 +1,5 @@
 /**
- * Parses a given string into a JSON.
+ * Parses a given value into a JSON.
  * Does not throw an exception on an invalid JSON string.
  */
-export declare function jsonParse<T extends Record<string, any>>(str: string): T | undefined;
+export declare function jsonParse<ValueType extends Record<string, any>>(value: any): ValueType | undefined;

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { EventEmitter } from 'stream';
+/**
+ * Pipes all emitted events from one emitter to another.
+ */
+export declare function pipeEvents(source: EventEmitter, destination: EventEmitter): void;

package/lib/types/utils/logging/prepareResponse.d.ts

@@ -3,7 +3,7 @@ import { SerializedResponse } from '../../setupWorker/glossary';
  * Formats a mocked response for introspection in the browser's console.
  */
 export declare function prepareResponse(res: SerializedResponse<any>): {
-    body: string | Record<string, any> | undefined;
+    body: string | number | Record<string, any> | undefined;
     status: number;
     statusText: string;
     headers: import("headers-utils").FlatHeadersObject;

package/lib/types/utils/matching/matchRequestUrl.d.ts

@@ -1,5 +1,15 @@
-import { Path, match } from 'node-match-path';
+export declare type Path = string | RegExp;
+export declare type PathParams = Record<string, string | string[]>;
+export interface Match {
+    matches: boolean;
+    params?: PathParams;
+}
+/**
+ * Coerce a path supported by MSW into a path
+ * supported by "path-to-regexp".
+ */
+export declare function coercePath(path: string): string;
 /**
  * Returns the result of matching given request URL against a mask.
  */
-export declare function matchRequestUrl(url: URL, path: Path, baseUrl?: string): ReturnType<typeof match>;
+export declare function matchRequestUrl(url: URL, path: Path, baseUrl?: string): Match;

package/lib/types/utils/matching/normalizePath.d.ts

@@ -1,4 +1,4 @@
-import { Path } from 'node-match-path';
+import type { Path } from './matchRequestUrl';
 /**
  * Normalizes a given request handler path:
  * - Preserves RegExp.

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

@@ -1,5 +1,5 @@
 import { MockedRequest } from '../../handlers/RequestHandler';
 /**
- * Parses a given request/response body based on the `Content-Type` header.
+ * Parses a given request/response body based on the "Content-Type" header.
  */
-export declare function parseBody(body?: MockedRequest['body'], headers?: Headers): string | Record<string, any> | undefined;
+export declare function parseBody(body?: MockedRequest['body'], headers?: Headers): string | number | Record<string, any> | undefined;

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

@@ -1,7 +1,7 @@
-import { MockedRequest } from '../../handlers/RequestHandler';
+import { RestRequest } from '../../handlers/RestHandler';
 import { ServiceWorkerIncomingRequest } from '../../setupWorker/glossary';
 /**
  * Converts a given request received from the Service Worker
  * into a `MockedRequest` instance.
  */
-export declare function parseWorkerRequest(rawRequest: ServiceWorkerIncomingRequest): MockedRequest;
+export declare function parseWorkerRequest(rawRequest: ServiceWorkerIncomingRequest): RestRequest;

package/lib/types/utils/worker/createFallbackRequestListener.d.ts

@@ -1,3 +1,4 @@
 import { InterceptorApi } from '@mswjs/interceptors';
 import { SetupWorkerInternalContext, StartOptions } from '../../setupWorker/glossary';
-export declare function createFallbackRequestListener(context: SetupWorkerInternalContext, options: StartOptions): InterceptorApi;
+import { RequiredDeep } from '../../typeUtils';
+export declare function createFallbackRequestListener(context: SetupWorkerInternalContext, options: RequiredDeep<StartOptions>): InterceptorApi;

package/lib/types/utils/worker/createRequestListener.d.ts

@@ -1,3 +1,4 @@
 import { StartOptions, SetupWorkerInternalContext, ServiceWorkerIncomingEventsMap } from '../../setupWorker/glossary';
 import { ServiceWorkerMessage } from '../createBroadcastChannel';
-export declare const createRequestListener: (context: SetupWorkerInternalContext, options: StartOptions) => (event: MessageEvent, message: ServiceWorkerMessage<'REQUEST', ServiceWorkerIncomingEventsMap['REQUEST']>) => Promise<void>;
+import { RequiredDeep } from '../../typeUtils';
+export declare const createRequestListener: (context: SetupWorkerInternalContext, options: RequiredDeep<StartOptions>) => (event: MessageEvent, message: ServiceWorkerMessage<'REQUEST', ServiceWorkerIncomingEventsMap['REQUEST']>) => Promise<void>;