msw 0.42.3 → 0.43.0

package/lib/index.js

@@ -424,17 +424,18 @@ async function enableMocking(context, options) {
   });
 }
 
-// src/utils/createBroadcastChannel.ts
-var createBroadcastChannel = (event) => {
+// src/setupWorker/start/utils/createMessageChannel.ts
+function createMessageChannel(event) {
   const port = event.ports[0];
   return {
     send(message) {
-      if (port) {
-        port.postMessage(message);
+      if (!port) {
+        return;
       }
+      port.postMessage(message);
     }
   };
-};
+}
 
 // src/utils/NetworkError.ts
 var NetworkError = class extends Error {
@@ -1355,24 +1356,69 @@ async function handleRequest(request, handlers, options, emitter, handleRequestO
   return transformedResponse;
 }
 
-// src/utils/worker/createRequestListener.ts
+// src/setupWorker/start/utils/streamResponse.ts
+var import_outvariant3 = require("outvariant");
+async function streamResponse(operationChannel, messageChannel, mockedResponse) {
+  const response2 = new Response(mockedResponse.body, mockedResponse);
+  delete mockedResponse.body;
+  messageChannel.send({
+    type: "MOCK_RESPONSE_START",
+    payload: mockedResponse
+  });
+  (0, import_outvariant3.invariant)(response2.body, "Failed to stream mocked response with no body");
+  const reader = response2.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (!done) {
+      operationChannel.postMessage({
+        type: "MOCK_RESPONSE_CHUNK",
+        payload: value
+      });
+      continue;
+    }
+    operationChannel.postMessage({
+      type: "MOCK_RESPONSE_END"
+    });
+    operationChannel.close();
+    reader.releaseLock();
+    break;
+  }
+}
+
+// src/utils/internal/StrictBroadcastChannel.ts
+var ParentClass = typeof BroadcastChannel == "undefined" ? class UnsupportedEnvironment {
+  constructor() {
+    throw new Error("Cannot construct BroadcastChannel in a non-browser environment");
+  }
+} : BroadcastChannel;
+var StrictBroadcastChannel = class extends ParentClass {
+  postMessage(message) {
+    return super.postMessage(message);
+  }
+};
+
+// src/setupWorker/start/createRequestListener.ts
 var createRequestListener = (context, options) => {
   return async (event, message) => {
-    const channel = createBroadcastChannel(event);
+    const messageChannel = createMessageChannel(event);
     try {
       const request = parseWorkerRequest(message.payload);
+      const operationChannel = new StrictBroadcastChannel(`msw-response-stream-${request.id}`);
       await handleRequest(request, context.requestHandlers, options, context.emitter, {
         transformResponse,
         onPassthroughResponse() {
-          return channel.send({
+          return messageChannel.send({
             type: "MOCK_NOT_FOUND"
           });
         },
         onMockedResponse(response2) {
-          channel.send({
-            type: "MOCK_SUCCESS",
-            payload: response2
-          });
+          if (response2.body == null) {
+            return messageChannel.send({
+              type: "MOCK_RESPONSE",
+              payload: response2
+            });
+          }
+          streamResponse(operationChannel, messageChannel, response2);
         },
         onMockedResponseSent(response2, { handler, publicRequest, parsedRequest }) {
           if (options.quiet) {
@@ -1383,7 +1429,7 @@ var createRequestListener = (context, options) => {
       });
     } catch (error2) {
       if (error2 instanceof NetworkError) {
-        return channel.send({
+        return messageChannel.send({
           type: "NETWORK_ERROR",
           payload: {
             name: error2.name,
@@ -1392,7 +1438,7 @@ var createRequestListener = (context, options) => {
         });
       }
       if (error2 instanceof Error) {
-        channel.send({
+        messageChannel.send({
           type: "INTERNAL_ERROR",
           payload: {
             status: 500,
@@ -1421,8 +1467,8 @@ function transformResponse(response2) {
 async function requestIntegrityCheck(context, serviceWorker) {
   context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
   const { payload: actualChecksum } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
-  if (actualChecksum !== "02f4ad4a2797f85668baf196e553d929") {
-    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"02f4ad4a2797f85668baf196e553d929"}).`);
+  if (actualChecksum !== "c9450df6e4dc5e45740c3b0b640727a2") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"c9450df6e4dc5e45740c3b0b640727a2"}).`);
   }
   return serviceWorker;
 }
@@ -1445,7 +1491,7 @@ function deferNetworkRequestsUntil(predicatePromise) {
   };
 }
 
-// src/utils/worker/createResponseListener.ts
+// src/setupWorker/start/createResponseListener.ts
 function createResponseListener(context) {
   return (_, message) => {
     var _a;
@@ -1599,7 +1645,7 @@ function prepareStartHandler(handler, context) {
   };
 }
 
-// src/utils/worker/createFallbackRequestListener.ts
+// src/setupWorker/start/createFallbackRequestListener.ts
 var import_interceptors = require("@mswjs/interceptors");
 var import_fetch3 = require("@mswjs/interceptors/lib/interceptors/fetch");
 var import_XMLHttpRequest = require("@mswjs/interceptors/lib/interceptors/XMLHttpRequest");
@@ -1629,7 +1675,7 @@ function parseIsomorphicRequest(request) {
   return mockedRequest;
 }
 
-// src/utils/worker/createFallbackRequestListener.ts
+// src/setupWorker/start/createFallbackRequestListener.ts
 function createFallbackRequestListener(context, options) {
   const interceptor = new import_interceptors.BatchInterceptor({
     name: "fallback",