@mswjs/interceptors 0.25.1 → 0.25.3

package/lib/node/{chunk-RGYCLCLK.mjs → chunk-GM3YBSM3.mjs}

@@ -1,132 +1,6 @@
 // src/Interceptor.ts
-import { Logger as Logger2 } from "@open-draft/logger";
-
-// src/utils/AsyncEventEmitter.ts
 import { Logger } from "@open-draft/logger";
 import { Emitter } from "strict-event-emitter";
-
-// src/utils/nextTick.ts
-function nextTick(callback) {
-  setTimeout(callback, 0);
-}
-
-// src/utils/AsyncEventEmitter.ts
-var AsyncEventEmitter = class extends Emitter {
-  constructor() {
-    super();
-    this.logger = new Logger("async-event-emitter");
-    this.queue = /* @__PURE__ */ new Map();
-    this.readyState = "ACTIVE" /* ACTIVE */;
-  }
-  on(eventName, listener) {
-    const logger = this.logger.extend("on");
-    logger.info('adding "%s" listener...', eventName);
-    if (this.readyState === "DEACTIVATED" /* DEACTIVATED */) {
-      logger.info("the emitter is destroyed, skipping!");
-      return this;
-    }
-    return super.on(eventName, async (...args) => {
-      const queue = this.openListenerQueue(eventName);
-      logger.info('awaiting the "%s" listener...', eventName);
-      queue.push({
-        args,
-        done: new Promise(async (resolve, reject) => {
-          try {
-            await listener(...args);
-            resolve();
-            logger.info('"%s" listener has resolved!', eventName);
-          } catch (error) {
-            logger.info('"%s" listener has rejected!', error);
-            reject(error);
-          }
-        })
-      });
-    });
-  }
-  emit(eventName, ...data) {
-    const logger = this.logger.extend("emit");
-    logger.info('emitting "%s" event...', eventName);
-    if (this.readyState === "DEACTIVATED" /* DEACTIVATED */) {
-      logger.info("the emitter is destroyed, skipping!");
-      return false;
-    }
-    if (this.isInternalEventName(eventName)) {
-      return super.emit(eventName, ...data);
-    }
-    this.openListenerQueue(eventName);
-    logger.info('appending a one-time cleanup "%s" listener...', eventName);
-    this.once(eventName, () => {
-      nextTick(() => {
-        this.queue.delete(eventName);
-        logger.info('cleaned up "%s" listeners queue!', eventName);
-      });
-    });
-    return super.emit(eventName, ...data);
-  }
-  /**
-   * Returns a promise that resolves when all the listeners for the given event
-   * has been called. Awaits asynchronous listeners.
-   * If the event has no listeners, resolves immediately.
-   */
-  async untilIdle(eventName, filter = () => true) {
-    const listenersQueue = this.queue.get(eventName) || [];
-    await Promise.all(
-      listenersQueue.filter(filter).map(({ done }) => done)
-    ).finally(() => {
-      this.queue.delete(eventName);
-    });
-  }
-  openListenerQueue(eventName) {
-    const logger = this.logger.extend("openListenerQueue");
-    logger.info('opening "%s" listeners queue...', eventName);
-    const queue = this.queue.get(eventName);
-    if (!queue) {
-      logger.info("no queue found, creating one...");
-      this.queue.set(eventName, []);
-      return [];
-    }
-    logger.info("returning an exising queue:", queue);
-    return queue;
-  }
-  removeAllListeners(eventName) {
-    const logger = this.logger.extend("removeAllListeners");
-    logger.info("event:", eventName);
-    if (eventName) {
-      this.queue.delete(eventName);
-      logger.info(
-        'cleared the "%s" listeners queue!',
-        eventName,
-        this.queue.get(eventName)
-      );
-    } else {
-      this.queue.clear();
-      logger.info("cleared the listeners queue!", this.queue);
-    }
-    return super.removeAllListeners(eventName);
-  }
-  activate() {
-    const logger = this.logger.extend("activate");
-    this.readyState = "ACTIVE" /* ACTIVE */;
-    logger.info("set state to:", this.readyState);
-  }
-  /**
-   * Deactivate this event emitter.
-   * Deactivated emitter can no longer emit and listen to events
-   * and needs to be activated again in order to do so.
-   */
-  deactivate() {
-    const logger = this.logger.extend("deactivate");
-    logger.info("removing all listeners...");
-    this.removeAllListeners();
-    this.readyState = "DEACTIVATED" /* DEACTIVATED */;
-    logger.info("set state to:", this.readyState);
-  }
-  isInternalEventName(eventName) {
-    return eventName === "newListener" || eventName === "removeListener";
-  }
-};
-
-// src/Interceptor.ts
 function getGlobalSymbol(symbol) {
   return (
     // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
@@ -151,9 +25,9 @@ var Interceptor = class {
   constructor(symbol) {
     this.symbol = symbol;
     this.readyState = "INACTIVE" /* INACTIVE */;
-    this.emitter = new AsyncEventEmitter();
+    this.emitter = new Emitter();
     this.subscriptions = [];
-    this.logger = new Logger2(symbol.description);
+    this.logger = new Logger(symbol.description);
     this.emitter.setMaxListeners(0);
     this.logger.info("constructing the interceptor...");
   }
@@ -181,8 +55,6 @@ var Interceptor = class {
       return;
     }
     this.readyState = "APPLYING" /* APPLYING */;
-    this.emitter.activate();
-    logger.info("activated the emiter!", this.emitter.readyState);
     const runningInstance = this.getInstance();
     if (runningInstance) {
       logger.info("found a running instance, reusing...");
@@ -193,6 +65,7 @@ var Interceptor = class {
           runningInstance.emitter.removeListener(event, listener);
           logger.info('removed proxied "%s" listener!', event);
         });
+        return this;
       };
       this.readyState = "APPLIED" /* APPLIED */;
       return;
@@ -212,14 +85,27 @@ var Interceptor = class {
   /**
    * Listen to the interceptor's public events.
    */
-  on(eventName, listener) {
+  on(event, listener) {
     const logger = this.logger.extend("on");
     if (this.readyState === "DISPOSING" /* DISPOSING */ || this.readyState === "DISPOSED" /* DISPOSED */) {
       logger.info("cannot listen to events, already disposed!");
-      return;
+      return this;
     }
-    logger.info('adding "%s" event listener:', eventName, listener.name);
-    this.emitter.on(eventName, listener);
+    logger.info('adding "%s" event listener:', event, listener.name);
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  removeAllListeners(event) {
+    this.emitter.removeAllListeners(event);
+    return this;
   }
   /**
    * Disposes of any side-effects this interceptor has introduced.
@@ -246,7 +132,7 @@ var Interceptor = class {
       this.subscriptions = [];
       logger.info("disposed of all subscriptions!", this.subscriptions.length);
     }
-    this.emitter.deactivate();
+    this.emitter.removeAllListeners();
     logger.info("destroyed the listener!");
     this.readyState = "DISPOSED" /* DISPOSED */;
   }

package/lib/node/{chunk-E6YC337Q.js → chunk-JCWVLTP7.js}

@@ -5,14 +5,18 @@
 var _chunk3LFH2WCFjs = require('./chunk-3LFH2WCF.js');
 
 
+var _chunkOGN3ZR35js = require('./chunk-OGN3ZR35.js');
+
+
 var _chunkVQ4DZOBBjs = require('./chunk-VQ4DZOBB.js');
 
 
 
-var _chunkZJOF5MEZjs = require('./chunk-ZJOF5MEZ.js');
 
+var _chunk5PTPJLB7js = require('./chunk-5PTPJLB7.js');
 
-var _chunkXYZRP5S2js = require('./chunk-XYZRP5S2.js');
+
+var _chunk3XFLRXRYjs = require('./chunk-3XFLRXRY.js');
 
 // src/interceptors/XMLHttpRequest/index.ts
 var _outvariant = require('outvariant');
@@ -204,9 +208,10 @@ function parseJson(data) {
 }
 
 // src/interceptors/XMLHttpRequest/utils/createResponse.ts
-var statusCodesWithoutBody = [204, 205, 304];
 function createResponse(request, body) {
-  const responseBodyOrNull = statusCodesWithoutBody.includes(request.status) ? null : body;
+  const responseBodyOrNull = _chunkOGN3ZR35js.responseStatusCodesWithoutBody.includes(
+    request.status
+  ) ? null : body;
   return new Response(responseBodyOrNull, {
     status: request.status,
     statusText: request.statusText,
@@ -239,7 +244,7 @@ var XMLHttpRequestController = class {
     this.method = "GET";
     this.url = null;
     this.events = /* @__PURE__ */ new Map();
-    this.requestId = _chunkZJOF5MEZjs.uuidv4.call(void 0, );
+    this.requestId = _chunk5PTPJLB7js.uuidv4.call(void 0, );
     this.requestHeaders = new Headers();
     this.responseBuffer = new Uint8Array();
     this.request = createProxy(initialRequest, {
@@ -654,30 +659,32 @@ function createXMLHttpRequestProxy({
           prototypeDescriptors[propertyName]
         );
       }
-      const requestController = new XMLHttpRequestController(
+      const xhrRequestController = new XMLHttpRequestController(
         originalRequest,
         logger
       );
-      requestController.onRequest = async function({ request, requestId }) {
-        const interactiveRequest = _chunkZJOF5MEZjs.toInteractiveRequest.call(void 0, request);
-        this.logger.info(
-          'emitting the "request" event for %s listener(s)...',
-          emitter.listenerCount("request")
-        );
-        emitter.emit("request", {
-          request: interactiveRequest,
-          requestId
-        });
+      xhrRequestController.onRequest = async function({ request, requestId }) {
+        const { interactiveRequest, requestController } = _chunk5PTPJLB7js.toInteractiveRequest.call(void 0, request);
         this.logger.info("awaiting mocked response...");
+        emitter.once("request", ({ requestId: pendingRequestId }) => {
+          if (pendingRequestId !== requestId) {
+            return;
+          }
+          if (requestController.responsePromise.state === "pending") {
+            requestController.respondWith(void 0);
+          }
+        });
         const resolverResult = await _until.until.call(void 0, async () => {
-          await emitter.untilIdle(
-            "request",
-            ({ args: [{ requestId: pendingRequestId }] }) => {
-              return pendingRequestId === requestId;
-            }
+          this.logger.info(
+            'emitting the "request" event for %s listener(s)...',
+            emitter.listenerCount("request")
           );
+          await _chunk5PTPJLB7js.emitAsync.call(void 0, emitter, "request", {
+            request: interactiveRequest,
+            requestId
+          });
           this.logger.info('all "request" listeners settled!');
-          const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+          const mockedResponse2 = await requestController.responsePromise;
           this.logger.info("event.respondWith called with:", mockedResponse2);
           return mockedResponse2;
         });
@@ -686,7 +693,7 @@ function createXMLHttpRequestProxy({
             "request listener threw an exception, aborting request...",
             resolverResult.error
           );
-          requestController.errorWith(resolverResult.error);
+          xhrRequestController.errorWith(resolverResult.error);
           return;
         }
         const mockedResponse = resolverResult.data;
@@ -700,16 +707,16 @@ function createXMLHttpRequestProxy({
             this.logger.info(
               "received a network error response, rejecting the request promise..."
             );
-            requestController.errorWith(new TypeError("Network error"));
+            xhrRequestController.errorWith(new TypeError("Network error"));
             return;
           }
-          return requestController.respondWith(mockedResponse);
+          return xhrRequestController.respondWith(mockedResponse);
         }
         this.logger.info(
           "no mocked response received, performing request as-is..."
         );
       };
-      requestController.onResponse = async function({
+      xhrRequestController.onResponse = async function({
         response,
         isMockedResponse,
         request,
@@ -726,14 +733,14 @@ function createXMLHttpRequestProxy({
           requestId
         });
       };
-      return requestController.request;
+      return xhrRequestController.request;
     }
   });
   return XMLHttpRequestProxy;
 }
 
 // src/interceptors/XMLHttpRequest/index.ts
-var _XMLHttpRequestInterceptor = class extends _chunkXYZRP5S2js.Interceptor {
+var _XMLHttpRequestInterceptor = class extends _chunk3XFLRXRYjs.Interceptor {
   constructor() {
     super(_XMLHttpRequestInterceptor.interceptorSymbol);
   }

package/lib/node/{chunk-OL7OR4RL.mjs → chunk-MCO3RLQC.mjs}

@@ -1,10 +1,14 @@
 import {
+  responseStatusCodesWithoutBody
+} from "./chunk-3IYIKC3X.mjs";
+import {
+  emitAsync,
   toInteractiveRequest,
   uuidv4
-} from "./chunk-STA6QBYM.mjs";
+} from "./chunk-YQGTMMOZ.mjs";
 import {
   Interceptor
-} from "./chunk-RGYCLCLK.mjs";
+} from "./chunk-GM3YBSM3.mjs";
 
 // src/interceptors/ClientRequest/index.ts
 import http from "http";
@@ -13,6 +17,7 @@ import https from "https";
 // src/interceptors/ClientRequest/NodeClientRequest.ts
 import { ClientRequest, IncomingMessage as IncomingMessage2 } from "http";
 import { until } from "@open-draft/until";
+import { DeferredPromise } from "@open-draft/deferred-promise";
 
 // src/interceptors/ClientRequest/utils/normalizeClientRequestEndArgs.ts
 import { Logger } from "@open-draft/logger";
@@ -101,13 +106,15 @@ function inheritProperties(source, target) {
 
 // src/interceptors/ClientRequest/utils/createResponse.ts
 function createResponse(message) {
-  const readable = new ReadableStream({
+  const responseBodyOrNull = responseStatusCodesWithoutBody.includes(
+    message.statusCode || 200
+  ) ? null : new ReadableStream({
     start(controller) {
       message.on("data", (chunk) => controller.enqueue(chunk));
       message.on("end", () => controller.close());
     }
   });
-  return new Response(readable, {
+  return new Response(responseBodyOrNull, {
     status: message.statusCode,
     statusText: message.statusMessage,
     headers: createHeadersFromIncomingHttpHeaders(message.headers)
@@ -155,7 +162,6 @@ function createRequest(clientRequest) {
 }
 
 // src/interceptors/ClientRequest/NodeClientRequest.ts
-import { DeferredPromise } from "@open-draft/deferred-promise";
 var _NodeClientRequest = class extends ClientRequest {
   constructor([url, requestOptions, callback], options) {
     super(requestOptions, callback);
@@ -208,27 +214,36 @@ var _NodeClientRequest = class extends ClientRequest {
     this.logger.info("normalized arguments:", { chunk, encoding, callback });
     this.writeRequestBodyChunk(chunk, encoding || void 0);
     const capturedRequest = createRequest(this);
-    const interactiveRequest = toInteractiveRequest(capturedRequest);
+    const { interactiveRequest, requestController } = toInteractiveRequest(capturedRequest);
+    Object.defineProperty(capturedRequest, "respondWith", {
+      value: requestController.respondWith.bind(requestController)
+    });
     if (this.getHeader("X-Request-Id") != null) {
       this.removeHeader("X-Request-Id");
       return this.passthrough(chunk, encoding, callback);
     }
-    this.logger.info(
-      'emitting the "request" event for %d listener(s)...',
-      this.emitter.listenerCount("request")
-    );
-    this.emitter.emit("request", {
-      request: interactiveRequest,
-      requestId
+    this.emitter.once("request", ({ requestId: pendingRequestId }) => {
+      if (pendingRequestId !== requestId) {
+        return;
+      }
+      if (requestController.responsePromise.state === "pending") {
+        this.logger.info(
+          "request has not been handled in listeners, executing fail-safe listener..."
+        );
+        requestController.responsePromise.resolve(void 0);
+      }
     });
     until(async () => {
-      await this.emitter.untilIdle(
-        "request",
-        ({ args: [{ requestId: pendingRequestId }] }) => {
-          return pendingRequestId === requestId;
-        }
+      this.logger.info(
+        'emitting the "request" event for %d listener(s)...',
+        this.emitter.listenerCount("request")
       );
-      const [mockedResponse] = await interactiveRequest.respondWith.invoked();
+      await emitAsync(this.emitter, "request", {
+        request: interactiveRequest,
+        requestId
+      });
+      this.logger.info('all "request" listeners done!');
+      const mockedResponse = await requestController.responsePromise;
       this.logger.info("event.respondWith called with:", mockedResponse);
       return mockedResponse;
     }).then((resolverResult) => {
@@ -243,13 +258,19 @@ var _NodeClientRequest = class extends ClientRequest {
           "encountered resolver exception, aborting request...",
           resolverResult.error
         );
+        this.destroyed = true;
         this.emit("error", resolverResult.error);
         this.terminate();
         return this;
       }
       const mockedResponse = resolverResult.data;
       if (mockedResponse) {
-        this.logger.info("received mocked response:", mockedResponse);
+        this.logger.info(
+          "received mocked response:",
+          mockedResponse.status,
+          mockedResponse.statusText
+        );
+        this.destroyed = false;
         if (mockedResponse.type === "error") {
           this.logger.info(
             "received network error response, aborting request..."
@@ -381,9 +402,13 @@ var _NodeClientRequest = class extends ClientRequest {
       });
     }
     this.logger.info("mocked response headers ready:", headers);
+    this.res = this.response;
+    this.emit("response", this.response);
     const isResponseStreamFinished = new DeferredPromise();
     const finishResponseStream = () => {
       this.logger.info("finished response stream!");
+      this.response.push(null);
+      this.response.complete = true;
       isResponseStreamFinished.resolve();
     };
     if (body) {
@@ -401,14 +426,11 @@ var _NodeClientRequest = class extends ClientRequest {
     } else {
       finishResponseStream();
     }
-    this.res = this.response;
-    this.emit("response", this.response);
     isResponseStreamFinished.then(() => {
       this.logger.info("finalizing response...");
-      this.response.push(null);
-      this.response.complete = true;
       this.response.emit("end");
       this.terminate();
+      this.logger.info("request complete!");
     });
   }
   /**
@@ -696,7 +718,7 @@ function normalizeClientRequestArgs(defaultProtocol, ...args) {
 
 // src/interceptors/ClientRequest/http.get.ts
 function get(protocol, options) {
-  return (...args) => {
+  return function interceptorsHttpGet(...args) {
     const clientRequestArgs = normalizeClientRequestArgs(
       `${protocol}:`,
       ...args
@@ -711,7 +733,7 @@ function get(protocol, options) {
 import { Logger as Logger6 } from "@open-draft/logger";
 var logger6 = new Logger6("http request");
 function request(protocol, options) {
-  return (...args) => {
+  return function interceptorsHttpRequest(...args) {
     logger6.info('request call (protocol "%s"):', protocol, args);
     const clientRequestArgs = normalizeClientRequestArgs(
       `${protocol}:`,