msw 0.39.1 → 0.40.1

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/graphql-deps.js

@@ -1,6 +1,6 @@
-import { j as jsonParse, b as set, s as status, e as delay, f as fetch, d as cookie } from './fetch-deps.js';
 import { d as data, e as extensions, a as errors } from './errors-deps.js';
-import { g as getPublicUrlFromRequest, d as devUtils, n as __rest, R as RequestHandler, m as matchRequestUrl, i as prepareRequest, j as prepareResponse, k as getStatusCodeColor, l as getTimestamp } from './RequestHandler-deps.js';
+import { j as jsonParse, d as cookie } from './fetch-deps.js';
+import { g as getPublicUrlFromRequest, d as devUtils, o as __rest, e as defaultContext, R as RequestHandler, m as matchRequestUrl, j as prepareRequest, k as prepareResponse, l as getStatusCodeColor, n as getTimestamp } from './matchRequestUrl-deps.js';
 
 function devAssert(condition, message) {
   const booleanCondition = Boolean(condition);
@@ -3413,16 +3413,10 @@ function tryCatch(fn, onException) {
     }
 }
 
-const graphqlContext = {
-    set,
-    status,
-    delay,
-    fetch,
-    data,
+const graphqlContext = Object.assign(Object.assign({}, defaultContext), { data,
     extensions,
     errors,
-    cookie,
-};
+    cookie });
 function isDocumentNode(value) {
     if (value == null) {
         return false;

package/lib/esm/graphql.js

@@ -1,5 +1,5 @@
 export { g as graphql } from './graphql-deps.js';
-import './fetch-deps.js';
 import './errors-deps.js';
-import './RequestHandler-deps.js';
+import './fetch-deps.js';
+import './matchRequestUrl-deps.js';
 import '@mswjs/interceptors/lib/utils/getCleanUrl';

package/lib/esm/index.js

@@ -1,7 +1,7 @@
 export { i as context } from './index-deps.js';
 import { c as commonjsGlobal, p as parse_1, l as lib$2, a as lib$3, j as jsonParse } from './fetch-deps.js';
-import { _ as __awaiter, d as devUtils, p as parseBody, g as getPublicUrlFromRequest, N as NetworkError } from './RequestHandler-deps.js';
-export { R as RequestHandler, f as cleanUrl, e as compose, c as createResponseComposition, b as defaultContext, a as defaultResponse, m as matchRequestUrl, r as response } from './RequestHandler-deps.js';
+import { _ as __awaiter, d as devUtils, p as passthrough, a as parseBody, g as getPublicUrlFromRequest, N as NetworkError } from './matchRequestUrl-deps.js';
+export { R as RequestHandler, h as cleanUrl, f as compose, c as createResponseComposition, e as defaultContext, b as defaultResponse, m as matchRequestUrl, r as response } from './matchRequestUrl-deps.js';
 import { store } from '@mswjs/cookies';
 import { i as isStringEqual, R as RestHandler } from './rest-deps.js';
 export { a as RESTMethods, R as RestHandler, r as rest, b as restContext } from './rest-deps.js';
@@ -683,6 +683,12 @@ function printStartMessage(args = {}) {
     console.groupCollapsed(`%c${devUtils.formatMessage(message)}`, 'color:orangered;font-weight:bold;');
     console.log('%cDocumentation: %chttps://mswjs.io/docs', 'font-weight:bold', 'font-weight:normal');
     console.log('Found an issue? https://github.com/mswjs/msw/issues');
+    if (args.workerUrl) {
+        console.log('Worker script URL:', args.workerUrl);
+    }
+    if (args.workerScope) {
+        console.log('Worker scope:', args.workerScope);
+    }
     console.groupEnd();
 }
 
@@ -690,10 +696,22 @@ function printStartMessage(args = {}) {
  * Signals the worker to enable the interception of requests.
  */
 function enableMocking(context, options) {
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         context.workerChannel.send('MOCK_ACTIVATE');
-        return context.events.once('MOCKING_ENABLED').then(() => {
-            printStartMessage({ quiet: options.quiet });
+        yield context.events.once('MOCKING_ENABLED');
+        // Warn the developer on multiple "worker.start()" calls.
+        // While this will not affect the worker in any way,
+        // it likely indicates an issue with the developer's code.
+        if (context.isMockingEnabled) {
+            devUtils.warn(`Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.`);
+            return;
+        }
+        context.isMockingEnabled = true;
+        printStartMessage({
+            quiet: options.quiet,
+            workerScope: (_a = context.registration) === null || _a === void 0 ? void 0 : _a.scope,
+            workerUrl: (_b = context.worker) === null || _b === void 0 ? void 0 : _b.scriptURL,
         });
     });
 }
@@ -745,13 +763,36 @@ function getRequestCookies(request) {
     }
 }
 
+/**
+ * Sets relevant cookies on the request.
+ * Request cookies are taken from the following sources:
+ * - Immediate (own) request cookies (those in the "Cookie" request header);
+ * - From the `document.cookie` based on the request's `credentials` value;
+ * - From the internal cookie store that persists/hydrates cookies in Node.js
+ */
 function setRequestCookies(request) {
     var _a;
+    // Set mocked request cookies from the `cookie` header of the original request.
+    // No need to take `credentials` into account, because in Node.js requests are intercepted
+    // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
+    // Unlike browser, where interception is on the worker level, _before_ the request happens.
+    const requestCookiesString = request.headers.get('cookie');
     store.hydrate();
-    request.cookies = Object.assign(Object.assign({}, getRequestCookies(request)), Array.from((_a = store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => Object.assign(cookies, { [name]: value }), {}));
-    request.headers.set('cookie', Object.entries(request.cookies)
-        .map(([name, value]) => `${name}=${value}`)
-        .join('; '));
+    const cookiesFromStore = Array.from((_a = store.get(Object.assign(Object.assign({}, request), { url: request.url.toString() }))) === null || _a === void 0 ? void 0 : _a.entries()).reduce((cookies, [name, { value }]) => {
+        return Object.assign(cookies, { [name.trim()]: value });
+    }, {});
+    const cookiesFromDocument = getRequestCookies(request);
+    const forwardedCookies = Object.assign(Object.assign({}, cookiesFromDocument), cookiesFromStore);
+    // Ensure the persisted (document) cookies are propagated to the request.
+    // Propagated the cookies persisted in the Cookuie Store to the request headers.
+    // This forwards relevant request cookies based on the request's credentials.
+    for (const [name, value] of Object.entries(forwardedCookies)) {
+        request.headers.append('cookie', `${name}=${value}`);
+    }
+    const ownCookies = requestCookiesString
+        ? parse_1(requestCookiesString)
+        : {};
+    request.cookies = Object.assign(Object.assign(Object.assign({}, request.cookies), forwardedCookies), ownCookies);
 }
 
 /**
@@ -789,6 +830,7 @@ function parseWorkerRequest(rawRequest) {
         body: pruneGetRequestBody(rawRequest),
         bodyUsed: rawRequest.bodyUsed,
         headers: new lib$2.Headers(rawRequest.headers),
+        passthrough,
     };
     // Set document cookies on the request.
     setRequestCookies(request);
@@ -1095,17 +1137,24 @@ function readResponseCookies(request, response) {
 }
 
 function handleRequest(request, handlers, options, emitter, handleRequestOptions) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         emitter.emit('request:start', request);
         // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
         if (request.headers.get('x-msw-bypass') === 'true') {
             emitter.emit('request:end', request);
-            (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
+            (_a = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _a === void 0 ? void 0 : _a.call(handleRequestOptions, request);
             return;
         }
         // Resolve a mocked response from the list of request handlers.
-        const lookupResult = yield getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
+        const [lookupError, lookupResult] = yield until(() => {
+            return getResponse(request, handlers, handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.resolutionContext);
+        });
+        if (lookupError) {
+            // Allow developers to react to unhandled exceptions in request handlers.
+            emitter.emit('unhandledException', lookupError, request);
+            throw lookupError;
+        }
         const { handler, response } = lookupResult;
         // When there's no handler for the request, consider it unhandled.
         // Allow the developer to react to such cases.
@@ -1113,7 +1162,7 @@ function handleRequest(request, handlers, options, emitter, handleRequestOptions
             onUnhandledRequest(request, handlers, options.onUnhandledRequest);
             emitter.emit('request:unhandled', request);
             emitter.emit('request:end', request);
-            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
+            (_b = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _b === void 0 ? void 0 : _b.call(handleRequestOptions, request);
             return;
         }
         // When the handled request returned no mocked response, warn the developer,
@@ -1126,7 +1175,14 @@ Expected response resolver to return a mocked response Object, but got %s. The o
     %s\
 `, response, handler.info.header, handler.info.callFrame);
             emitter.emit('request:end', request);
-            (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onBypassResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
+            (_c = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _c === void 0 ? void 0 : _c.call(handleRequestOptions, request);
+            return;
+        }
+        // When the developer explicitly returned "req.passthrough()" do not warn them.
+        // Perform the request as-is.
+        if (response.passthrough) {
+            emitter.emit('request:end', request);
+            (_d = handleRequestOptions === null || handleRequestOptions === void 0 ? void 0 : handleRequestOptions.onPassthroughResponse) === null || _d === void 0 ? void 0 : _d.call(handleRequestOptions, request);
             return;
         }
         // Store all the received response cookies in the virtual cookie store.
@@ -1157,7 +1213,7 @@ const createRequestListener = (context, options) => {
                 transformResponse(response) {
                     return Object.assign(Object.assign({}, response), { headers: response.headers.all() });
                 },
-                onBypassResponse() {
+                onPassthroughResponse() {
                     return channel.send({
                         type: 'MOCK_NOT_FOUND',
                     });
@@ -1379,12 +1435,19 @@ function printStopMessage(args = {}) {
 const createStop = (context) => {
     return function stop() {
         var _a;
+        // Warn developers calling "worker.stop()" more times than necessary.
+        // This likely indicates a mistake in their code.
+        if (!context.isMockingEnabled) {
+            devUtils.warn('Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.');
+            return;
+        }
         /**
          * Signal the Service Worker to disable mocking for this client.
          * Use this an an explicit way to stop the mocking, while preserving
          * the worker-client relation. Does not affect the worker's lifecycle.
          */
         context.workerChannel.send('MOCK_DEACTIVATE');
+        context.isMockingEnabled = false;
         window.clearInterval(context.keepAliveInterval);
         printStopMessage({ quiet: (_a = context.startOptions) === null || _a === void 0 ? void 0 : _a.quiet });
     };
@@ -1437,6 +1500,7 @@ function parseIsomorphicRequest(request) {
         url: request.url,
         method: request.method,
         body: parseBody(request.body, request.headers),
+        credentials: request.credentials || 'same-origin',
         headers: request.headers,
         cookies: {},
         redirect: 'manual',
@@ -1448,21 +1512,10 @@ function parseIsomorphicRequest(request) {
         integrity: '',
         destination: 'document',
         bodyUsed: false,
-        credentials: 'same-origin',
+        passthrough,
     };
-    // Set mocked request cookies from the `cookie` header of the original request.
-    // No need to take `credentials` into account, because in Node.js requests are intercepted
-    // _after_ they happen. Request issuer should have already taken care of sending relevant cookies.
-    // Unlike browser, where interception is on the worker level, _before_ the request happens.
-    const requestCookiesString = request.headers.get('cookie');
     // Attach all the cookies from the virtual cookie store.
     setRequestCookies(mockedRequest);
-    const requestCookies = requestCookiesString
-        ? parse_1(requestCookiesString)
-        : {};
-    // Merge both direct request cookies and the cookies inherited
-    // from other same-origin requests in the cookie store.
-    mockedRequest.cookies = Object.assign(Object.assign({}, mockedRequest.cookies), requestCookies);
     return mockedRequest;
 }
 
@@ -1554,6 +1607,9 @@ function setupWorker(...requestHandlers) {
     const publicEmitter = new lib$1.StrictEventEmitter();
     pipeEvents(emitter, publicEmitter);
     const context = {
+        // Mocking is not considered enabled until the worker
+        // signals back the successful activation event.
+        isMockingEnabled: false,
         startOptions: undefined,
         worker: null,
         registration: null,

package/lib/esm/{RequestHandler-deps.js → matchRequestUrl-deps.js}

@@ -1,4 +1,4 @@
-import { c as commonjsGlobal, l as lib$1, j as jsonParse, s as status, b as set, e as delay, f as fetch } from './fetch-deps.js';
+import { c as commonjsGlobal, l as lib$1, s as status, b as set, e as delay, f as fetch, j as jsonParse } from './fetch-deps.js';
 import { getCleanUrl } from '@mswjs/interceptors/lib/utils/getCleanUrl';
 
 /*! *****************************************************************************
@@ -205,6 +205,196 @@ class NetworkError extends Error {
     }
 }
 
+/**
+ * Composes a given list of functions into a new function that
+ * executes from right to left.
+ */
+function compose(...fns) {
+    return (...args) => {
+        return fns.reduceRight((leftFn, rightFn) => {
+            return leftFn instanceof Promise
+                ? Promise.resolve(leftFn).then(rightFn)
+                : rightFn(leftFn);
+        }, args[0]);
+    };
+}
+
+const defaultResponse = {
+    status: 200,
+    statusText: 'OK',
+    body: null,
+    delay: 0,
+    once: false,
+    passthrough: false,
+};
+const defaultResponseTransformers = [];
+function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
+    return (...transformers) => __awaiter(this, void 0, void 0, function* () {
+        const initialResponse = Object.assign({}, defaultResponse, {
+            headers: new lib$1.Headers({
+                'x-powered-by': 'msw',
+            }),
+        }, responseOverrides);
+        const resolvedTransformers = [
+            ...defaultTransformers,
+            ...transformers,
+        ].filter(Boolean);
+        const resolvedResponse = resolvedTransformers.length > 0
+            ? compose(...resolvedTransformers)(initialResponse)
+            : initialResponse;
+        return resolvedResponse;
+    });
+}
+const response = Object.assign(createResponseComposition(), {
+    once: createResponseComposition({ once: true }),
+    networkError(message) {
+        throw new NetworkError(message);
+    },
+});
+
+const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
+/**
+ * Return the stack trace frame of a function's invocation.
+ */
+function getCallFrame(error) {
+    // In <IE11, new Error may return an undefined stack
+    const stack = error.stack;
+    if (!stack) {
+        return;
+    }
+    const frames = stack.split('\n').slice(1);
+    // Get the first frame that doesn't reference the library's internal trace.
+    // Assume that frame is the invocation frame.
+    const declarationFrame = frames.find((frame) => {
+        return !BUILD_FRAME.test(frame);
+    });
+    if (!declarationFrame) {
+        return;
+    }
+    // Extract file reference from the stack frame.
+    const declarationPath = declarationFrame
+        .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
+        .replace(/^@/, '');
+    return declarationPath;
+}
+
+/**
+ * Determines if the given function is an iterator.
+ */
+function isIterable(fn) {
+    if (!fn) {
+        return false;
+    }
+    return typeof fn[Symbol.iterator] == 'function';
+}
+
+const defaultContext = {
+    status,
+    set,
+    delay,
+    fetch,
+};
+class RequestHandler {
+    constructor(options) {
+        this.shouldSkip = false;
+        this.ctx = options.ctx || defaultContext;
+        this.resolver = options.resolver;
+        const callFrame = getCallFrame(new Error());
+        this.info = Object.assign(Object.assign({}, options.info), { callFrame });
+    }
+    /**
+     * Parse the captured request to extract additional information from it.
+     * Parsed result is then exposed to other methods of this request handler.
+     */
+    parse(_request, _resolutionContext) {
+        return null;
+    }
+    /**
+     * Test if this handler matches the given request.
+     */
+    test(request, resolutionContext) {
+        return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
+    }
+    /**
+     * Derive the publicly exposed request (`req`) instance of the response resolver
+     * from the captured request and its parsed result.
+     */
+    getPublicRequest(request, _parsedResult) {
+        return request;
+    }
+    markAsSkipped(shouldSkip = true) {
+        this.shouldSkip = shouldSkip;
+    }
+    /**
+     * Execute this request handler and produce a mocked response
+     * using the given resolver function.
+     */
+    run(request, resolutionContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shouldSkip) {
+                return null;
+            }
+            const parsedResult = this.parse(request, resolutionContext);
+            const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
+            if (!shouldIntercept) {
+                return null;
+            }
+            const publicRequest = this.getPublicRequest(request, parsedResult);
+            // Create a response extraction wrapper around the resolver
+            // since it can be both an async function and a generator.
+            const executeResolver = this.wrapResolver(this.resolver);
+            const mockedResponse = yield executeResolver(publicRequest, response, this.ctx);
+            return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
+        });
+    }
+    wrapResolver(resolver) {
+        return (req, res, ctx) => __awaiter(this, void 0, void 0, function* () {
+            const result = this.resolverGenerator || (yield resolver(req, res, ctx));
+            if (isIterable(result)) {
+                const { value, done } = result[Symbol.iterator]().next();
+                const nextResponse = yield value;
+                // If the generator is done and there is no next value,
+                // return the previous generator's value.
+                if (!nextResponse && done) {
+                    return this.resolverGeneratorResult;
+                }
+                if (!this.resolverGenerator) {
+                    this.resolverGenerator = result;
+                }
+                this.resolverGeneratorResult = nextResponse;
+                return nextResponse;
+            }
+            return result;
+        });
+    }
+    createExecutionResult(parsedResult, request, response) {
+        return {
+            handler: this,
+            parsedResult: parsedResult || null,
+            request,
+            response: response || null,
+        };
+    }
+}
+/**
+ * Bypass this intercepted request.
+ * This will make a call to the actual endpoint requested.
+ */
+function passthrough() {
+    // Constructing a dummy "101 Continue" mocked response
+    // to keep the return type of the resolver consistent.
+    return {
+        status: 101,
+        statusText: 'Continue',
+        headers: new lib$1.Headers(),
+        body: null,
+        // Setting "passthrough" to true will signal the response pipeline
+        // to perform this intercepted request as-is.
+        passthrough: true,
+        once: false,
+    };
+}
+
 function parseContentHeaders(headersString) {
     var _a, _b;
     const headers = lib$1.stringToHeaders(headersString);
@@ -799,175 +989,4 @@ function matchRequestUrl(url, path, baseUrl) {
     };
 }
 
-/**
- * Composes a given list of functions into a new function that
- * executes from right to left.
- */
-function compose(...fns) {
-    return (...args) => {
-        return fns.reduceRight((leftFn, rightFn) => {
-            return leftFn instanceof Promise
-                ? Promise.resolve(leftFn).then(rightFn)
-                : rightFn(leftFn);
-        }, args[0]);
-    };
-}
-
-const defaultResponse = {
-    status: 200,
-    statusText: 'OK',
-    body: null,
-    delay: 0,
-    once: false,
-};
-const defaultResponseTransformers = [];
-function createResponseComposition(responseOverrides, defaultTransformers = defaultResponseTransformers) {
-    return (...transformers) => __awaiter(this, void 0, void 0, function* () {
-        const initialResponse = Object.assign({}, defaultResponse, {
-            headers: new lib$1.Headers({
-                'x-powered-by': 'msw',
-            }),
-        }, responseOverrides);
-        const resolvedTransformers = [
-            ...defaultTransformers,
-            ...transformers,
-        ].filter(Boolean);
-        const resolvedResponse = resolvedTransformers.length > 0
-            ? compose(...resolvedTransformers)(initialResponse)
-            : initialResponse;
-        return resolvedResponse;
-    });
-}
-const response = Object.assign(createResponseComposition(), {
-    once: createResponseComposition({ once: true }),
-    networkError(message) {
-        throw new NetworkError(message);
-    },
-});
-
-const BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
-/**
- * Return the stack trace frame of a function's invocation.
- */
-function getCallFrame(error) {
-    // In <IE11, new Error may return an undefined stack
-    const stack = error.stack;
-    if (!stack) {
-        return;
-    }
-    const frames = stack.split('\n').slice(1);
-    // Get the first frame that doesn't reference the library's internal trace.
-    // Assume that frame is the invocation frame.
-    const declarationFrame = frames.find((frame) => {
-        return !BUILD_FRAME.test(frame);
-    });
-    if (!declarationFrame) {
-        return;
-    }
-    // Extract file reference from the stack frame.
-    const declarationPath = declarationFrame
-        .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
-        .replace(/^@/, '');
-    return declarationPath;
-}
-
-/**
- * Determines if the given function is an iterator.
- */
-function isIterable(fn) {
-    if (!fn) {
-        return false;
-    }
-    return typeof fn[Symbol.iterator] == 'function';
-}
-
-const defaultContext = {
-    status,
-    set,
-    delay,
-    fetch,
-};
-class RequestHandler {
-    constructor(options) {
-        this.shouldSkip = false;
-        this.ctx = options.ctx || defaultContext;
-        this.resolver = options.resolver;
-        const callFrame = getCallFrame(new Error());
-        this.info = Object.assign(Object.assign({}, options.info), { callFrame });
-    }
-    /**
-     * Parse the captured request to extract additional information from it.
-     * Parsed result is then exposed to other methods of this request handler.
-     */
-    parse(_request, _resolutionContext) {
-        return null;
-    }
-    /**
-     * Test if this handler matches the given request.
-     */
-    test(request, resolutionContext) {
-        return this.predicate(request, this.parse(request, resolutionContext), resolutionContext);
-    }
-    /**
-     * Derive the publicly exposed request (`req`) instance of the response resolver
-     * from the captured request and its parsed result.
-     */
-    getPublicRequest(request, _parsedResult) {
-        return request;
-    }
-    markAsSkipped(shouldSkip = true) {
-        this.shouldSkip = shouldSkip;
-    }
-    /**
-     * Execute this request handler and produce a mocked response
-     * using the given resolver function.
-     */
-    run(request, resolutionContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shouldSkip) {
-                return null;
-            }
-            const parsedResult = this.parse(request, resolutionContext);
-            const shouldIntercept = this.predicate(request, parsedResult, resolutionContext);
-            if (!shouldIntercept) {
-                return null;
-            }
-            const publicRequest = this.getPublicRequest(request, parsedResult);
-            // Create a response extraction wrapper around the resolver
-            // since it can be both an async function and a generator.
-            const executeResolver = this.wrapResolver(this.resolver);
-            const mockedResponse = yield executeResolver(publicRequest, response, this.ctx);
-            return this.createExecutionResult(parsedResult, publicRequest, mockedResponse);
-        });
-    }
-    wrapResolver(resolver) {
-        return (req, res, ctx) => __awaiter(this, void 0, void 0, function* () {
-            const result = this.resolverGenerator || (yield resolver(req, res, ctx));
-            if (isIterable(result)) {
-                const { value, done } = result[Symbol.iterator]().next();
-                const nextResponse = yield value;
-                // If the generator is done and there is no next value,
-                // return the previous generator's value.
-                if (!nextResponse && done) {
-                    return this.resolverGeneratorResult;
-                }
-                if (!this.resolverGenerator) {
-                    this.resolverGenerator = result;
-                }
-                this.resolverGeneratorResult = nextResponse;
-                return nextResponse;
-            }
-            return result;
-        });
-    }
-    createExecutionResult(parsedResult, request, response) {
-        return {
-            handler: this,
-            parsedResult: parsedResult || null,
-            request,
-            response: response || null,
-        };
-    }
-}
-
-export { NetworkError as N, RequestHandler as R, __awaiter as _, defaultResponse as a, defaultContext as b, createResponseComposition as c, devUtils as d, compose as e, cleanUrl as f, getPublicUrlFromRequest as g, getSearchParams as h, prepareRequest as i, prepareResponse as j, getStatusCodeColor as k, getTimestamp as l, matchRequestUrl as m, __rest as n, parseBody as p, response as r };
+export { NetworkError as N, RequestHandler as R, __awaiter as _, parseBody as a, defaultResponse as b, createResponseComposition as c, devUtils as d, defaultContext as e, compose as f, getPublicUrlFromRequest as g, cleanUrl as h, getSearchParams as i, prepareRequest as j, prepareResponse as k, getStatusCodeColor as l, matchRequestUrl as m, getTimestamp as n, __rest as o, passthrough as p, response as r };

package/lib/esm/mockServiceWorker.js

@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 /**
- * Mock Service Worker (0.39.1).
+ * Mock Service Worker (0.40.1).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.

package/lib/esm/rest-deps.js

@@ -1,5 +1,5 @@
-import { R as RequestHandler, f as cleanUrl, h as getSearchParams, d as devUtils, m as matchRequestUrl, g as getPublicUrlFromRequest, i as prepareRequest, j as prepareResponse, k as getStatusCodeColor, l as getTimestamp } from './RequestHandler-deps.js';
-import { b as set, s as status, d as cookie, g as json, e as delay, f as fetch } from './fetch-deps.js';
+import { e as defaultContext, R as RequestHandler, h as cleanUrl, i as getSearchParams, d as devUtils, m as matchRequestUrl, g as getPublicUrlFromRequest, j as prepareRequest, k as prepareResponse, l as getStatusCodeColor, n as getTimestamp } from './matchRequestUrl-deps.js';
+import { d as cookie, g as json } from './fetch-deps.js';
 import { b as body, t as text, x as xml } from './xml-deps.js';
 
 /**
@@ -19,17 +19,11 @@ var RESTMethods;
     RESTMethods["OPTIONS"] = "OPTIONS";
     RESTMethods["DELETE"] = "DELETE";
 })(RESTMethods || (RESTMethods = {}));
-const restContext = {
-    set,
-    status,
-    cookie,
+const restContext = Object.assign(Object.assign({}, defaultContext), { cookie,
     body,
     text,
     json,
-    xml,
-    delay,
-    fetch,
-};
+    xml });
 /**
  * Request handler for REST API requests.
  * Provides request matching based on method and URL.