msw 0.21.2 → 0.21.3

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Change Log
+
+This project adheres to [Semantic Versioning](https://semver.org/).
+Every release, along with the migration instructions, is documented on the Github [Releases](https://github.com/mswjs/msw/releases) page.

package/lib/esm/fetch-deps.js

@@ -82,11 +82,11 @@ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof win
 
 function createCommonjsModule(fn, basedir, module) {
 	return module = {
-	  path: basedir,
-	  exports: {},
-	  require: function (path, base) {
-      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    }
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+		}
 	}, fn(module, module.exports), module.exports;
 }
 

package/lib/esm/index.js

@@ -9,18 +9,18 @@ export { m as matchRequestUrl } from './matchRequestUrl-deps.js';
 export { graphql, graphqlContext } from './graphql.js';
 
 /*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
+Copyright (c) Microsoft Corporation.
 
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
 
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -632,6 +632,10 @@ function resetHandlers(initialHandlers, ...nextHandlers) {
 // so it persists between Fash refreshes of the application's code.
 let listeners = [];
 function setupWorker(...requestHandlers) {
+    requestHandlers.forEach((handler) => {
+        if (Array.isArray(handler))
+            throw new Error(`[MSW] Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).`);
+    });
     const context = {
         worker: null,
         registration: null,

package/lib/types/LiveStorage.d.ts

@@ -0,0 +1,17 @@
+export declare class LiveStorage<Value> {
+    name: string;
+    value: Value;
+    channel: BroadcastChannel;
+    constructor(name: string, initialValue: Value);
+    getValue: () => Value;
+    update: (applyUpdate: (prevValue: Value) => Value) => void;
+    private broadcastValue;
+    /**
+     * Flush the value into the presistency layer.
+     */
+    private persist;
+    /**
+     * Hydrate the value from the persistency layer.
+     */
+    private hydrate;
+}

package/lib/types/graphql.d.ts

@@ -27,7 +27,7 @@ export interface GraphQLRequestPayload<VariablesType> {
     query: string;
     variables?: VariablesType;
 }
-interface GraphQLRequestParsedResult<VariablesType> {
+export interface GraphQLRequestParsedResult<VariablesType> {
     operationType: OperationTypeNode;
     operationName: string | undefined;
     variables: VariablesType | undefined;

package/lib/types/index.d.ts

@@ -4,5 +4,5 @@ export { MockedResponse, ResponseTransformer, response } from './response';
 export { context };
 export { MockedRequest, RequestHandler, RequestParams, RequestQuery, ResponseResolver, ResponseResolverReturnType, AsyncResponseResolverReturnType, defaultContext, } from './utils/handlers/requestHandler';
 export { rest, restContext, RESTMethods, ParsedRestRequest } from './rest';
-export { graphql, graphqlContext, GraphQLMockedRequest, GraphQLMockedContext, GraphQLRequestPayload, GraphQLResponseResolver, } from './graphql';
+export { graphql, graphqlContext, GraphQLMockedRequest, GraphQLMockedContext, GraphQLRequestPayload, GraphQLResponseResolver, GraphQLRequestParsedResult, } from './graphql';
 export { matchRequestUrl } from './utils/matching/matchRequestUrl';

package/lib/types/rest.d.ts

@@ -1,4 +1,4 @@
-import { RequestHandler, ResponseResolver, MockedRequest, DefaultRequestBodyType } from './utils/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/matchRequestUrl';
@@ -20,13 +20,13 @@ export declare const restContext: {
     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>, requestInit?: RequestInit) => any;
+    fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
 };
 export interface ParsedRestRequest {
     match: ReturnType<typeof matchRequestUrl>;
 }
 export declare const rest: {
-    head: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+    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>;
@@ -35,8 +35,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -45,9 +45,9 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
-    get: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+        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>;
@@ -56,8 +56,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -66,9 +66,9 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
-    post: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+        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>;
@@ -77,8 +77,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -87,9 +87,9 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
-    put: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+        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>;
@@ -98,8 +98,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -108,9 +108,9 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
-    delete: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+        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>;
@@ -119,8 +119,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -129,9 +129,9 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
-    patch: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+        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>;
@@ -140,8 +140,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -150,9 +150,9 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
-    options: <RequestBodyType = DefaultRequestBodyType, ResponseBodyType = any>(mask: Mask, resolver: ResponseResolver<MockedRequest<RequestBodyType>, {
+        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>;
@@ -161,8 +161,8 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ResponseBodyType>) => RequestHandler<MockedRequest<RequestBodyType>, {
+        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>;
@@ -171,6 +171,6 @@ export declare const rest: {
         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>, requestInit?: RequestInit) => any;
-    }, ParsedRestRequest, MockedRequest<RequestBodyType>, ResponseBodyType>;
+        fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
+    }, ParsedRestRequest, MockedRequest<RequestBodyType, RequestParams>, ResponseBodyType>;
 };

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

@@ -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<import("./handlers/requestHandler").DefaultRequestBodyType>, 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

@@ -6,10 +6,10 @@ 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>, requestInit?: RequestInit) => any;
+    fetch: (input: string | MockedRequest<DefaultRequestBodyType, RequestParams>, requestInit?: RequestInit) => any;
 };
 export declare type DefaultRequestBodyType = Record<string, any> | string | undefined;
-export interface MockedRequest<BodyType = DefaultRequestBodyType> {
+export interface MockedRequest<BodyType = DefaultRequestBodyType, RequestParamsType = RequestParams> {
     url: URL;
     method: Request['method'];
     headers: Headers;
@@ -25,7 +25,7 @@ export interface MockedRequest<BodyType = DefaultRequestBodyType> {
     referrerPolicy: Request['referrerPolicy'];
     body: BodyType;
     bodyUsed: Request['bodyUsed'];
-    params: RequestParams;
+    params: RequestParamsType;
 }
 export declare type RequestQuery = {
     [queryName: string]: any;

package/lib/umd/index.js

@@ -88,11 +88,11 @@
 
   function createCommonjsModule(fn, basedir, module) {
   	return module = {
-  	  path: basedir,
-  	  exports: {},
-  	  require: function (path, base) {
-        return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-      }
+  		path: basedir,
+  		exports: {},
+  		require: function (path, base) {
+  			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+  		}
   	}, fn(module, module.exports), module.exports;
   }
 
@@ -728,18 +728,18 @@
   });
 
   /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation. All rights reserved.
-  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-  this file except in compliance with the License. You may obtain a copy of the
-  License at http://www.apache.org/licenses/LICENSE-2.0
+  Copyright (c) Microsoft Corporation.
 
-  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-  MERCHANTABLITY OR NON-INFRINGEMENT.
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
 
-  See the Apache Version 2.0 License for specific language governing permissions
-  and limitations under the License.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** */
 
   function __awaiter(thisArg, _arguments, P, generator) {
@@ -2744,6 +2744,10 @@ If this message still persists after updating, please report an issue: https://g
   // so it persists between Fash refreshes of the application's code.
   let listeners = [];
   function setupWorker(...requestHandlers) {
+      requestHandlers.forEach((handler) => {
+          if (Array.isArray(handler))
+              throw new Error(`[MSW] Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).`);
+      });
       const context = {
           worker: null,
           registration: null,

package/native/index.js

@@ -6,18 +6,18 @@ var XMLHttpRequest = require('node-request-interceptor/lib/interceptors/XMLHttpR
 var nodeRequestInterceptor = require('node-request-interceptor');
 
 /*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
+Copyright (c) Microsoft Corporation.
 
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
 
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -120,11 +120,11 @@ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof win
 
 function createCommonjsModule(fn, basedir, module) {
 	return module = {
-	  path: basedir,
-	  exports: {},
-	  require: function (path, base) {
-      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    }
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+		}
 	}, fn(module, module.exports), module.exports;
 }
 
@@ -2098,6 +2098,10 @@ function createSetupServer(...interceptors) {
      * Sets up a server-side requests interception with the given mock definition.
      */
     return function setupServer(...requestHandlers) {
+        requestHandlers.forEach((handler) => {
+            if (Array.isArray(handler))
+                throw new Error(`[MSW] Failed to call "setupServer" given an Array of request handlers (setupServer([a, b])), expected to receive each handler individually: setupServer(a, b).`);
+        });
         const interceptor = new nodeRequestInterceptor.RequestInterceptor(interceptors);
         // Error when attempting to run this function in a browser environment.
         if (!isNodeProcess()) {

package/node/context/delay.d.ts

@@ -0,0 +1,11 @@
+import { ResponseTransformer } from '../response';
+export declare const MIN_SERVER_RESPONSE_TIME = 100;
+export declare const MAX_SERVER_RESPONSE_TIME = 400;
+export declare const NODE_SERVER_RESPONSE_TIME = 5;
+/**
+ * Delays the current response for the given duration (in ms)
+ * @example
+ * res(delay()) // realistic server response time
+ * res(delay(1500)) // explicit response delay duration
+ */
+export declare const delay: (durationMs?: number | undefined) => ResponseTransformer;

package/node/context/fetch.d.ts

@@ -0,0 +1,8 @@
+import { MockedRequest } from '../utils/handlers/requestHandler';
+export declare const augmentRequestInit: (requestInit: RequestInit) => RequestInit;
+/**
+ * Wrapper around the native `window.fetch()` function that performs
+ * a request bypassing MSW. Requests performed using
+ * this function will never be mocked.
+ */
+export declare const fetch: (input: string | MockedRequest, requestInit?: RequestInit) => Promise<Response>;

package/node/context/set.d.ts

@@ -0,0 +1,2 @@
+import { ResponseTransformer } from '../response';
+export declare function set<N extends string | Record<string, string | string[]>>(...args: N extends string ? [N, string] : [N]): ResponseTransformer;

package/node/context/status.d.ts

@@ -0,0 +1,2 @@
+import { ResponseTransformer } from '../response';
+export declare const status: (statusCode: number, statusText?: string | undefined) => ResponseTransformer;

package/node/index.js

@@ -8,18 +8,18 @@ var timers = require('timers');
 var nodeRequestInterceptor = require('node-request-interceptor');
 
 /*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
+Copyright (c) Microsoft Corporation.
 
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
 
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -122,11 +122,11 @@ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof win
 
 function createCommonjsModule(fn, basedir, module) {
 	return module = {
-	  path: basedir,
-	  exports: {},
-	  require: function (path, base) {
-      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-    }
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
+		}
 	}, fn(module, module.exports), module.exports;
 }
 
@@ -2100,6 +2100,10 @@ function createSetupServer(...interceptors) {
      * Sets up a server-side requests interception with the given mock definition.
      */
     return function setupServer(...requestHandlers) {
+        requestHandlers.forEach((handler) => {
+            if (Array.isArray(handler))
+                throw new Error(`[MSW] Failed to call "setupServer" given an Array of request handlers (setupServer([a, b])), expected to receive each handler individually: setupServer(a, b).`);
+        });
         const interceptor = new nodeRequestInterceptor.RequestInterceptor(interceptors);
         // Error when attempting to run this function in a browser environment.
         if (!isNodeProcess()) {

package/node/node/createSetupServer.d.ts

@@ -0,0 +1,29 @@
+import { Interceptor } from 'node-request-interceptor';
+import { RequestHandlersList } from '../setupWorker/glossary';
+import { SharedOptions } from '../sharedOptions';
+/**
+ * Creates a `setupServer` API using given request interceptors.
+ * Useful to generate identical API using different patches to request issuing modules.
+ */
+export declare function createSetupServer(...interceptors: Interceptor[]): (...requestHandlers: RequestHandlersList) => {
+    /**
+     * Enables requests interception based on the previously provided mock definition.
+     */
+    listen(options?: SharedOptions | undefined): void;
+    /**
+     * Prepends given request handlers to the list of existing handlers.
+     */
+    use(...handlers: RequestHandlersList): void;
+    /**
+     * Marks all request handlers that respond using `res.once()` as unused.
+     */
+    restoreHandlers(): void;
+    /**
+     * Resets request handlers to the initial list given to the `setupServer` call, or to the explicit next request handlers list, if given.
+     */
+    resetHandlers(...nextHandlers: RequestHandlersList): void;
+    /**
+     * Stops requests interception by restoring all augmented modules.
+     */
+    close(): void;
+};

package/node/node/index.d.ts

@@ -0,0 +1,5 @@
+export { setupServer } from './setupServer'
+
+declare module 'types/context/body.d.ts' {
+  export const body: string
+}

package/node/node/setupServer.d.ts

@@ -0,0 +1,7 @@
+export declare const setupServer: (...requestHandlers: import("../setupWorker/glossary").RequestHandlersList) => {
+    listen(options?: import("../sharedOptions").SharedOptions | undefined): void;
+    use(...handlers: import("../setupWorker/glossary").RequestHandlersList): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: import("../setupWorker/glossary").RequestHandlersList): void;
+    close(): void;
+};

package/node/response.d.ts

@@ -0,0 +1,25 @@
+import { Headers } from 'headers-utils';
+export interface MockedResponse<BodyType = any> {
+    body: BodyType;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    once: boolean;
+    delay?: number;
+}
+export declare type ResponseTransformer<BodyType = any> = (res: MockedResponse<BodyType>) => MockedResponse<BodyType>;
+declare type ResponseFunction<BodyType = any> = (...transformers: ResponseTransformer<BodyType>[]) => MockedResponse<BodyType>;
+export declare type ResponseComposition<BodyType = any> = ResponseFunction<BodyType> & {
+    /**
+     * Respond using a given mocked response to the first captured request.
+     * Does not affect any subsequent captured requests.
+     */
+    once: ResponseFunction<BodyType>;
+    networkError: (message: string) => void;
+};
+export declare const defaultResponse: Omit<MockedResponse, 'headers'>;
+export declare const response: ResponseFunction<any> & {
+    once: ResponseFunction<any>;
+    networkError(message: string): never;
+};
+export {};

package/node/utils/NetworkError.d.ts

@@ -0,0 +1,3 @@
+export declare class NetworkError extends Error {
+    constructor(message: string);
+}

package/node/utils/getResponse.d.ts

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

package/node/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>, requestInit?: RequestInit) => Promise<Response>;
+};
+export declare type DefaultRequestBodyType = Record<string, any> | string | undefined;
+export interface MockedRequest<BodyType = DefaultRequestBodyType> {
+    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: RequestParams;
+}
+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/node/utils/handlers/requestHandlerUtils.d.ts

@@ -0,0 +1,4 @@
+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").RequestHandler<any, any, any, any, any>[];

package/node/utils/internal/compose.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Composes a given list of functions into a new function that
+ * executes from right to left.
+ */
+export declare function compose(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;

package/node/utils/internal/isNodeProcess.d.ts

@@ -0,0 +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/node/utils/internal/jsonParse.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parses a given string 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;

package/node/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/node/utils/request/onUnhandledRequest.d.ts

@@ -0,0 +1,5 @@
+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;
+export {};

package/node/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "0.21.2",
+  "version": "0.21.3",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.",
   "main": "lib/umd/index.js",
   "module": "lib/esm/index.js",
@@ -83,6 +83,7 @@
     "@rollup/plugin-node-resolve": "^9.0.0",
     "@rollup/plugin-replace": "^2.3.3",
     "@types/express": "^4.17.8",
+    "@types/fs-extra": "^9.0.1",
     "@types/jest": "^26.0.13",
     "@types/node": "^14.6.4",
     "@types/node-fetch": "^2.5.7",
@@ -98,6 +99,7 @@
     "eslint-config-prettier": "^6.11.0",
     "eslint-plugin-prettier": "^3.1.4",
     "express": "^4.17.1",
+    "fs-extra": "^9.0.1",
     "html-webpack-plugin": "^4.4.1",
     "husky": "^4.3.0",
     "ignore-loader": "^0.1.2",