chore: migrate to rettime

package.json

@@ -252,7 +252,7 @@
     "outvariant": "^1.4.3",
     "path-to-regexp": "^6.3.0",
     "picocolors": "^1.1.1",
-    "strict-event-emitter": "^0.5.1",
+    "rettime": "^0.6.2",
     "type-fest": "^4.26.1",
     "yargs": "^17.7.2"
   },

src/browser/setupWorker/glossary.ts

@@ -1,4 +1,4 @@
-import { Emitter } from 'strict-event-emitter'
+import { Emitter } from 'rettime'
 import {
   LifeCycleEventEmitter,
   LifeCycleEventsMap,
@@ -95,7 +95,7 @@ export interface SetupWorkerInternalContext {
     /**
      * Adds a Service Worker event listener.
      */
-    on<EventType extends keyof ServiceWorkerIncomingEventsMap>(
+    on: <EventType extends keyof ServiceWorkerIncomingEventsMap>(
       eventType: EventType,
       callback: (
         event: MessageEvent,
@@ -104,10 +104,10 @@ export interface SetupWorkerInternalContext {
           ServiceWorkerIncomingEventsMap[EventType]
         >,
       ) => void,
-    ): void
-    send<EventType extends ServiceWorkerOutgoingEventTypes>(
+    ) => void
+    send: <EventType extends ServiceWorkerOutgoingEventTypes>(
       eventType: EventType,
-    ): void
+    ) => void
   }
   events: {
     /**
@@ -122,13 +122,13 @@ export interface SetupWorkerInternalContext {
     /**
      * Removes all currently attached listeners.
      */
-    removeAllListeners(): void
+    removeAllListeners: () => void
     /**
      * Awaits a given message type from the Service Worker.
      */
-    once<EventType extends keyof ServiceWorkerIncomingEventsMap>(
+    once: <EventType extends keyof ServiceWorkerIncomingEventsMap>(
       eventType: EventType,
-    ): Promise<
+    ) => Promise<
       ServiceWorkerMessage<EventType, ServiceWorkerIncomingEventsMap[EventType]>
     >
   }
@@ -235,7 +235,7 @@ export interface SetupWorker {
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/list-handlers `worker.listHandlers()` API reference}
    */
-  listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>
+  listHandlers: () => ReadonlyArray<RequestHandler | WebSocketHandler>
 
   /**
    * Life-cycle events.

src/core/SetupApi.ts

@@ -1,5 +1,5 @@
 import { invariant } from 'outvariant'
-import { EventMap, Emitter } from 'strict-event-emitter'
+import { Emitter, type DefaultEventMap } from 'rettime'
 import { RequestHandler } from './handlers/RequestHandler'
 import { LifeCycleEventEmitter } from './sharedOptions'
 import { devUtils } from './utils/internal/devUtils'
@@ -12,8 +12,10 @@ export abstract class HandlersController {
   abstract prepend(
     runtimeHandlers: Array<RequestHandler | WebSocketHandler>,
   ): void
-  abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void
-  abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>
+  abstract reset: (
+    nextHandles: Array<RequestHandler | WebSocketHandler>,
+  ) => void
+  abstract currentHandlers: () => Array<RequestHandler | WebSocketHandler>
 }
 
 export class InMemoryHandlersController implements HandlersController {
@@ -44,12 +46,14 @@ export class InMemoryHandlersController implements HandlersController {
 /**
  * Generic class for the mock API setup.
  */
-export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
+export abstract class SetupApi<
+  EventMap extends DefaultEventMap,
+> extends Disposable {
   protected handlersController: HandlersController
-  protected readonly emitter: Emitter<EventsMap>
-  protected readonly publicEmitter: Emitter<EventsMap>
+  protected readonly emitter: Emitter<EventMap>
+  protected readonly publicEmitter: Emitter<EventMap>
 
-  public readonly events: LifeCycleEventEmitter<EventsMap>
+  public readonly events: LifeCycleEventEmitter<EventMap>
 
   constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>) {
     super()
@@ -63,8 +67,8 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
 
     this.handlersController = new InMemoryHandlersController(initialHandlers)
 
-    this.emitter = new Emitter<EventsMap>()
-    this.publicEmitter = new Emitter<EventsMap>()
+    this.emitter = new Emitter<EventMap>()
+    this.publicEmitter = new Emitter<EventMap>()
     pipeEvents(this.emitter, this.publicEmitter)
 
     this.events = this.createLifeCycleEvents()
@@ -111,17 +115,15 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
     return toReadonlyArray(this.handlersController.currentHandlers())
   }
 
-  private createLifeCycleEvents(): LifeCycleEventEmitter<EventsMap> {
+  private createLifeCycleEvents(): LifeCycleEventEmitter<EventMap> {
     return {
-      on: (...args: any[]) => {
-        return (this.publicEmitter.on as any)(...args)
-      },
-      removeListener: (...args: any[]) => {
-        return (this.publicEmitter.removeListener as any)(...args)
-      },
-      removeAllListeners: (...args: any[]) => {
-        return this.publicEmitter.removeAllListeners(...args)
-      },
+      on: this.publicEmitter.on.bind(this.publicEmitter),
+      removeListener: this.publicEmitter.removeListener.bind(
+        this.publicEmitter,
+      ),
+      removeAllListeners: this.publicEmitter.removeAllListeners.bind(
+        this.publicEmitter,
+      ),
     }
   }
 }

src/core/handlers/WebSocketHandler.ts

@@ -1,4 +1,4 @@
-import { Emitter } from 'strict-event-emitter'
+import { type DefaultEventMap, Emitter, TypedEvent } from 'rettime'
 import { createRequestId } from '@mswjs/interceptors'
 import type {
   WebSocketClientConnectionProtocol,
@@ -18,8 +18,8 @@ type WebSocketHandlerParsedResult = {
   match: Match
 }
 
-export type WebSocketHandlerEventMap = {
-  connection: [args: WebSocketHandlerConnection]
+export interface WebSocketHandlerEventMap extends DefaultEventMap {
+  connection: TypedEvent<WebSocketHandlerConnection>
 }
 
 export interface WebSocketHandlerConnection {
@@ -136,7 +136,9 @@ export class WebSocketHandler {
 
     // Emit the connection event on the handler.
     // This is what the developer adds listeners for.
-    return this[kEmitter].emit('connection', connection)
+    return this[kEmitter].emit(
+      new TypedEvent('connection', { data: connection }),
+    )
   }
 }
 

src/core/sharedOptions.ts

@@ -1,4 +1,4 @@
-import type { Emitter } from 'strict-event-emitter'
+import type { Emitter, DefaultEventMap } from 'rettime'
 import type { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest'
 
 export interface SharedOptions {
@@ -13,46 +13,46 @@
   onUnhandledRequest?: UnhandledRequestStrategy
 }
 
-export type LifeCycleEventsMap = {
+export interface LifeCycleEventsMap extends DefaultEventMap {
   'request:start': [
     args: {
       request: Request
       requestId: string
     },
   ]
   'request:match': [
     args: {
       request: Request
       requestId: string
     },
   ]
   'request:unhandled': [
     args: {
       request: Request
       requestId: string
     },
   ]
   'request:end': [
     args: {
       request: Request
       requestId: string
     },
   ]
   'response:mocked': [
     args: {
       response: Response
       request: Request
       requestId: string
     },
   ]
   'response:bypass': [
     args: {
       response: Response
       request: Request
       requestId: string
     },
   ]
   unhandledException: [
     args: {
       error: Error
       request: Request
@@ -61,6 +61,7 @@
   ]
 }
 
-export type LifeCycleEventEmitter<
-  EventsMap extends Record<string | symbol, any>,
-> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>
+export type LifeCycleEventEmitter<EventMap extends DefaultEventMap> = Pick<
+  Emitter<EventMap>,
+  'on' | 'removeListener' | 'removeAllListeners'
+>

src/core/utils/handleRequest.test.ts

@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import { Emitter } from 'strict-event-emitter'
+import { Emitter } from 'rettime'
 import { createRequestId } from '@mswjs/interceptors'
 import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequestHandler } from '../handlers/RequestHandler'

src/core/utils/handleRequest.ts

@@ -1,5 +1,5 @@
 import { until } from '@open-draft/until'
-import { Emitter } from 'strict-event-emitter'
+import { Emitter } from 'rettime'
 import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequiredDeep } from '../typeUtils'
 import type { RequestHandler } from '../handlers/RequestHandler'
@@ -44,11 +44,11 @@
   emitter: Emitter<LifeCycleEventsMap>,
   handleRequestOptions?: HandleRequestOptions,
 ): Promise<Response | undefined> {
   emitter.emit('request:start', { request, requestId })
 
   // Perform requests wrapped in "bypass()" as-is.
   if (request.headers.get('accept')?.includes('msw/passthrough')) {
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)
     return
   }
@@ -65,7 +65,7 @@
 
   if (lookupResult.error) {
     // Allow developers to react to unhandled exceptions in request handlers.
     emitter.emit('unhandledException', {
       error: lookupResult.error,
       request,
       requestId,
@@ -77,8 +77,8 @@
   // matching this request. Report the request as unhandled.
   if (!lookupResult.data) {
     await onUnhandledRequest(request, options.onUnhandledRequest)
     emitter.emit('request:unhandled', { request, requestId })
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)
     return
   }
@@ -88,7 +88,7 @@
   // When the handled request returned no mocked response, warn the developer,
   // as it may be an oversight on their part. Perform the request as-is.
   if (!response) {
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)
     return
   }
@@ -99,7 +99,7 @@
     response.status === 302 &&
     response.headers.get('x-msw-intention') === 'passthrough'
   ) {
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)
     return
   }
@@ -107,7 +107,7 @@
   // Store all the received response cookies in the cookie jar.
   storeResponseCookies(request, response)
 
   emitter.emit('request:match', { request, requestId })
 
   const requiredLookupResult =
     lookupResult.data as RequiredDeep<HandlersExecutionResult>

src/core/utils/internal/pipeEvents.test.ts

@@ -1,4 +1,4 @@
-import { Emitter } from 'strict-event-emitter'
+import { Emitter, TypedEvent } from 'rettime'
 import { pipeEvents } from './pipeEvents'
 
 it('pipes events from the source emitter to the destination emitter', () => {
@@ -9,6 +9,7 @@ it('pipes events from the source emitter to the destination emitter', () => {
   const callback = vi.fn()
   destination.on('hello', callback)
 
-  source.emit('hello', 'world', { data: true })
-  expect(callback).toHaveBeenNthCalledWith(1, 'world', { data: true })
+  const event = new TypedEvent('hello', { data: 'world' })
+  source.emit(event)
+  expect(callback).toHaveBeenNthCalledWith(1, event)
 })

src/core/utils/internal/pipeEvents.ts

@@ -1,11 +1,11 @@
-import { Emitter, EventMap } from 'strict-event-emitter'
+import type { Emitter, DefaultEventMap } from 'rettime'
 
 /**
  * Pipes all emitted events from one emitter to another.
  */
-export function pipeEvents<Events extends EventMap>(
-  source: Emitter<Events>,
-  destination: Emitter<Events>,
+export function pipeEvents<EventMap extends DefaultEventMap>(
+  source: Emitter<EventMap>,
+  destination: Emitter<EventMap>,
 ): void {
   const rawEmit: typeof source.emit & { _isPiped?: boolean } = source.emit
 
@@ -14,9 +14,9 @@ export function pipeEvents<Events extends EventMap>(
   }
 
   const sourceEmit: typeof source.emit & { _isPiped?: boolean } =
-    function sourceEmit(this: typeof source, event, ...data) {
-      destination.emit(event, ...data)
-      return rawEmit.call(this, event, ...data)
+    function sourceEmit(this: typeof source, event) {
+      destination.emit(event)
+      return rawEmit.call(this, event)
     }
 
   sourceEmit._isPiped = true

src/core/ws.ts

@@ -27,7 +27,7 @@
 
 export type WebSocketEventListener<
   EventType extends keyof WebSocketHandlerEventMap,
 > = (...args: WebSocketHandlerEventMap[EventType]) => void
 
 export type WebSocketLink = {
   /**
@@ -116,15 +116,15 @@
       // handler matches and emits a connection event.
       // When that happens, store that connection in the
       // set of all connections for reference.
-      handler[kEmitter].on('connection', async ({ client }) => {
-        await clientManager.addConnection(client)
+      handler[kEmitter].on('connection', async (event) => {
+        await clientManager.addConnection(event.data.client)
       })
 
       // The "handleWebSocketEvent" function will invoke
       // the "run()" method on the WebSocketHandler.
       // If the handler matches, it will emit the "connection"
       // event. Attach the user-defined listener to that event.
       handler[kEmitter].on(event, listener)
 
       return handler
     },

test/browser/setup/workerConsole.ts

@@ -1,5 +1,5 @@
 import { format } from 'outvariant'
-import { Emitter } from 'strict-event-emitter'
+import { type DefaultEventMap, Emitter, TypedEvent } from 'rettime'
 import { type Page } from '@playwright/test'
 
 type WorkerConsoleMessageType =
@@ -33,8 +33,8 @@ type WorkerConsoleMessageType =
   | 'context'
   | 'memory'
 
-type WorkerConsoleEventMap = {
-  [MessageType in WorkerConsoleMessageType]: [message: string]
+type WorkerConsoleEventMap = DefaultEventMap & {
+  [MessageType in WorkerConsoleMessageType]: TypedEvent<string>
 }
 
 type InternalWorkerConsoleMessageData = {
@@ -85,7 +85,7 @@ export class WorkerConsole extends Emitter<WorkerConsoleEventMap> {
         const formattedMessage = format(template, ...positionals)
 
         this.addMessage(messageType, formattedMessage)
-        this.emit(messageType, formattedMessage)
+        this.emit(new TypedEvent(messageType, { data: formattedMessage }))
       },
     )
 

test/support/WebSocketServer.ts

@@ -1,12 +1,12 @@
 import { invariant } from 'outvariant'
-import { Emitter } from 'strict-event-emitter'
+import { type DefaultEventMap, Emitter, TypedEvent } from 'rettime'
 import fastify, { FastifyInstance } from 'fastify'
 import fastifyWebSocket, { SocketStream } from '@fastify/websocket'
 
 type FastifySocket = SocketStream['socket']
 
-type WebSocketEventMap = {
-  connection: [client: FastifySocket]
+interface WebSocketEventMap extends DefaultEventMap {
+  connection: TypedEvent<FastifySocket>
 }
 
 export class WebSocketServer extends Emitter<WebSocketEventMap> {
@@ -24,8 +24,7 @@ export class WebSocketServer extends Emitter<WebSocketEventMap> {
       fastify.get('/', { websocket: true }, ({ socket }) => {
         this.clients.add(socket)
         socket.once('close', () => this.clients.delete(socket))
-
-        this.emit('connection', socket)
+        this.emit(new TypedEvent('connection', { data: socket }))
       })
     })
   }