msw 1.3.2 → 2.0.0

package/lib/core/GraphQLHandler-b42ca96f.d.ts

@@ -0,0 +1,74 @@
+import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
+import { g as RequestHandlerDefaultInfo, D as DefaultBodyType, R as RequestHandler, a as ResponseResolver, c as RequestHandlerOptions } from './RequestHandler-1a5dbdc7.js';
+import { Path } from './utils/matching/matchRequestUrl.js';
+
+interface ParsedGraphQLQuery {
+    operationType: OperationTypeNode;
+    operationName?: string;
+}
+type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
+    query: string;
+    variables?: VariablesType;
+}) | undefined;
+declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
+type GraphQLParsedOperationsMap = Record<string, string[]>;
+type GraphQLMultipartRequestBody = {
+    operations: string;
+    map?: string;
+} & {
+    [fileName: string]: File;
+};
+/**
+ * Determines if a given request can be considered a GraphQL request.
+ * Does not parse the query and does not guarantee its validity.
+ */
+declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
+
+type ExpectedOperationTypeNode = OperationTypeNode | 'all';
+type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
+type GraphQLVariables = Record<string, any>;
+interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
+    operationType: ExpectedOperationTypeNode;
+    operationName: GraphQLHandlerNameSelector;
+}
+type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
+    query: string;
+    operationName: string;
+    variables: Variables;
+};
+type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
+interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
+    query: string;
+    variables?: Variables;
+}
+interface GraphQLResponseBody<BodyType extends DefaultBodyType> {
+    data?: BodyType;
+    errors?: readonly Partial<GraphQLError>[];
+}
+declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
+declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, ParsedGraphQLRequest, GraphQLResolverExtras<any>> {
+    private endpoint;
+    constructor(operationType: ExpectedOperationTypeNode, operationName: GraphQLHandlerNameSelector, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+    parse(args: {
+        request: Request;
+    }): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
+    predicate(args: {
+        request: Request;
+        parsedResult: ParsedGraphQLRequest;
+    }): boolean;
+    protected extendResolverArgs(args: {
+        request: Request;
+        parsedResult: ParsedGraphQLRequest<GraphQLVariables>;
+    }): {
+        query: string;
+        operationName: string;
+        variables: GraphQLVariables;
+    };
+    log(args: {
+        request: Request;
+        response: Response;
+        parsedResult: ParsedGraphQLRequest;
+    }): Promise<void>;
+}
+
+export { ExpectedOperationTypeNode as E, GraphQLHandler as G, ParsedGraphQLRequest as P, GraphQLVariables as a, GraphQLRequestBody as b, GraphQLJsonRequestBody as c, GraphQLHandlerNameSelector as d, GraphQLResolverExtras as e, GraphQLResponseBody as f, ParsedGraphQLQuery as g, GraphQLParsedOperationsMap as h, GraphQLMultipartRequestBody as i, parseGraphQLRequest as j, GraphQLHandlerInfo as k, isDocumentNode as l, parseDocumentNode as p };

package/lib/core/HttpResponse.d.ts

@@ -0,0 +1,2 @@
+export { f as HttpResponse, H as HttpResponseInit, S as StrictRequest, e as StrictResponse } from './RequestHandler-1a5dbdc7.js';
+import './typeUtils.js';

package/lib/core/HttpResponse.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var HttpResponse_exports = {};
+__export(HttpResponse_exports, {
+  HttpResponse: () => HttpResponse
+});
+module.exports = __toCommonJS(HttpResponse_exports);
+var import_decorators = require("./utils/HttpResponse/decorators.js");
+class HttpResponse extends Response {
+  constructor(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    super(body, responseInit);
+    (0, import_decorators.decorateResponse)(this, responseInit);
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "text/plain"` body.
+   * @example
+   * HttpResponse.text('hello world')
+   * HttpResponse.text('Error', { status: 500 })
+   */
+  static text(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    responseInit.headers.set("Content-Type", "text/plain");
+    return new HttpResponse(body, responseInit);
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/json"` body.
+   * @example
+   * HttpResponse.json({ firstName: 'John' })
+   * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+   */
+  static json(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    responseInit.headers.set("Content-Type", "application/json");
+    return new HttpResponse(
+      JSON.stringify(body),
+      responseInit
+    );
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/xml"` body.
+   * @example
+   * HttpResponse.xml(`<user name="John" />`)
+   * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+   */
+  static xml(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    responseInit.headers.set("Content-Type", "text/xml");
+    return new HttpResponse(body, responseInit);
+  }
+  /**
+   * Create a `Response` with an `ArrayBuffer` body.
+   * @example
+   * const buffer = new ArrayBuffer(3)
+   * const view = new Uint8Array(buffer)
+   * view.set([1, 2, 3])
+   *
+   * HttpResponse.arrayBuffer(buffer)
+   */
+  static arrayBuffer(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    if (body) {
+      responseInit.headers.set("Content-Length", body.byteLength.toString());
+    }
+    return new HttpResponse(body, responseInit);
+  }
+  /**
+   * Create a `Response` with a `FormData` body.
+   * @example
+   * const data = new FormData()
+   * data.set('name', 'Alice')
+   *
+   * HttpResponse.formData(data)
+   */
+  static formData(body, init) {
+    return new HttpResponse(body, (0, import_decorators.normalizeResponseInit)(init));
+  }
+}

package/lib/core/HttpResponse.mjs

@@ -0,0 +1,77 @@
+import {
+  decorateResponse,
+  normalizeResponseInit
+} from './utils/HttpResponse/decorators.mjs';
+class HttpResponse extends Response {
+  constructor(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    super(body, responseInit);
+    decorateResponse(this, responseInit);
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "text/plain"` body.
+   * @example
+   * HttpResponse.text('hello world')
+   * HttpResponse.text('Error', { status: 500 })
+   */
+  static text(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    responseInit.headers.set("Content-Type", "text/plain");
+    return new HttpResponse(body, responseInit);
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/json"` body.
+   * @example
+   * HttpResponse.json({ firstName: 'John' })
+   * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+   */
+  static json(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    responseInit.headers.set("Content-Type", "application/json");
+    return new HttpResponse(
+      JSON.stringify(body),
+      responseInit
+    );
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/xml"` body.
+   * @example
+   * HttpResponse.xml(`<user name="John" />`)
+   * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+   */
+  static xml(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    responseInit.headers.set("Content-Type", "text/xml");
+    return new HttpResponse(body, responseInit);
+  }
+  /**
+   * Create a `Response` with an `ArrayBuffer` body.
+   * @example
+   * const buffer = new ArrayBuffer(3)
+   * const view = new Uint8Array(buffer)
+   * view.set([1, 2, 3])
+   *
+   * HttpResponse.arrayBuffer(buffer)
+   */
+  static arrayBuffer(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    if (body) {
+      responseInit.headers.set("Content-Length", body.byteLength.toString());
+    }
+    return new HttpResponse(body, responseInit);
+  }
+  /**
+   * Create a `Response` with a `FormData` body.
+   * @example
+   * const data = new FormData()
+   * data.set('name', 'Alice')
+   *
+   * HttpResponse.formData(data)
+   */
+  static formData(body, init) {
+    return new HttpResponse(body, normalizeResponseInit(init));
+  }
+}
+export {
+  HttpResponse
+};

package/lib/core/RequestHandler-1a5dbdc7.d.ts

@@ -0,0 +1,172 @@
+import { MaybePromise } from './typeUtils.js';
+
+interface ResponseLookupResult {
+    handler: RequestHandler;
+    parsedResult?: any;
+    response?: Response;
+}
+interface ResponseResolutionContext {
+    baseUrl?: string;
+}
+/**
+ * Returns a mocked response for a given request using following request handlers.
+ */
+declare const getResponse: <Handler extends RequestHandler<RequestHandlerDefaultInfo, any, any, RequestHandlerOptions>[]>(request: Request, handlers: Handler, resolutionContext?: ResponseResolutionContext) => Promise<ResponseLookupResult | null>;
+
+interface HttpResponseInit extends ResponseInit {
+    type?: ResponseType;
+}
+declare const bodyType: unique symbol;
+interface StrictRequest<BodyType extends DefaultBodyType> extends Request {
+    json(): Promise<BodyType>;
+}
+/**
+ * Opaque `Response` type that supports strict body type.
+ */
+interface StrictResponse<BodyType extends DefaultBodyType> extends Response {
+    readonly [bodyType]: BodyType;
+}
+/**
+ * A drop-in replacement for the standard `Response` class
+ * to allow additional features, like mocking the response `Set-Cookie` header.
+ *
+ * @example
+ * new HttpResponse('Hello world', { status: 201 })
+ * HttpResponse.json({ name: 'John' })
+ * HttpResponse.formData(form)
+ *
+ * @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
+ */
+declare class HttpResponse extends Response {
+    constructor(body?: BodyInit | null, init?: HttpResponseInit);
+    /**
+     * Create a `Response` with a `Content-Type: "text/plain"` body.
+     * @example
+     * HttpResponse.text('hello world')
+     * HttpResponse.text('Error', { status: 500 })
+     */
+    static text<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): StrictResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "application/json"` body.
+     * @example
+     * HttpResponse.json({ firstName: 'John' })
+     * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+     */
+    static json<BodyType extends DefaultBodyType>(body?: BodyType | null, init?: HttpResponseInit): StrictResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "application/xml"` body.
+     * @example
+     * HttpResponse.xml(`<user name="John" />`)
+     * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+     */
+    static xml<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): Response;
+    /**
+     * Create a `Response` with an `ArrayBuffer` body.
+     * @example
+     * const buffer = new ArrayBuffer(3)
+     * const view = new Uint8Array(buffer)
+     * view.set([1, 2, 3])
+     *
+     * HttpResponse.arrayBuffer(buffer)
+     */
+    static arrayBuffer(body?: ArrayBuffer, init?: HttpResponseInit): Response;
+    /**
+     * Create a `Response` with a `FormData` body.
+     * @example
+     * const data = new FormData()
+     * data.set('name', 'Alice')
+     *
+     * HttpResponse.formData(data)
+     */
+    static formData(body?: FormData, init?: HttpResponseInit): Response;
+}
+
+type DefaultRequestMultipartBody = Record<string, string | File | Array<string | File>>;
+type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;
+interface RequestHandlerDefaultInfo {
+    header: string;
+}
+interface RequestHandlerInternalInfo {
+    callFrame?: string;
+}
+type ResponseResolverReturnType<BodyType extends DefaultBodyType = undefined> = (BodyType extends undefined ? Response : StrictResponse<BodyType>) | undefined | void;
+type MaybeAsyncResponseResolverReturnType<BodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<BodyType>>;
+type AsyncResponseResolverReturnType<BodyType extends DefaultBodyType> = MaybeAsyncResponseResolverReturnType<BodyType> | Generator<MaybeAsyncResponseResolverReturnType<BodyType>, MaybeAsyncResponseResolverReturnType<BodyType>, MaybeAsyncResponseResolverReturnType<BodyType>>;
+type ResponseResolverInfo<ResolverExtraInfo extends Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType> = {
+    request: StrictRequest<RequestBodyType>;
+} & ResolverExtraInfo;
+type ResponseResolver<ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>) => AsyncResponseResolverReturnType<ResponseBodyType>;
+interface RequestHandlerArgs<HandlerInfo, HandlerOptions extends RequestHandlerOptions> {
+    info: HandlerInfo;
+    resolver: ResponseResolver<any>;
+    options?: HandlerOptions;
+}
+interface RequestHandlerOptions {
+    once?: boolean;
+}
+interface RequestHandlerExecutionResult<ParsedResult extends Record<string, unknown> | undefined> {
+    handler: RequestHandler;
+    parsedResult?: ParsedResult;
+    request: Request;
+    response?: Response;
+}
+declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, ParsedResult extends Record<string, any> | undefined = any, ResolverExtras extends Record<string, unknown> = any, HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions> {
+    info: HandlerInfo & RequestHandlerInternalInfo;
+    /**
+     * Indicates whether this request handler has been used
+     * (its resolver has successfully executed).
+     */
+    isUsed: boolean;
+    protected resolver: ResponseResolver<ResolverExtras, any, any>;
+    private resolverGenerator?;
+    private resolverGeneratorResult?;
+    private options?;
+    constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>);
+    /**
+     * Determine if the intercepted request should be mocked.
+     */
+    abstract predicate(args: {
+        request: Request;
+        parsedResult: ParsedResult;
+        resolutionContext?: ResponseResolutionContext;
+    }): boolean;
+    /**
+     * Print out the successfully handled request.
+     */
+    abstract log(args: {
+        request: Request;
+        response: Response;
+        parsedResult: ParsedResult;
+    }): void;
+    /**
+     * Parse the intercepted request to extract additional information from it.
+     * Parsed result is then exposed to other methods of this request handler.
+     */
+    parse(_args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<ParsedResult>;
+    /**
+     * Test if this handler matches the given request.
+     */
+    test(args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<boolean>;
+    protected extendResolverArgs(_args: {
+        request: Request;
+        parsedResult: ParsedResult;
+    }): ResolverExtras;
+    /**
+     * Execute this request handler and produce a mocked response
+     * using the given resolver function.
+     */
+    run(args: {
+        request: StrictRequest<any>;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<RequestHandlerExecutionResult<ParsedResult> | null>;
+    private wrapResolver;
+    private createExecutionResult;
+}
+
+export { AsyncResponseResolverReturnType as A, DefaultBodyType as D, HttpResponseInit as H, MaybeAsyncResponseResolverReturnType as M, RequestHandler as R, StrictRequest as S, ResponseResolver as a, ResponseResolverReturnType as b, RequestHandlerOptions as c, DefaultRequestMultipartBody as d, StrictResponse as e, HttpResponse as f, RequestHandlerDefaultInfo as g, ResponseLookupResult as h, ResponseResolutionContext as i, getResponse as j, RequestHandlerInternalInfo as k, ResponseResolverInfo as l, RequestHandlerArgs as m, RequestHandlerExecutionResult as n };

package/lib/core/SetupApi.d.ts

@@ -0,0 +1,26 @@
+import { EventMap, Emitter } from 'strict-event-emitter';
+import { R as RequestHandler, g as RequestHandlerDefaultInfo } from './RequestHandler-1a5dbdc7.js';
+import { LifeCycleEventEmitter } from './sharedOptions.js';
+import { Disposable } from './utils/internal/Disposable.js';
+import './typeUtils.js';
+import './utils/request/onUnhandledRequest.js';
+
+/**
+ * Generic class for the mock API setup.
+ */
+declare abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
+    protected initialHandlers: ReadonlyArray<RequestHandler>;
+    protected currentHandlers: Array<RequestHandler>;
+    protected readonly emitter: Emitter<EventsMap>;
+    protected readonly publicEmitter: Emitter<EventsMap>;
+    readonly events: LifeCycleEventEmitter<EventsMap>;
+    constructor(...initialHandlers: Array<RequestHandler>);
+    private validateHandlers;
+    use(...runtimeHandlers: Array<RequestHandler>): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: Array<RequestHandler>): void;
+    listHandlers(): ReadonlyArray<RequestHandler<RequestHandlerDefaultInfo, any, any>>;
+    private createLifeCycleEvents;
+}
+
+export { SetupApi };

package/lib/core/SetupApi.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SetupApi_exports = {};
+__export(SetupApi_exports, {
+  SetupApi: () => SetupApi
+});
+module.exports = __toCommonJS(SetupApi_exports);
+var import_outvariant = require("outvariant");
+var import_strict_event_emitter = require("strict-event-emitter");
+var import_devUtils = require("./utils/internal/devUtils.js");
+var import_pipeEvents = require("./utils/internal/pipeEvents.js");
+var import_toReadonlyArray = require("./utils/internal/toReadonlyArray.js");
+var import_Disposable = require("./utils/internal/Disposable.js");
+class SetupApi extends import_Disposable.Disposable {
+  constructor(...initialHandlers) {
+    super();
+    this.validateHandlers(...initialHandlers);
+    this.initialHandlers = (0, import_toReadonlyArray.toReadonlyArray)(initialHandlers);
+    this.currentHandlers = [...initialHandlers];
+    this.emitter = new import_strict_event_emitter.Emitter();
+    this.publicEmitter = new import_strict_event_emitter.Emitter();
+    (0, import_pipeEvents.pipeEvents)(this.emitter, this.publicEmitter);
+    this.events = this.createLifeCycleEvents();
+    this.subscriptions.push(() => {
+      this.emitter.removeAllListeners();
+      this.publicEmitter.removeAllListeners();
+    });
+  }
+  validateHandlers(...handlers) {
+    for (const handler of handlers) {
+      (0, import_outvariant.invariant)(
+        !Array.isArray(handler),
+        import_devUtils.devUtils.formatMessage(
+          'Failed to construct "%s" given an Array of request handlers. Make sure you spread the request handlers when calling the respective setup function.'
+        ),
+        this.constructor.name
+      );
+    }
+  }
+  use(...runtimeHandlers) {
+    this.currentHandlers.unshift(...runtimeHandlers);
+  }
+  restoreHandlers() {
+    this.currentHandlers.forEach((handler) => {
+      handler.isUsed = false;
+    });
+  }
+  resetHandlers(...nextHandlers) {
+    this.currentHandlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
+  }
+  listHandlers() {
+    return (0, import_toReadonlyArray.toReadonlyArray)(this.currentHandlers);
+  }
+  createLifeCycleEvents() {
+    return {
+      on: (...args) => {
+        return this.publicEmitter.on(...args);
+      },
+      removeListener: (...args) => {
+        return this.publicEmitter.removeListener(...args);
+      },
+      removeAllListeners: (...args) => {
+        return this.publicEmitter.removeAllListeners(...args);
+      }
+    };
+  }
+}

package/lib/core/SetupApi.mjs

@@ -0,0 +1,63 @@
+import { invariant } from "outvariant";
+import { Emitter } from "strict-event-emitter";
+import { devUtils } from './utils/internal/devUtils.mjs';
+import { pipeEvents } from './utils/internal/pipeEvents.mjs';
+import { toReadonlyArray } from './utils/internal/toReadonlyArray.mjs';
+import { Disposable } from './utils/internal/Disposable.mjs';
+class SetupApi extends Disposable {
+  constructor(...initialHandlers) {
+    super();
+    this.validateHandlers(...initialHandlers);
+    this.initialHandlers = toReadonlyArray(initialHandlers);
+    this.currentHandlers = [...initialHandlers];
+    this.emitter = new Emitter();
+    this.publicEmitter = new Emitter();
+    pipeEvents(this.emitter, this.publicEmitter);
+    this.events = this.createLifeCycleEvents();
+    this.subscriptions.push(() => {
+      this.emitter.removeAllListeners();
+      this.publicEmitter.removeAllListeners();
+    });
+  }
+  validateHandlers(...handlers) {
+    for (const handler of handlers) {
+      invariant(
+        !Array.isArray(handler),
+        devUtils.formatMessage(
+          'Failed to construct "%s" given an Array of request handlers. Make sure you spread the request handlers when calling the respective setup function.'
+        ),
+        this.constructor.name
+      );
+    }
+  }
+  use(...runtimeHandlers) {
+    this.currentHandlers.unshift(...runtimeHandlers);
+  }
+  restoreHandlers() {
+    this.currentHandlers.forEach((handler) => {
+      handler.isUsed = false;
+    });
+  }
+  resetHandlers(...nextHandlers) {
+    this.currentHandlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
+  }
+  listHandlers() {
+    return toReadonlyArray(this.currentHandlers);
+  }
+  createLifeCycleEvents() {
+    return {
+      on: (...args) => {
+        return this.publicEmitter.on(...args);
+      },
+      removeListener: (...args) => {
+        return this.publicEmitter.removeListener(...args);
+      },
+      removeAllListeners: (...args) => {
+        return this.publicEmitter.removeAllListeners(...args);
+      }
+    };
+  }
+}
+export {
+  SetupApi
+};

package/lib/core/bypass.d.ts

@@ -0,0 +1,16 @@
+type BypassRequestInput = string | URL | Request;
+/**
+ * Creates a `Request` instance that will always be ignored by MSW.
+ *
+ * @example
+ * import { bypass } from 'msw'
+ *
+ * fetch(bypass('/resource'))
+ * fetch(bypass(new URL('/resource', 'https://example.com)))
+ * fetch(bypass(new Request('https://example.com/resource')))
+ *
+ * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
+ */
+declare function bypass(input: BypassRequestInput, init?: RequestInit): Request;
+
+export { BypassRequestInput, bypass };

package/lib/core/bypass.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bypass_exports = {};
+__export(bypass_exports, {
+  bypass: () => bypass
+});
+module.exports = __toCommonJS(bypass_exports);
+var import_outvariant = require("outvariant");
+function bypass(input, init) {
+  const request = input instanceof Request ? input : new Request(input, init);
+  (0, import_outvariant.invariant)(
+    !request.bodyUsed,
+    'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
+    request.method,
+    request.url
+  );
+  const requestClone = request.clone();
+  requestClone.headers.set("x-msw-intention", "bypass");
+  return requestClone;
+}

package/lib/core/bypass.mjs

@@ -0,0 +1,16 @@
+import { invariant } from "outvariant";
+function bypass(input, init) {
+  const request = input instanceof Request ? input : new Request(input, init);
+  invariant(
+    !request.bodyUsed,
+    'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
+    request.method,
+    request.url
+  );
+  const requestClone = request.clone();
+  requestClone.headers.set("x-msw-intention", "bypass");
+  return requestClone;
+}
+export {
+  bypass
+};