msw 0.28.1 → 0.30.1

package/lib/iife/mockServiceWorker.js

@@ -1,11 +1,12 @@
+/* eslint-disable */
+/* tslint:disable */
+
 /**
- * Mock Service Worker.
+ * Mock Service Worker (0.30.1).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.
  */
-/* eslint-disable */
-/* tslint:disable */
 
 const INTEGRITY_CHECKSUM = '82ef9b96d8393b6da34527d1d6e19187'
 const bypassHeaderName = 'x-msw-bypass'

package/lib/types/context/body.d.ts

@@ -6,4 +6,4 @@ import { ResponseTransformer } from '../response';
  * res(ctx.body(JSON.stringify({ key: 'value' })))
  * @see {@link https://mswjs.io/docs/api/context/body `ctx.body()`}
  */
-export declare const body: <BodyType extends string | Blob | BufferSource | ReadableStream<any> | FormData>(value: BodyType) => ResponseTransformer<BodyType>;
+export declare const body: <BodyType extends string | Blob | BufferSource | ReadableStream<any> | FormData>(value: BodyType) => ResponseTransformer<BodyType, any>;

package/lib/types/context/json.d.ts

@@ -9,4 +9,4 @@ import { ResponseTransformer } from '../response';
  * res(ctx.json([1, '2', false, { ok: true }]))
  * @see {@link https://mswjs.io/docs/api/context/json `ctx.json()`}
  */
-export declare const json: <BodyTypeJSON>(body: BodyTypeJSON) => ResponseTransformer<BodyTypeJSON>;
+export declare const json: <BodyTypeJSON>(body: BodyTypeJSON) => ResponseTransformer<BodyTypeJSON, any>;

package/lib/types/context/text.d.ts

@@ -5,4 +5,4 @@ import { ResponseTransformer } from '../response';
  * @example res(ctx.text('Successful response'))
  * @see {@link https://mswjs.io/docs/api/context/text `ctx.text()`}
  */
-export declare const text: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType>;
+export declare const text: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType, any>;

package/lib/types/context/xml.d.ts

@@ -6,4 +6,4 @@ import { ResponseTransformer } from '../response';
  * res(ctx.xml('<node key="value">Content</node>'))
  * @see {@link https://mswjs.io/docs/api/context/xml `ctx.xml()`}
  */
-export declare const xml: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType>;
+export declare const xml: <BodyType extends string>(body: BodyType) => ResponseTransformer<BodyType, any>;

package/lib/types/handlers/GraphQLHandler.d.ts

@@ -1,11 +1,12 @@
 import { OperationTypeNode } from 'graphql';
-import { Mask, ResponseWithSerializedHeaders } from '../setupWorker/glossary';
+import { Mask, SerializedResponse } from '../setupWorker/glossary';
 import { set } from '../context/set';
 import { status } from '../context/status';
 import { delay } from '../context/delay';
 import { fetch } from '../context/fetch';
 import { DataContext } from '../context/data';
 import { errors } from '../context/errors';
+import { cookie } from '../context/cookie';
 import { MockedRequest, RequestHandler, ResponseResolver } from './RequestHandler';
 import { ParsedGraphQLRequest, GraphQLMultipartRequestBody } from '../utils/internal/parseGraphQLRequest';
 export declare type ExpectedOperationTypeNode = OperationTypeNode | 'all';
@@ -17,6 +18,7 @@ export declare type GraphQLContext<QueryType> = {
     fetch: typeof fetch;
     data: DataContext<QueryType>;
     errors: typeof errors;
+    cookie: typeof cookie;
 };
 export declare const graphqlContext: GraphQLContext<any>;
 export declare type GraphQLVariables = Record<string, any>;
@@ -38,5 +40,5 @@ export declare class GraphQLHandler<Request extends GraphQLRequest<any> = GraphQ
     parse(request: MockedRequest): ParsedGraphQLRequest<GraphQLVariables>;
     protected getPublicRequest(request: Request, parsedResult: ParsedGraphQLRequest): GraphQLRequest<any>;
     predicate(request: MockedRequest, parsedResult: ParsedGraphQLRequest): boolean;
-    log(request: Request, response: ResponseWithSerializedHeaders<any>): void;
+    log(request: Request, response: SerializedResponse<any>): void;
 }

package/lib/types/handlers/RequestHandler.d.ts

@@ -2,9 +2,9 @@ import { Headers } from 'headers-utils';
 import { MockedResponse, ResponseComposition } from '../response';
 import { set } from '../context/set';
 export declare const defaultContext: {
-    status: (statusCode: number, statusText?: string | undefined) => import("../response").ResponseTransformer<any>;
+    status: (statusCode: number, statusText?: string | undefined) => import("../response").ResponseTransformer<any, any>;
     set: typeof set;
-    delay: (durationOrMode?: number | import("../context/delay").DelayMode | undefined) => import("../response").ResponseTransformer<any>;
+    delay: (durationOrMode?: number | import("../context/delay").DelayMode | undefined) => import("../response").ResponseTransformer<any, any>;
     fetch: (input: string | MockedRequest<DefaultRequestBody>, requestInit?: RequestInit) => Promise<Response>;
 };
 export declare type DefaultRequestMultipartBody = Record<string, string | File | (string | File)[]>;
@@ -34,8 +34,9 @@ declare type RequestHandlerInfo<ExtraInfo extends Record<string, any>> = {
     header: string;
 } & ExtraInfo;
 declare type ContextMap = Record<string, (...args: any[]) => any>;
-export declare type ResponseResolverReturnType<R> = R | undefined | void;
-export declare type AsyncResponseResolverReturnType<R> = Promise<ResponseResolverReturnType<R>> | ResponseResolverReturnType<R>;
+export declare type ResponseResolverReturnType<ReturnType> = ReturnType | undefined | void;
+export declare type MaybeAsyncResponseResolverReturnType<ReturnType> = ResponseResolverReturnType<ReturnType> | Promise<ResponseResolverReturnType<ReturnType>>;
+export declare type AsyncResponseResolverReturnType<ReturnType> = MaybeAsyncResponseResolverReturnType<ReturnType> | Generator<MaybeAsyncResponseResolverReturnType<ReturnType>, MaybeAsyncResponseResolverReturnType<ReturnType>, MaybeAsyncResponseResolverReturnType<ReturnType>>;
 export declare type ResponseResolver<RequestType = MockedRequest, ContextType = typeof defaultContext, BodyType = any> = (req: RequestType, res: ResponseComposition<BodyType>, context: ContextType) => AsyncResponseResolverReturnType<MockedResponse<BodyType>>;
 export interface RequestHandlerOptions<HandlerInfo> {
     info: RequestHandlerInfo<HandlerInfo>;
@@ -50,8 +51,10 @@ export interface RequestHandlerExecutionResult<PublicRequestType> {
 }
 export declare abstract class RequestHandler<HandlerInfo extends Record<string, any> = Record<string, any>, Request extends MockedRequest = MockedRequest, ParsedResult = any, PublicRequest extends MockedRequest = Request> {
     info: RequestHandlerDefaultInfo & RequestHandlerInfo<HandlerInfo>;
-    private ctx;
     shouldSkip: boolean;
+    private ctx;
+    private resolverGenerator?;
+    private resolverGeneratorResult?;
     protected resolver: ResponseResolver<any, any>;
     constructor(options: RequestHandlerOptions<HandlerInfo>);
     /**
@@ -61,12 +64,12 @@ export declare abstract class RequestHandler<HandlerInfo extends Record<string,
     /**
      * Print out the successfully handled request.
      */
-    abstract log(request: Request, res: any, handler: this, parsedResult: ParsedResult): void;
+    abstract log(request: Request, response: any, handler: this, parsedResult: ParsedResult): void;
     /**
      * Parse the captured request to extract additional information from it.
      * Parsed result is then exposed to other methods of this request handler.
      */
-    parse(request: MockedRequest): ParsedResult;
+    parse(_request: MockedRequest): ParsedResult;
     /**
      * Test if this handler matches the given request.
      */
@@ -75,13 +78,14 @@ export declare abstract class RequestHandler<HandlerInfo extends Record<string,
      * Derive the publicly exposed request (`req`) instance of the response resolver
      * from the captured request and its parsed result.
      */
-    protected getPublicRequest(request: MockedRequest, parsedResult: ParsedResult): PublicRequest;
+    protected getPublicRequest(request: MockedRequest, _parsedResult: ParsedResult): PublicRequest;
     markAsSkipped(shouldSkip?: boolean): void;
     /**
      * Execute this request handler and produce a mocked response
      * using the given resolver function.
      */
     run(request: MockedRequest): Promise<RequestHandlerExecutionResult<PublicRequest> | null>;
+    private wrapResolver;
     private createExecutionResult;
 }
 export {};

package/lib/types/handlers/RestHandler.d.ts

@@ -1,6 +1,6 @@
 import { Match } from 'node-match-path';
 import { body, cookie, delay, fetch, json, set, status, text, xml } from '../context';
-import { Mask, ResponseWithSerializedHeaders } from '../setupWorker/glossary';
+import { Mask, SerializedResponse } from '../setupWorker/glossary';
 import { DefaultRequestBody, MockedRequest, RequestHandler, ResponseResolver } from './RequestHandler';
 interface RestHandlerInfo {
     method: string;
@@ -47,6 +47,6 @@ export declare class RestHandler<RequestType extends MockedRequest<DefaultReques
     parse(request: RequestType): Match;
     protected getPublicRequest(request: RequestType, parsedResult: ParsedRestRequest): RestRequest<any, RequestParams>;
     predicate(request: RequestType, parsedResult: ParsedRestRequest): boolean;
-    log(request: RequestType, response: ResponseWithSerializedHeaders<any>): void;
+    log(request: RequestType, response: SerializedResponse<any>): void;
 }
 export {};

package/lib/types/node/glossary.d.ts

@@ -1,3 +1,4 @@
+import { PartialDeep } from 'type-fest';
 import { IsomorphicResponse } from '@mswjs/interceptors';
 import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
 import { SharedOptions } from '../sharedOptions';
@@ -14,7 +15,7 @@ export interface SetupServerApi {
      * Starts requests interception based on the previously provided request handlers.
      * @see {@link https://mswjs.io/docs/api/setup-server/listen `server.listen()`}
      */
-    listen(options?: SharedOptions): void;
+    listen(options?: PartialDeep<SharedOptions>): void;
     /**
      * Stops requests interception by restoring all augmented modules.
      * @see {@link https://mswjs.io/docs/api/setup-server/close `server.close()`}

package/lib/types/response.d.ts

@@ -10,7 +10,7 @@ export interface MockedResponse<BodyType = any> {
     once: boolean;
     delay?: number;
 }
-export declare type ResponseTransformer<BodyType = any> = (res: MockedResponse<BodyType>) => MockedResponse<BodyType> | Promise<MockedResponse<BodyType>>;
+export declare type ResponseTransformer<BodyType extends TransformerBodyType = any, TransformerBodyType = any> = (res: MockedResponse<TransformerBodyType>) => MockedResponse<BodyType> | Promise<MockedResponse<BodyType>>;
 export declare type ResponseFunction<BodyType = any> = (...transformers: ResponseTransformer<BodyType>[]) => MockedResponse<BodyType> | Promise<MockedResponse<BodyType>>;
 export declare type ResponseComposition<BodyType = any> = ResponseFunction<BodyType> & {
     /**

package/lib/types/setupWorker/glossary.d.ts

@@ -1,11 +1,11 @@
-import { HeadersList } from 'headers-utils';
+import { PartialDeep } from 'type-fest';
+import { FlatHeadersObject } from 'headers-utils';
 import { StrictEventEmitter } from 'strict-event-emitter';
 import { MockedResponse } from '../response';
 import { SharedOptions } from '../sharedOptions';
 import { ServiceWorkerMessage } from '../utils/createBroadcastChannel';
-import { createStart } from './start/createStart';
-import { createStop } from './stop/createStop';
 import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
+import { InterceptorApi } from '@mswjs/interceptors';
 export declare type Mask = RegExp | string;
 export declare type ResolvedMask = Mask | URL;
 declare type RequestWithoutMethods = Omit<Request, 'text' | 'body' | 'json' | 'blob' | 'arrayBuffer' | 'formData' | 'clone' | 'signal' | 'isHistoryNavigation' | 'isReloadNavigation'>;
@@ -55,7 +55,7 @@ export interface WorkerLifecycleEventsMap {
     'response:bypass': (response: Response, requestId: string) => void;
 }
 export interface SetupWorkerInternalContext {
-    startOptions: StartOptions | undefined;
+    startOptions?: StartOptions;
     worker: ServiceWorker | null;
     registration: ServiceWorkerRegistration | null;
     requestHandlers: RequestHandler[];
@@ -83,50 +83,55 @@ export interface SetupWorkerInternalContext {
          */
         once<EventType extends keyof ServiceWorkerIncomingEventsMap>(eventType: EventType): Promise<ServiceWorkerMessage<EventType, ServiceWorkerIncomingEventsMap[EventType]>>;
     };
+    useFallbackMode: boolean;
+    fallbackInterceptor?: InterceptorApi;
 }
 export declare type ServiceWorkerInstanceTuple = [
     ServiceWorker | null,
     ServiceWorkerRegistration
 ];
 export declare type FindWorker = (scriptUrl: string, mockServiceWorkerUrl: string) => boolean;
-export declare type StartOptions = SharedOptions & {
+export interface StartOptions extends SharedOptions {
     /**
      * Service Worker instance options.
      */
-    serviceWorker?: {
-        url?: string;
-        options?: RegistrationOptions;
+    serviceWorker: {
+        url: string;
+        options: RegistrationOptions;
     };
     /**
      * Disables the logging of captured requests
      * into browser's console.
      */
-    quiet?: boolean;
+    quiet: boolean;
     /**
      * Defers any network requests until the Service Worker
      * instance is ready. Defaults to `true`.
      */
-    waitUntilReady?: boolean;
+    waitUntilReady: boolean;
     /**
      * A custom lookup function to find a Mock Service Worker in the list
      * of all registered Service Workers on the page.
      */
-    findWorker?: FindWorker;
-};
-export declare type ResponseWithSerializedHeaders<BodyType = any> = Omit<MockedResponse<BodyType>, 'headers'> & {
-    headers: HeadersList;
+    findWorker: FindWorker;
+}
+export declare type SerializedResponse<BodyType = any> = Omit<MockedResponse<BodyType>, 'headers'> & {
+    headers: FlatHeadersObject;
 };
+export declare type StartReturnType = Promise<ServiceWorkerRegistration | undefined>;
+export declare type StartHandler = (options: StartOptions, initialOptions: PartialDeep<StartOptions>) => StartReturnType;
+export declare type StopHandler = () => void;
 export interface SetupWorkerApi {
     /**
      * Registers and activates the mock Service Worker.
      * @see {@link https://mswjs.io/docs/api/setup-worker/start `worker.start()`}
      */
-    start: ReturnType<typeof createStart>;
+    start: (options?: PartialDeep<StartOptions>) => StartReturnType;
     /**
      * Stops requests interception for the current client.
      * @see {@link https://mswjs.io/docs/api/setup-worker/stop `worker.stop()`}
      */
-    stop: ReturnType<typeof createStop>;
+    stop: StopHandler;
     /**
      * Prepends given request handlers to the list of existing handlers.
      * @param {RequestHandler[]} handlers List of runtime request handlers.

package/lib/types/setupWorker/start/createFallbackStart.d.ts

@@ -0,0 +1,2 @@
+import { SetupWorkerInternalContext, StartHandler } from '../glossary';
+export declare function createFallbackStart(context: SetupWorkerInternalContext): StartHandler;

package/lib/types/setupWorker/start/createStartHandler.d.ts

@@ -0,0 +1,2 @@
+import { SetupWorkerInternalContext, StartHandler } from '../glossary';
+export declare const createStartHandler: (context: SetupWorkerInternalContext) => StartHandler;

package/lib/types/setupWorker/start/utils/enableMocking.d.ts

@@ -0,0 +1,5 @@
+import { StartOptions, SetupWorkerInternalContext } from '../../glossary';
+/**
+ * Signals the worker to enable the interception of requests.
+ */
+export declare function enableMocking(context: SetupWorkerInternalContext, options: StartOptions): Promise<void>;

package/lib/types/setupWorker/start/utils/prepareStartHandler.d.ts

@@ -0,0 +1,9 @@
+import { PartialDeep } from 'type-fest';
+import { SetupWorkerApi, SetupWorkerInternalContext, StartHandler, StartOptions } from '../../glossary';
+export declare const DEFAULT_START_OPTIONS: StartOptions;
+/**
+ * Returns resolved worker start options, merging the default options
+ * with the given custom options.
+ */
+export declare function resolveStartOptions(initialOptions?: PartialDeep<StartOptions>): StartOptions;
+export declare function prepareStartHandler(handler: StartHandler, context: SetupWorkerInternalContext): SetupWorkerApi['start'];

package/lib/types/setupWorker/start/utils/printStartMessage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prints a worker activation message in the browser's console.
+ */
+export declare function printStartMessage(args?: {
+    quiet?: boolean;
+    message?: string;
+}): void;

package/lib/types/setupWorker/start/utils/validateWorkerScope.d.ts

@@ -0,0 +1,2 @@
+import { StartOptions } from '../../glossary';
+export declare function validateWorkerScope(registration: ServiceWorkerRegistration, options?: StartOptions): void;

package/lib/types/setupWorker/stop/createFallbackStop.d.ts

@@ -0,0 +1,2 @@
+import { SetupWorkerInternalContext, StopHandler } from '../glossary';
+export declare function createFallbackStop(context: SetupWorkerInternalContext): StopHandler;

package/lib/types/setupWorker/stop/createStop.d.ts

@@ -1,2 +1,2 @@
-import { SetupWorkerInternalContext } from '../glossary';
-export declare const createStop: (context: SetupWorkerInternalContext) => () => void;
+import { SetupWorkerInternalContext, StopHandler } from '../glossary';
+export declare const createStop: (context: SetupWorkerInternalContext) => StopHandler;

package/lib/types/setupWorker/stop/utils/printStopMessage.d.ts

@@ -0,0 +1,3 @@
+export declare function printStopMessage(args?: {
+    quiet?: boolean;
+}): void;

package/lib/types/sharedOptions.d.ts

@@ -2,10 +2,11 @@ import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest';
 export interface SharedOptions {
     /**
      * Specifies how to react to a request that has no corresponding
-     * request handler. Bypasses such requests by default.
+     * request handler. Warns on unhandled requests by default.
      *
+     * @example worker.start({ onUnhandledRequest: 'bypass' })
      * @example worker.start({ onUnhandledRequest: 'warn' })
      * @example server.listen({ onUnhandledRequest: 'error' })
      */
-    onUnhandledRequest?: UnhandledRequestStrategy;
+    onUnhandledRequest: UnhandledRequestStrategy;
 }

package/lib/types/utils/getResponse.d.ts

@@ -1,6 +1,6 @@
 import { MockedResponse } from '../response';
 import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
-interface ResponsePayload {
+export interface ResponseLookupResult {
     handler?: RequestHandler;
     publicRequest?: any;
     parsedRequest?: any;
@@ -9,5 +9,4 @@ interface ResponsePayload {
 /**
  * Returns a mocked response for a given request using following request handlers.
  */
-export declare const getResponse: <Request_1 extends MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, Handler extends RequestHandler<Record<string, any>, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, any, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>>[]>(request: Request_1, handlers: Handler) => Promise<ResponsePayload>;
-export {};
+export declare const getResponse: <Request_1 extends MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, Handler extends RequestHandler<Record<string, any>, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>, any, MockedRequest<import("../handlers/RequestHandler").DefaultRequestBody>>[]>(request: Request_1, handlers: Handler) => Promise<ResponseLookupResult>;

package/lib/types/utils/handleRequest.d.ts

@@ -0,0 +1,27 @@
+import { StrictEventEmitter } from 'strict-event-emitter';
+import { MockedRequest, RequestHandler } from '../handlers/RequestHandler';
+import { ServerLifecycleEventsMap } from '../node/glossary';
+import { MockedResponse } from '../response';
+import { SharedOptions } from '../sharedOptions';
+import { ResponseLookupResult } from './getResponse';
+export interface HandleRequestOptions<ResponseType> {
+    /**
+     * Transforms a `MockedResponse` instance returned from a handler
+     * to a response instance
+     */
+    transformResponse?(response: MockedResponse<string>): ResponseType;
+    /**
+     * Invoked whenever returning a bypassed (as-is) response.
+     */
+    onBypassResponse?(request: MockedRequest): void;
+    /**
+     * Invoked when the mocked response is ready to be sent.
+     */
+    onMockedResponse?(response: ResponseType, handler: DeepRequired<ResponseLookupResult>): void;
+    /**
+     * Invoked when the mocked response is sent.
+     * Respects the response delay duration.
+     */
+    onMockedResponseSent?(response: ResponseType, handler: DeepRequired<ResponseLookupResult>): void;
+}
+export declare function handleRequest<ResponseType extends Record<string, any> = MockedResponse<string>>(request: MockedRequest, handlers: RequestHandler[], options: SharedOptions, emitter: StrictEventEmitter<ServerLifecycleEventsMap>, handleRequestOptions?: HandleRequestOptions<ResponseType>): Promise<ResponseType | undefined>;

package/lib/types/utils/internal/isIterable.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Determines if the given function is an iterator.
+ */
+export declare function isIterable<IteratorType>(fn: any): fn is Generator<IteratorType, IteratorType, IteratorType>;

package/lib/types/utils/internal/tryCatch.d.ts

@@ -0,0 +1 @@
+export declare function tryCatch<Fn extends (...args: any[]) => any>(fn: Fn, onException?: (error: Error) => void): ReturnType<Fn> | undefined;

package/lib/types/utils/logging/prepareResponse.d.ts

@@ -1,12 +1,12 @@
-import { ResponseWithSerializedHeaders } from '../../setupWorker/glossary';
+import { SerializedResponse } from '../../setupWorker/glossary';
 /**
  * Formats a mocked response for introspection in browser's console.
  */
-export declare function prepareResponse(res: ResponseWithSerializedHeaders<any>): {
+export declare function prepareResponse(res: SerializedResponse<any>): {
     body: string | Record<string, any> | undefined;
     status: number;
     statusText: string;
     once: boolean;
     delay?: number | undefined;
-    headers: import("headers-utils").HeadersList;
+    headers: import("headers-utils").FlatHeadersObject;
 };

package/lib/types/utils/request/parseIsomorphicRequest.d.ts

@@ -0,0 +1,6 @@
+import { IsomorphicRequest } from '@mswjs/interceptors';
+import { MockedRequest } from '../../handlers/RequestHandler';
+/**
+ * Converts a given isomorphic request to a `MockedRequest` instance.
+ */
+export declare function parseIsomorphicRequest(request: IsomorphicRequest): MockedRequest;

package/lib/types/utils/request/parseWorkerRequest.d.ts

@@ -1,3 +1,7 @@
 import { MockedRequest } from '../../handlers/RequestHandler';
 import { ServiceWorkerIncomingRequest } from '../../setupWorker/glossary';
+/**
+ * Converts a given request received from the Service Worker
+ * into a `MockedRequest` instance.
+ */
 export declare function parseWorkerRequest(rawRequest: ServiceWorkerIncomingRequest): MockedRequest;

package/lib/types/utils/worker/createFallbackRequestListener.d.ts

@@ -0,0 +1,3 @@
+import { InterceptorApi } from '@mswjs/interceptors';
+import { SetupWorkerInternalContext, StartOptions } from '../../setupWorker/glossary';
+export declare function createFallbackRequestListener(context: SetupWorkerInternalContext, options: StartOptions): InterceptorApi;