@mswjs/interceptors 0.20.0 → 0.21.0

package/README.md

@@ -107,7 +107,7 @@ To use this library you need to choose one or multiple interceptors to apply. Th
 Use an interceptor by constructing it and attaching request/response listeners:
 
 ```js
-import { ClientRequestInterceptor } from '@mswjs/interceptors/lib/interceptors/ClientRequest'
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
 
 const interceptor = new ClientRequestInterceptor()
 
@@ -138,8 +138,8 @@ You can combine multiple interceptors to capture requests from different request
 
 ```js
 import { BatchInterceptor } from '@mswjs/interceptors'
-import { ClientRequestInterceptor } from '@mswjs/interceptors/lib/interceptors/ClientRequest'
-import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/lib/interceptors/XMLHttpRequest'
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
+import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
 
 const interceptor = new BatchInterceptor({
   name: 'my-interceptor',
@@ -256,7 +256,7 @@ interceptor.on('request', (request, requestId) => {
 })
 ```
 
-> We use Fetch API `Response` class as the middleground for mocked response definition. This library then coerces the response instance to the appropriate response format (e.g. to `http.OutgoingMessage` in the case of `http.ClientRequest`).
+> We use Fetch API `Response` class as the middle-ground for mocked response definition. This library then coerces the response instance to the appropriate response format (e.g. to `http.OutgoingMessage` in the case of `http.ClientRequest`).
 
 **The `Response` class is built-in in since Node.js 18. Use a Fetch API-compatible polyfill, like `node-fetch`, for older versions of Node.js.`**
 
@@ -326,8 +326,8 @@ Enables request interception in the current process while delegating the respons
 
 ```js
 // child.js
-import { RemoteHttpInterceptor } from '@mswjs/interceptors/lib/RemoteHttpInterceptor'
-import { ClientRequestInterceptor } from '@mswjs/interceptors/lib/interceptors/ClientRequest'
+import { RemoteHttpInterceptor } from '@mswjs/interceptors/RemoteHttpInterceptor'
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
 
 const interceptor = new RemoteHttpInterceptor({
   // Alternatively, you can use presets.
@@ -350,7 +350,7 @@ Resolves an intercepted request in the given child `process`. Requires for that
 ```js
 // parent.js
 import { spawn } from 'child_process'
-import { RemoteHttpResolver } from '@mswjs/interceptors/lib/RemoteHttpInterceptor'
+import { RemoteHttpResolver } from '@mswjs/interceptors/RemoteHttpInterceptor'
 
 const appProcess = spawn('node', ['app.js'], {
   stdio: ['inherit', 'inherit', 'inherit', 'ipc'],

package/lib/browser/Interceptor-959f650e.d.ts

@@ -0,0 +1,104 @@
+import { Debugger } from 'debug';
+import { EventMap, Emitter, Listener } from 'strict-event-emitter';
+
+type AnyFunction = (...args: any[]) => any;
+type LazyCallbackReturnType<FnType extends AnyFunction> = Parameters<FnType> | [];
+interface LazyCallback<FnType extends AnyFunction> {
+    (...args: Parameters<FnType>): void;
+    invoked(): Promise<LazyCallbackReturnType<FnType>>;
+}
+
+type LazyResponseCallback = (response: Response) => void;
+type InteractiveRequest = globalThis.Request & {
+    respondWith: LazyCallback<LazyResponseCallback>;
+};
+
+declare const IS_PATCHED_MODULE: unique symbol;
+type RequestCredentials = 'omit' | 'include' | 'same-origin';
+type HttpRequestEventMap = {
+    request: [request: InteractiveRequest, requestId: string];
+    response: [response: Response, request: Request, requestId: string];
+};
+
+interface QueueItem<Args extends Array<unknown>> {
+    args: Args;
+    done: Promise<void>;
+}
+declare enum AsyncEventEmitterReadyState {
+    ACTIVE = "ACTIVE",
+    DEACTIVATED = "DEACTIVATED"
+}
+declare class AsyncEventEmitter<Events extends EventMap> extends Emitter<Events> {
+    readyState: AsyncEventEmitterReadyState;
+    private log;
+    protected queue: Map<keyof Events, Array<QueueItem<Events[any]>>>;
+    constructor();
+    on<EventName extends keyof Events>(eventName: EventName, listener: Listener<any>): this;
+    emit<EventName extends keyof Events>(eventName: EventName, ...data: Events[EventName]): boolean;
+    /**
+     * 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.
+     */
+    untilIdle<EventName extends keyof Events>(eventName: EventName, filter?: (item: QueueItem<Events[EventName]>) => boolean): Promise<void>;
+    private openListenerQueue;
+    removeAllListeners<EventName extends keyof Events>(eventName?: EventName): this;
+    activate(): void;
+    /**
+     * 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(): void;
+    private isInternalEventName;
+}
+
+type InterceptorEventMap = Record<string, any>;
+type InterceptorSubscription = () => void;
+declare function getGlobalSymbol<V>(symbol: Symbol): V | undefined;
+declare function deleteGlobalSymbol(symbol: Symbol): void;
+declare enum InterceptorReadyState {
+    INACTIVE = "INACTIVE",
+    APPLYING = "APPLYING",
+    APPLIED = "APPLIED",
+    DISPOSING = "DISPOSING",
+    DISPOSED = "DISPOSED"
+}
+type ExtractEventNames<Events extends Record<string, any>> = Events extends Record<infer EventName, any> ? EventName : never;
+declare class Interceptor<Events extends InterceptorEventMap> {
+    private readonly symbol;
+    protected emitter: AsyncEventEmitter<Events>;
+    protected subscriptions: Array<InterceptorSubscription>;
+    protected log: Debugger;
+    readyState: InterceptorReadyState;
+    constructor(symbol: Symbol);
+    /**
+     * Determine if this interceptor can be applied
+     * in the current environment.
+     */
+    protected checkEnvironment(): boolean;
+    /**
+     * Apply this interceptor to the current process.
+     * Returns an already running interceptor instance if it's present.
+     */
+    apply(): void;
+    /**
+     * Setup the module augments and stubs necessary for this interceptor.
+     * This method is not run if there's a running interceptor instance
+     * to prevent instantiating an interceptor multiple times.
+     */
+    protected setup(): void;
+    /**
+     * Listen to the interceptor's public events.
+     */
+    on<EventName extends ExtractEventNames<Events>>(eventName: EventName, listener: Listener<Events[EventName]>): void;
+    /**
+     * Disposes of any side-effects this interceptor has introduced.
+     */
+    dispose(): void;
+    private getInstance;
+    private setInstance;
+    private clearInstance;
+}
+
+export { AsyncEventEmitter as A, ExtractEventNames as E, HttpRequestEventMap as H, Interceptor as I, RequestCredentials as R, IS_PATCHED_MODULE as a, InterceptorEventMap as b, InterceptorSubscription as c, deleteGlobalSymbol as d, InterceptorReadyState as e, InteractiveRequest as f, getGlobalSymbol as g };