@mswjs/interceptors 0.25.0 → 0.25.2

package/lib/node/interceptors/ClientRequest/index.js

@@ -1,8 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk3MYUI4B2js = require('../../chunk-3MYUI4B2.js');
-require('../../chunk-ZJOF5MEZ.js');
-require('../../chunk-XYZRP5S2.js');
+var _chunkB2CIOP5Bjs = require('../../chunk-B2CIOP5B.js');
+require('../../chunk-5PTPJLB7.js');
+require('../../chunk-3XFLRXRY.js');
 
 
-exports.ClientRequestInterceptor = _chunk3MYUI4B2js.ClientRequestInterceptor;
+exports.ClientRequestInterceptor = _chunkB2CIOP5Bjs.ClientRequestInterceptor;

package/lib/node/interceptors/ClientRequest/index.mjs

@@ -1,8 +1,8 @@
 import {
   ClientRequestInterceptor
-} from "../../chunk-OL7OR4RL.mjs";
-import "../../chunk-STA6QBYM.mjs";
-import "../../chunk-RGYCLCLK.mjs";
+} from "../../chunk-OMRBBJT7.mjs";
+import "../../chunk-YQGTMMOZ.mjs";
+import "../../chunk-GM3YBSM3.mjs";
 export {
   ClientRequestInterceptor
 };

package/lib/node/interceptors/XMLHttpRequest/index.d.ts

@@ -1,12 +1,13 @@
-import { f as InteractiveRequest, A as AsyncEventEmitter, H as HttpRequestEventMap, e as Interceptor } from '../../Interceptor-738f79c5.js';
+import { Emitter } from 'strict-event-emitter';
+import { f as InteractiveRequest, H as HttpRequestEventMap, e as Interceptor } from '../../Interceptor-7a701c1f.js';
+import '@open-draft/deferred-promise';
 import '@open-draft/logger';
-import 'strict-event-emitter';
 
 type XMLHttpRequestEventListener = (args: {
     request: InteractiveRequest;
     requestId: string;
 }) => Promise<void> | void;
-type XMLHttpRequestEmitter = AsyncEventEmitter<HttpRequestEventMap>;
+type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>;
 declare class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
     static interceptorSymbol: symbol;
     constructor();

package/lib/node/interceptors/XMLHttpRequest/index.js

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkE6YC337Qjs = require('../../chunk-E6YC337Q.js');
+var _chunk5YAV7CXXjs = require('../../chunk-5YAV7CXX.js');
 require('../../chunk-3LFH2WCF.js');
 require('../../chunk-VQ4DZOBB.js');
-require('../../chunk-ZJOF5MEZ.js');
-require('../../chunk-XYZRP5S2.js');
+require('../../chunk-5PTPJLB7.js');
+require('../../chunk-3XFLRXRY.js');
 
 
-exports.XMLHttpRequestInterceptor = _chunkE6YC337Qjs.XMLHttpRequestInterceptor;
+exports.XMLHttpRequestInterceptor = _chunk5YAV7CXXjs.XMLHttpRequestInterceptor;

package/lib/node/interceptors/XMLHttpRequest/index.mjs

@@ -1,10 +1,10 @@
 import {
   XMLHttpRequestInterceptor
-} from "../../chunk-HSCXCLVT.mjs";
+} from "../../chunk-7RGC35CC.mjs";
 import "../../chunk-7II4SWKS.mjs";
 import "../../chunk-GFH37L5D.mjs";
-import "../../chunk-STA6QBYM.mjs";
-import "../../chunk-RGYCLCLK.mjs";
+import "../../chunk-YQGTMMOZ.mjs";
+import "../../chunk-GM3YBSM3.mjs";
 export {
   XMLHttpRequestInterceptor
 };

package/lib/node/interceptors/fetch/index.d.ts

@@ -1,4 +1,5 @@
-import { e as Interceptor, H as HttpRequestEventMap } from '../../Interceptor-738f79c5.js';
+import { e as Interceptor, H as HttpRequestEventMap } from '../../Interceptor-7a701c1f.js';
+import '@open-draft/deferred-promise';
 import '@open-draft/logger';
 import 'strict-event-emitter';
 

package/lib/node/interceptors/fetch/index.js

@@ -4,16 +4,17 @@ 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/fetch/index.ts
-var _deferredpromise = require('@open-draft/deferred-promise');
 var _outvariant = require('outvariant');
+var _deferredpromise = require('@open-draft/deferred-promise');
 var _until = require('@open-draft/until');
-var _FetchInterceptor = class extends _chunkXYZRP5S2js.Interceptor {
+var _FetchInterceptor = class extends _chunk3XFLRXRYjs.Interceptor {
   constructor() {
     super(_FetchInterceptor.symbol);
   }
@@ -28,17 +29,21 @@ var _FetchInterceptor = class extends _chunkXYZRP5S2js.Interceptor {
     );
     globalThis.fetch = async (input, init) => {
       var _a;
-      const requestId = _chunkZJOF5MEZjs.uuidv4.call(void 0, );
+      const requestId = _chunk5PTPJLB7js.uuidv4.call(void 0, );
       const request = new Request(input, init);
       this.logger.info("[%s] %s", request.method, request.url);
-      const interactiveRequest = _chunkZJOF5MEZjs.toInteractiveRequest.call(void 0, request);
+      const { interactiveRequest, requestController } = _chunk5PTPJLB7js.toInteractiveRequest.call(void 0, request);
       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") {
+          requestController.responsePromise.resolve(void 0);
+        }
       });
       this.logger.info("awaiting for the mocked response...");
       const signal = interactiveRequest.signal;
@@ -51,15 +56,20 @@ var _FetchInterceptor = class extends _chunkXYZRP5S2js.Interceptor {
         { once: true }
       );
       const resolverResult = await _until.until.call(void 0, async () => {
-        const allListenersResolved = this.emitter.untilIdle(
-          "request",
-          ({ args: [{ requestId: pendingRequestId }] }) => {
-            return pendingRequestId === requestId;
-          }
-        );
-        await Promise.race([requestAborted, allListenersResolved]);
+        const listenersFinished = _chunk5PTPJLB7js.emitAsync.call(void 0, this.emitter, "request", {
+          request: interactiveRequest,
+          requestId
+        });
+        await Promise.race([
+          requestAborted,
+          // Put the listeners invocation Promise in the same race condition
+          // with the request abort Promise because otherwise awaiting the listeners
+          // would always yield some response (or undefined).
+          listenersFinished,
+          requestController.responsePromise
+        ]);
         this.logger.info("all request listeners have been resolved!");
-        const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+        const mockedResponse2 = await requestController.responsePromise;
         this.logger.info("event.respondWith called with:", mockedResponse2);
         return mockedResponse2;
       });

package/lib/node/interceptors/fetch/index.mjs

@@ -2,16 +2,17 @@ import {
   IS_PATCHED_MODULE
 } from "../../chunk-GFH37L5D.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/fetch/index.ts
-import { DeferredPromise } from "@open-draft/deferred-promise";
 import { invariant } from "outvariant";
+import { DeferredPromise } from "@open-draft/deferred-promise";
 import { until } from "@open-draft/until";
 var _FetchInterceptor = class extends Interceptor {
   constructor() {
@@ -31,14 +32,18 @@ var _FetchInterceptor = class extends Interceptor {
       const requestId = uuidv4();
       const request = new Request(input, init);
       this.logger.info("[%s] %s", request.method, request.url);
-      const interactiveRequest = toInteractiveRequest(request);
+      const { interactiveRequest, requestController } = toInteractiveRequest(request);
       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") {
+          requestController.responsePromise.resolve(void 0);
+        }
       });
       this.logger.info("awaiting for the mocked response...");
       const signal = interactiveRequest.signal;
@@ -51,15 +56,20 @@ var _FetchInterceptor = class extends Interceptor {
         { once: true }
       );
       const resolverResult = await until(async () => {
-        const allListenersResolved = this.emitter.untilIdle(
-          "request",
-          ({ args: [{ requestId: pendingRequestId }] }) => {
-            return pendingRequestId === requestId;
-          }
-        );
-        await Promise.race([requestAborted, allListenersResolved]);
+        const listenersFinished = emitAsync(this.emitter, "request", {
+          request: interactiveRequest,
+          requestId
+        });
+        await Promise.race([
+          requestAborted,
+          // Put the listeners invocation Promise in the same race condition
+          // with the request abort Promise because otherwise awaiting the listeners
+          // would always yield some response (or undefined).
+          listenersFinished,
+          requestController.responsePromise
+        ]);
         this.logger.info("all request listeners have been resolved!");
-        const [mockedResponse2] = await interactiveRequest.respondWith.invoked();
+        const mockedResponse2 = await requestController.responsePromise;
         this.logger.info("event.respondWith called with:", mockedResponse2);
         return mockedResponse2;
       });

package/lib/node/presets/node.d.ts

@@ -2,9 +2,10 @@ import { ClientRequestInterceptor } from '../interceptors/ClientRequest/index.js
 import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest/index.js';
 import 'http';
 import 'https';
-import '../Interceptor-738f79c5.js';
-import '@open-draft/logger';
 import 'strict-event-emitter';
+import '../Interceptor-7a701c1f.js';
+import '@open-draft/deferred-promise';
+import '@open-draft/logger';
 
 /**
  * The default preset provisions the interception of requests

package/lib/node/presets/node.js

@@ -1,18 +1,18 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk3MYUI4B2js = require('../chunk-3MYUI4B2.js');
+var _chunkB2CIOP5Bjs = require('../chunk-B2CIOP5B.js');
 
 
-var _chunkE6YC337Qjs = require('../chunk-E6YC337Q.js');
+var _chunk5YAV7CXXjs = require('../chunk-5YAV7CXX.js');
 require('../chunk-3LFH2WCF.js');
 require('../chunk-VQ4DZOBB.js');
-require('../chunk-ZJOF5MEZ.js');
-require('../chunk-XYZRP5S2.js');
+require('../chunk-5PTPJLB7.js');
+require('../chunk-3XFLRXRY.js');
 
 // src/presets/node.ts
 var node_default = [
-  new (0, _chunk3MYUI4B2js.ClientRequestInterceptor)(),
-  new (0, _chunkE6YC337Qjs.XMLHttpRequestInterceptor)()
+  new (0, _chunkB2CIOP5Bjs.ClientRequestInterceptor)(),
+  new (0, _chunk5YAV7CXXjs.XMLHttpRequestInterceptor)()
 ];
 
 

package/lib/node/presets/node.mjs

@@ -1,13 +1,13 @@
 import {
   ClientRequestInterceptor
-} from "../chunk-OL7OR4RL.mjs";
+} from "../chunk-OMRBBJT7.mjs";
 import {
   XMLHttpRequestInterceptor
-} from "../chunk-HSCXCLVT.mjs";
+} from "../chunk-7RGC35CC.mjs";
 import "../chunk-7II4SWKS.mjs";
 import "../chunk-GFH37L5D.mjs";
-import "../chunk-STA6QBYM.mjs";
-import "../chunk-RGYCLCLK.mjs";
+import "../chunk-YQGTMMOZ.mjs";
+import "../chunk-GM3YBSM3.mjs";
 
 // src/presets/node.ts
 var node_default = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mswjs/interceptors",
   "description": "Low-level HTTP/HTTPS/XHR/fetch request interception library.",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "main": "./lib/node/index.js",
   "module": "./lib/node/index.mjs",
   "types": "./lib/node/index.d.ts",
@@ -123,7 +123,7 @@
     "webpack-http-server": "^0.5.0"
   },
   "dependencies": {
-    "@open-draft/deferred-promise": "^2.1.0",
+    "@open-draft/deferred-promise": "^2.2.0",
     "@open-draft/logger": "^0.3.0",
     "@open-draft/until": "^2.0.0",
     "is-node-process": "^1.2.0",

package/src/BatchInterceptor.test.ts

@@ -112,3 +112,144 @@ it('disposes of child interceptors', async () => {
   expect(primaryDisposeSpy).toHaveBeenCalledTimes(1)
   expect(secondaryDisposeSpy).toHaveBeenCalledTimes(1)
 })
+
+it('forwards listeners added via "on()"', () => {
+  class FirstInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(1)
+  expect(interceptor['emitter'].listenerCount('foo')).toBe(0)
+})
+
+it('forwards listeners removal via "off()"', () => {
+  type Events = {
+    foo: []
+  }
+
+  class FirstInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+  interceptor.off('foo', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(0)
+})
+
+it('forwards removal of all listeners by name via ".removeAllListeners()"', () => {
+  type Events = {
+    foo: []
+    bar: []
+  }
+
+  class FirstInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<Events> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+  interceptor.on('foo', listener)
+  interceptor.on('bar', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(1)
+
+  interceptor.removeAllListeners('foo')
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(1)
+})
+
+it('forwards removal of all listeners via ".removeAllListeners()"', () => {
+  class FirstInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('first'))
+    }
+  }
+  class SecondaryInterceptor extends Interceptor<any> {
+    constructor() {
+      super(Symbol('second'))
+    }
+  }
+
+  const firstInterceptor = new FirstInterceptor()
+  const secondInterceptor = new SecondaryInterceptor()
+
+  const interceptor = new BatchInterceptor({
+    name: 'batch',
+    interceptors: [firstInterceptor, secondInterceptor],
+  })
+
+  const listener = vi.fn()
+  interceptor.on('foo', listener)
+  interceptor.on('foo', listener)
+  interceptor.on('bar', listener)
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(2)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(1)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(1)
+
+  interceptor.removeAllListeners()
+
+  expect(firstInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('foo')).toBe(0)
+  expect(firstInterceptor['emitter'].listenerCount('bar')).toBe(0)
+  expect(secondInterceptor['emitter'].listenerCount('bar')).toBe(0)
+})

package/src/BatchInterceptor.ts

@@ -1,5 +1,5 @@
 import { EventMap, Listener } from 'strict-event-emitter'
-import { ExtractEventNames, Interceptor } from './Interceptor'
+import { Interceptor, ExtractEventNames } from './Interceptor'
 
 export interface BatchInterceptorOptions<
   InterceptorList extends ReadonlyArray<Interceptor<any>>
@@ -51,11 +51,45 @@ export class BatchInterceptor<
   public on<EventName extends ExtractEventNames<Events>>(
     event: EventName,
     listener: Listener<Events[EventName]>
-  ) {
+  ): this {
     // Instead of adding a listener to the batch interceptor,
     // propagate the listener to each of the individual interceptors.
-    this.interceptors.forEach((interceptor) => {
+    for (const interceptor of this.interceptors) {
       interceptor.on(event, listener)
-    })
+    }
+
+    return this
+  }
+
+  public once<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    for (const interceptor of this.interceptors) {
+      interceptor.once(event, listener)
+    }
+
+    return this
+  }
+
+  public off<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    for (const interceptor of this.interceptors) {
+      interceptor.off(event, listener)
+    }
+
+    return this
+  }
+
+  public removeAllListeners<EventName extends ExtractEventNames<Events>>(
+    event?: EventName | undefined
+  ): this {
+    for (const interceptors of this.interceptors) {
+      interceptors.removeAllListeners(event)
+    }
+
+    return this
   }
 }

package/src/Interceptor.test.ts

@@ -18,6 +18,52 @@ it('does not set a maximum listeners limit', () => {
   expect(interceptor['emitter'].getMaxListeners()).toBe(0)
 })
 
+describe('on()', () => {
+  it('adds a new listener using "on()"', () => {
+    const interceptor = new Interceptor(symbol)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(0)
+
+    const listener = vi.fn()
+    interceptor.on('event', listener)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(1)
+  })
+})
+
+describe('once()', () => {
+  it('calls the listener only once', () => {
+    const interceptor = new Interceptor(symbol)
+    const listener = vi.fn()
+
+    interceptor.once('foo', listener)
+    expect(listener).not.toHaveBeenCalled()
+
+    interceptor['emitter'].emit('foo', 'bar')
+
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(listener).toHaveBeenCalledWith('bar')
+
+    listener.mockReset()
+
+    interceptor['emitter'].emit('foo', 'baz')
+    interceptor['emitter'].emit('foo', 'xyz')
+    expect(listener).toHaveBeenCalledTimes(0)
+  })
+})
+
+describe('off()', () => {
+  it('removes a listener using "off()"', () => {
+    const interceptor = new Interceptor(symbol)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(0)
+
+    const listener = vi.fn()
+    interceptor.on('event', listener)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(1)
+
+    interceptor.off('event', listener)
+    expect(interceptor['emitter'].listenerCount('event')).toBe(0)
+  })
+})
+
 describe('persistence', () => {
   it('stores global reference to the applied interceptor', () => {
     const interceptor = new Interceptor(symbol)