msw 0.34.0 → 0.36.2

package/lib/iife/mockServiceWorker.js

@@ -2,13 +2,13 @@
 /* tslint:disable */
 
 /**
- * Mock Service Worker (0.34.0).
+ * Mock Service Worker (0.36.2).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.
  */
 
-const INTEGRITY_CHECKSUM = 'f0a916b13c8acc2b526a03a6d26df85f'
+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.

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,29 +1,30 @@
 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 { MockedRequest, RequestHandler, RequestHandlerDefaultInfo, 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;
 };
 export declare const graphqlContext: GraphQLContext<any>;
 export declare type GraphQLVariables = Record<string, any>;
-export interface GraphQLHandlerInfo {
+export interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
     operationType: ExpectedOperationTypeNode;
     operationName: GraphQLHandlerNameSelector;
 }

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;
@@ -29,19 +29,19 @@ export interface MockedRequest<Body = DefaultRequestBody> {
     body: Body;
     bodyUsed: Request['bodyUsed'];
 }
-interface RequestHandlerDefaultInfo {
+export interface RequestHandlerDefaultInfo {
+    header: string;
+}
+export interface RequestHandlerInternalInfo {
     callFrame?: string;
 }
-declare type RequestHandlerInfo<ExtraInfo extends Record<string, any>> = {
-    header: string;
-} & ExtraInfo;
 declare type ContextMap = Record<string, (...args: any[]) => any>;
 export declare type ResponseResolverReturnType<ReturnType> = ReturnType | undefined | void;
 export declare type MaybeAsyncResponseResolverReturnType<ReturnType> = ResponseResolverReturnType<ReturnType> | Promise<ResponseResolverReturnType<ReturnType>>;
 export declare type AsyncResponseResolverReturnType<ReturnType> = MaybeAsyncResponseResolverReturnType<ReturnType> | Generator<MaybeAsyncResponseResolverReturnType<ReturnType>, MaybeAsyncResponseResolverReturnType<ReturnType>, MaybeAsyncResponseResolverReturnType<ReturnType>>;
 export declare type ResponseResolver<RequestType = MockedRequest, ContextType = typeof defaultContext, BodyType = any> = (req: RequestType, res: ResponseComposition<BodyType>, context: ContextType) => AsyncResponseResolverReturnType<MockedResponse<BodyType>>;
 export interface RequestHandlerOptions<HandlerInfo> {
-    info: RequestHandlerInfo<HandlerInfo>;
+    info: HandlerInfo;
     resolver: ResponseResolver<any, any>;
     ctx?: ContextMap;
 }
@@ -51,8 +51,8 @@ export interface RequestHandlerExecutionResult<PublicRequestType> {
     request: PublicRequestType;
     response?: MockedResponse;
 }
-export declare abstract class RequestHandler<HandlerInfo extends Record<string, any> = Record<string, any>, Request extends MockedRequest = MockedRequest, ParsedResult = any, PublicRequest extends MockedRequest = Request> {
-    info: RequestHandlerDefaultInfo & RequestHandlerInfo<HandlerInfo>;
+export declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, Request extends MockedRequest = MockedRequest, ParsedResult = any, PublicRequest extends MockedRequest = Request> {
+    info: HandlerInfo & RequestHandlerInternalInfo;
     shouldSkip: boolean;
     private ctx;
     private resolverGenerator?;

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 { DefaultRequestBody, MockedRequest, RequestHandler, ResponseResolver } from './RequestHandler';
-interface RestHandlerInfo {
-    method: string;
+import { Match, Path, PathParams } from '../utils/matching/matchRequestUrl';
+import { DefaultRequestBody, MockedRequest, RequestHandler, RequestHandlerDefaultInfo, ResponseResolver } from './RequestHandler';
+declare type RestHandlerMethod = string | RegExp;
+export interface RestHandlerInfo extends RequestHandlerDefaultInfo {
+    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/native/index.d.ts

@@ -1 +1 @@
-export declare const setupServer: (...requestHandlers: import("..").RequestHandler<Record<string, any>, import("..").MockedRequest<import("..").DefaultRequestBody>, any, import("..").MockedRequest<import("..").DefaultRequestBody>>[]) => import("../node").SetupServerApi;
+export declare const setupServer: (...requestHandlers: import("..").RequestHandler<import("../handlers/RequestHandler").RequestHandlerDefaultInfo, import("..").MockedRequest<import("..").DefaultRequestBody>, any, import("..").MockedRequest<import("..").DefaultRequestBody>>[]) => import("../node").SetupServerApi;

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/node/setupServer.d.ts

@@ -3,4 +3,4 @@
  * @param {RequestHandler[]} requestHandlers List of request handlers.
  * @see {@link https://mswjs.io/docs/api/setup-server `setupServer`}
  */
-export declare const setupServer: (...requestHandlers: import("..").RequestHandler<Record<string, any>, import("..").MockedRequest<import("..").DefaultRequestBody>, any, import("..").MockedRequest<import("..").DefaultRequestBody>>[]) => import("./glossary").SetupServerApi;
+export declare const setupServer: (...requestHandlers: import("..").RequestHandler<import("../handlers/RequestHandler").RequestHandlerDefaultInfo, import("..").MockedRequest<import("..").DefaultRequestBody>, any, import("..").MockedRequest<import("..").DefaultRequestBody>>[]) => import("./glossary").SetupServerApi;

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/getResponse.d.ts

@@ -12,4 +12,4 @@ export interface ResponseResolutionContext {
 /**
  * Returns a mocked response for a given request using following request handlers.
  */
-export declare const getResponse: <Request_1 extends MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, Handler extends RequestHandler<Record<string, any>, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, any, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>>[]>(request: Request_1, handlers: Handler, resolutionContext?: ResponseResolutionContext | undefined) => Promise<ResponseLookupResult>;
+export declare const getResponse: <Request_1 extends MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, Handler extends RequestHandler<import("../handlers/RequestHandler").RequestHandlerDefaultInfo, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, any, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>>[]>(request: Request_1, handlers: Handler, resolutionContext?: ResponseResolutionContext | undefined) => Promise<ResponseLookupResult>;

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/internal/requestHandlerUtils.d.ts

@@ -1,4 +1,4 @@
 import { RequestHandler } from '../../handlers/RequestHandler';
 export declare function use(currentHandlers: RequestHandler[], ...handlers: RequestHandler[]): void;
 export declare function restoreHandlers(handlers: RequestHandler[]): void;
-export declare function resetHandlers(initialHandlers: RequestHandler[], ...nextHandlers: RequestHandler[]): RequestHandler<Record<string, any>, import("../../handlers/RequestHandler").MockedRequest<import("../../handlers/RequestHandler").DefaultRequestBody>, any, import("../../handlers/RequestHandler").MockedRequest<import("../../handlers/RequestHandler").DefaultRequestBody>>[];
+export declare function resetHandlers(initialHandlers: RequestHandler[], ...nextHandlers: RequestHandler[]): RequestHandler<import("../../handlers/RequestHandler").RequestHandlerDefaultInfo, import("../../handlers/RequestHandler").MockedRequest<import("../../handlers/RequestHandler").DefaultRequestBody>, any, import("../../handlers/RequestHandler").MockedRequest<import("../../handlers/RequestHandler").DefaultRequestBody>>[];

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/onUnhandledRequest.d.ts

@@ -1,5 +1,4 @@
 import { MockedRequest, RequestHandler } from '../../handlers/RequestHandler';
-declare type UnhandledRequestCallback = (request: MockedRequest) => void;
+export declare type UnhandledRequestCallback = (request: MockedRequest) => void;
 export declare type UnhandledRequestStrategy = 'bypass' | 'warn' | 'error' | UnhandledRequestCallback;
 export declare function onUnhandledRequest(request: MockedRequest, handlers: RequestHandler[], strategy?: UnhandledRequestStrategy): void;
-export {};

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;