msw 0.0.0-fetch.rc-15 → 0.0.0-fetch.rc-16

package/README.md

@@ -71,12 +71,12 @@ In-browser usage is what sets Mock Service Worker apart from other tools. Utiliz
 ```js
 // src/mocks.js
 // 1. Import the library.
-import { rest, HttpResponse } from 'msw'
+import { http, HttpResponse } from 'msw'
 import { setupWorker } from 'msw/browser'
 
 // 2. Describe network behavior with request handlers.
 const worker = setupWorker(
-  rest.get('https://github.com/octocat', ({ request, params, cookies }) => {
+  http.get('https://github.com/octocat', ({ request, params, cookies }) => {
     return HttpResponse.json(
       {
         message: 'Mocked response',
@@ -121,7 +121,7 @@ Take a look at the example of an integration test in Jest that uses [React Testi
 // test/Dashboard.test.js
 
 import React from 'react'
-import { rest, HttpResponse } from 'msw'
+import { http, HttpResponse } from 'msw'
 import { setupServer } from 'msw/node'
 import { render, screen, waitFor } from '@testing-library/react'
 import Dashboard from '../src/components/Dashboard'
@@ -130,7 +130,7 @@ const server = setupServer(
   // Describe network behavior with request handlers.
   // Tip: move the handlers into their own module and
   // import it across your browser and Node.js setups!
-  rest.get('/posts', ({ request, params, cookies }) => {
+  http.get('/posts', ({ request, params, cookies }) => {
     return HttpResponse.json([
       {
         id: 'f8dd058f-9006-4174-8d49-e3086bc39c21',

package/lib/browser/index.d.ts

@@ -68,11 +68,6 @@ interface SetupWorker {
      * @see {@link https://mswjs.io/docs/api/setup-worker/list-handlers `worker.listHandlers()`}
      */
     listHandlers(): ReadonlyArray<RequestHandler<RequestHandlerDefaultInfo, any>>;
-    /**
-     * Lists all active request handlers.
-     * @see {@link https://mswjs.io/docs/api/setup-worker/print-handlers `worker.printHandlers()`}
-     */
-    printHandlers: () => void;
     events: LifeCycleEventEmitter<LifeCycleEventsMap>;
 }
 
@@ -84,7 +79,6 @@ declare class SetupWorkerApi extends SetupApi<LifeCycleEventsMap> implements Set
     constructor(...handlers: Array<RequestHandler>);
     private createWorkerContext;
     start(options?: StartOptions): StartReturnType;
-    printHandlers(): void;
     stop(): void;
 }
 /**

package/lib/browser/index.js

@@ -276,7 +276,7 @@ var createRequestListener = (context, options) => {
                 responseStream ? [responseStream] : void 0
               );
               if (!options.quiet) {
-                context.emitter.once("response:mocked", (response2) => {
+                context.emitter.once("response:mocked", ({ response: response2 }) => {
                   handler.log(requestCloneForLogs, response2, parsedRequest);
                 });
               }
@@ -363,25 +363,18 @@ function createResponseListener(context) {
       return;
     }
     const response = responseJson.status === 0 ? Response.error() : new Response(responseJson.body, responseJson);
-    if (responseJson.isMockedResponse) {
-      context.emitter.emit(
-        "response:mocked",
+    context.emitter.emit(
+      responseJson.isMockedResponse ? "response:mocked" : "response:bypass",
+      {
         response,
         /**
          * @todo @fixme In this context, we don't know anything about
          * the request.
          */
-        null,
-        responseJson.requestId
-      );
-    } else {
-      context.emitter.emit(
-        "response:bypass",
-        response,
-        null,
-        responseJson.requestId
-      );
-    }
+        request: null,
+        requestId: responseJson.requestId
+      }
+    );
   };
 }
 
@@ -554,7 +547,7 @@ function createFallbackRequestListener(context, options) {
       {
         onMockedResponse(_, { handler, parsedRequest }) {
           if (!options.quiet) {
-            context.emitter.once("response:mocked", (response2) => {
+            context.emitter.once("response:mocked", ({ response: response2 }) => {
               handler.log(requestCloneForLogs, response2, parsedRequest);
             });
           }
@@ -570,9 +563,11 @@ function createFallbackRequestListener(context, options) {
     ({ response, isMockedResponse, request, requestId }) => {
       context.emitter.emit(
         isMockedResponse ? "response:mocked" : "response:bypass",
-        response,
-        request,
-        requestId
+        {
+          response,
+          request,
+          requestId
+        }
       );
     }
   );
@@ -722,19 +717,6 @@ var SetupWorkerApi = class extends import_SetupApi.SetupApi {
       return yield this.startHandler(this.context.startOptions, options);
     });
   }
-  printHandlers() {
-    const handlers = this.listHandlers();
-    handlers.forEach((handler) => {
-      const { header, callFrame } = handler.info;
-      const pragma = handler.info.hasOwnProperty("operationType") ? "[graphql]" : "[rest]";
-      console.groupCollapsed(`${pragma} ${header}`);
-      if (callFrame) {
-        console.log(`Declaration: ${callFrame}`);
-      }
-      console.log("Handler:", handler);
-      console.groupEnd();
-    });
-  }
   stop() {
     super.dispose();
     this.context.events.removeAllListeners();

package/lib/browser/index.mjs

@@ -252,7 +252,7 @@ var createRequestListener = (context, options) => {
                 responseStream ? [responseStream] : void 0
               );
               if (!options.quiet) {
-                context.emitter.once("response:mocked", (response2) => {
+                context.emitter.once("response:mocked", ({ response: response2 }) => {
                   handler.log(requestCloneForLogs, response2, parsedRequest);
                 });
               }
@@ -339,25 +339,18 @@ function createResponseListener(context) {
       return;
     }
     const response = responseJson.status === 0 ? Response.error() : new Response(responseJson.body, responseJson);
-    if (responseJson.isMockedResponse) {
-      context.emitter.emit(
-        "response:mocked",
+    context.emitter.emit(
+      responseJson.isMockedResponse ? "response:mocked" : "response:bypass",
+      {
         response,
         /**
          * @todo @fixme In this context, we don't know anything about
          * the request.
          */
-        null,
-        responseJson.requestId
-      );
-    } else {
-      context.emitter.emit(
-        "response:bypass",
-        response,
-        null,
-        responseJson.requestId
-      );
-    }
+        request: null,
+        requestId: responseJson.requestId
+      }
+    );
   };
 }
 
@@ -532,7 +525,7 @@ function createFallbackRequestListener(context, options) {
       {
         onMockedResponse(_, { handler, parsedRequest }) {
           if (!options.quiet) {
-            context.emitter.once("response:mocked", (response2) => {
+            context.emitter.once("response:mocked", ({ response: response2 }) => {
               handler.log(requestCloneForLogs, response2, parsedRequest);
             });
           }
@@ -548,9 +541,11 @@ function createFallbackRequestListener(context, options) {
     ({ response, isMockedResponse, request, requestId }) => {
       context.emitter.emit(
         isMockedResponse ? "response:mocked" : "response:bypass",
-        response,
-        request,
-        requestId
+        {
+          response,
+          request,
+          requestId
+        }
       );
     }
   );
@@ -700,19 +695,6 @@ var SetupWorkerApi = class extends SetupApi {
       return yield this.startHandler(this.context.startOptions, options);
     });
   }
-  printHandlers() {
-    const handlers = this.listHandlers();
-    handlers.forEach((handler) => {
-      const { header, callFrame } = handler.info;
-      const pragma = handler.info.hasOwnProperty("operationType") ? "[graphql]" : "[rest]";
-      console.groupCollapsed(`${pragma} ${header}`);
-      if (callFrame) {
-        console.log(`Declaration: ${callFrame}`);
-      }
-      console.log("Handler:", handler);
-      console.groupEnd();
-    });
-  }
   stop() {
     super.dispose();
     this.context.events.removeAllListeners();

package/lib/core/NetworkError.d.ts

@@ -3,9 +3,9 @@
  * processing a request.
  *
  * @example
- * import { rest, NetworkError } from 'msw'
+ * import { http, NetworkError } from 'msw'
  *
- * rest.get('/user', () => {
+ * http.get('/user', () => {
  *   throw new NetworkError('Failed to fetch')
  * })
  */

package/lib/core/SetupApi.d.ts

@@ -21,7 +21,6 @@ declare abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
     resetHandlers(...nextHandlers: Array<RequestHandler>): void;
     listHandlers(): ReadonlyArray<RequestHandler<RequestHandlerDefaultInfo, any, any>>;
     private createLifeCycleEvents;
-    abstract printHandlers(): void;
 }
 
 export { SetupApi };

package/lib/core/handlers/{RestHandler.d.ts → HttpHandler.d.ts}

@@ -2,12 +2,12 @@ import { g as RequestHandlerDefaultInfo, R as RequestHandler, a as ResponseResol
 import { Path, Match, PathParams } from '../utils/matching/matchRequestUrl.js';
 import '../typeUtils.js';
 
-type RestHandlerMethod = string | RegExp;
-interface RestHandlerInfo extends RequestHandlerDefaultInfo {
-    method: RestHandlerMethod;
+type HttpHandlerMethod = string | RegExp;
+interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
+    method: HttpHandlerMethod;
     path: Path;
 }
-declare enum RESTMethods {
+declare enum HttpMethods {
     HEAD = "HEAD",
     GET = "GET",
     POST = "POST",
@@ -19,32 +19,32 @@ declare enum RESTMethods {
 type RequestQuery = {
     [queryName: string]: string;
 };
-type RestRequestParsedResult = {
+type HttpRequestParsedResult = {
     match: Match;
     cookies: Record<string, string>;
 };
-type RestRequestResolverExtras<Params extends PathParams> = {
+type HttpRequestResolverExtras<Params extends PathParams> = {
     params: Params;
     cookies: Record<string, string | Array<string>>;
 };
 /**
- * Request handler for REST API requests.
+ * Request handler for HTTP requests.
  * Provides request matching based on method and URL.
  */
-declare class RestHandler extends RequestHandler<RestHandlerInfo, RestRequestParsedResult, RestRequestResolverExtras<any>> {
-    constructor(method: RestHandlerMethod, path: Path, resolver: ResponseResolver<RestRequestResolverExtras<any>, any, any>, options?: RequestHandlerPublicOptions);
+declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
+    constructor(method: HttpHandlerMethod, path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerPublicOptions);
     private checkRedundantQueryParameters;
     parse(request: Request, resolutionContext?: ResponseResolutionContext): Promise<{
         match: Match;
         cookies: Record<string, string>;
     }>;
-    predicate(request: Request, parsedResult: RestRequestParsedResult): boolean;
+    predicate(request: Request, parsedResult: HttpRequestParsedResult): boolean;
     private matchMethod;
-    protected extendInfo(_request: Request, parsedResult: RestRequestParsedResult): {
+    protected extendInfo(_request: Request, parsedResult: HttpRequestParsedResult): {
         params: PathParams<string>;
         cookies: Record<string, string>;
     };
     log(request: Request, response: Response): Promise<void>;
 }
 
-export { RESTMethods, RequestQuery, RestHandler, RestHandlerInfo, RestRequestParsedResult, RestRequestResolverExtras };
+export { HttpHandler, HttpHandlerInfo, HttpMethods, HttpRequestParsedResult, HttpRequestResolverExtras, RequestQuery };

package/lib/core/handlers/{RestHandler.js → HttpHandler.js}

@@ -36,12 +36,12 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-var RestHandler_exports = {};
-__export(RestHandler_exports, {
-  RESTMethods: () => RESTMethods,
-  RestHandler: () => RestHandler
+var HttpHandler_exports = {};
+__export(HttpHandler_exports, {
+  HttpHandler: () => HttpHandler,
+  HttpMethods: () => HttpMethods
 });
-module.exports = __toCommonJS(RestHandler_exports);
+module.exports = __toCommonJS(HttpHandler_exports);
 var import_devUtils = require("../utils/internal/devUtils.js");
 var import_isStringEqual = require("../utils/internal/isStringEqual.js");
 var import_getStatusCodeColor = require("../utils/logging/getStatusCodeColor.js");
@@ -53,17 +53,17 @@ var import_getPublicUrlFromRequest = require("../utils/request/getPublicUrlFromR
 var import_getRequestCookies = require("../utils/request/getRequestCookies.js");
 var import_cleanUrl = require("../utils/url/cleanUrl.js");
 var import_RequestHandler = require("./RequestHandler.js");
-var RESTMethods = /* @__PURE__ */ ((RESTMethods2) => {
-  RESTMethods2["HEAD"] = "HEAD";
-  RESTMethods2["GET"] = "GET";
-  RESTMethods2["POST"] = "POST";
-  RESTMethods2["PUT"] = "PUT";
-  RESTMethods2["PATCH"] = "PATCH";
-  RESTMethods2["OPTIONS"] = "OPTIONS";
-  RESTMethods2["DELETE"] = "DELETE";
-  return RESTMethods2;
-})(RESTMethods || {});
-class RestHandler extends import_RequestHandler.RequestHandler {
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["HEAD"] = "HEAD";
+  HttpMethods2["GET"] = "GET";
+  HttpMethods2["POST"] = "POST";
+  HttpMethods2["PUT"] = "PUT";
+  HttpMethods2["PATCH"] = "PATCH";
+  HttpMethods2["OPTIONS"] = "OPTIONS";
+  HttpMethods2["DELETE"] = "DELETE";
+  return HttpMethods2;
+})(HttpMethods || {});
+class HttpHandler extends import_RequestHandler.RequestHandler {
   constructor(method, path, resolver, options) {
     super({
       info: {

package/lib/core/handlers/{RestHandler.mjs → HttpHandler.mjs}

@@ -33,17 +33,17 @@ import { cleanUrl, getSearchParams } from '../utils/url/cleanUrl.mjs';
 import {
   RequestHandler
 } from './RequestHandler.mjs';
-var RESTMethods = /* @__PURE__ */ ((RESTMethods2) => {
-  RESTMethods2["HEAD"] = "HEAD";
-  RESTMethods2["GET"] = "GET";
-  RESTMethods2["POST"] = "POST";
-  RESTMethods2["PUT"] = "PUT";
-  RESTMethods2["PATCH"] = "PATCH";
-  RESTMethods2["OPTIONS"] = "OPTIONS";
-  RESTMethods2["DELETE"] = "DELETE";
-  return RESTMethods2;
-})(RESTMethods || {});
-class RestHandler extends RequestHandler {
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["HEAD"] = "HEAD";
+  HttpMethods2["GET"] = "GET";
+  HttpMethods2["POST"] = "POST";
+  HttpMethods2["PUT"] = "PUT";
+  HttpMethods2["PATCH"] = "PATCH";
+  HttpMethods2["OPTIONS"] = "OPTIONS";
+  HttpMethods2["DELETE"] = "DELETE";
+  return HttpMethods2;
+})(HttpMethods || {});
+class HttpHandler extends RequestHandler {
   constructor(method, path, resolver, options) {
     super({
       info: {
@@ -127,6 +127,6 @@ class RestHandler extends RequestHandler {
   }
 }
 export {
-  RESTMethods,
-  RestHandler
+  HttpHandler,
+  HttpMethods
 };

package/lib/core/{rest.d.ts → http.d.ts}

@@ -1,17 +1,17 @@
 import { D as DefaultBodyType, a as ResponseResolver, f as RequestHandlerPublicOptions } from './RequestHandler-e964183f.js';
-import { RestRequestResolverExtras, RestHandler } from './handlers/RestHandler.js';
+import { HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
 import { PathParams, Path } from './utils/matching/matchRequestUrl.js';
 import './typeUtils.js';
 
-declare const rest: {
-    all: <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>, options?: RequestHandlerPublicOptions) => RestHandler;
-    head: <Params_1 extends PathParams<keyof Params_1> = PathParams, RequestBodyType_1 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_1 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_1>, RequestBodyType_1, ResponseBodyType_1>, options?: RequestHandlerPublicOptions) => RestHandler;
-    get: <Params_2 extends PathParams<keyof Params_2> = PathParams, RequestBodyType_2 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_2 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_2>, RequestBodyType_2, ResponseBodyType_2>, options?: RequestHandlerPublicOptions) => RestHandler;
-    post: <Params_3 extends PathParams<keyof Params_3> = PathParams, RequestBodyType_3 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_3 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_3>, RequestBodyType_3, ResponseBodyType_3>, options?: RequestHandlerPublicOptions) => RestHandler;
-    put: <Params_4 extends PathParams<keyof Params_4> = PathParams, RequestBodyType_4 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_4 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_4>, RequestBodyType_4, ResponseBodyType_4>, options?: RequestHandlerPublicOptions) => RestHandler;
-    delete: <Params_5 extends PathParams<keyof Params_5> = PathParams, RequestBodyType_5 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_5 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_5>, RequestBodyType_5, ResponseBodyType_5>, options?: RequestHandlerPublicOptions) => RestHandler;
-    patch: <Params_6 extends PathParams<keyof Params_6> = PathParams, RequestBodyType_6 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_6 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_6>, RequestBodyType_6, ResponseBodyType_6>, options?: RequestHandlerPublicOptions) => RestHandler;
-    options: <Params_7 extends PathParams<keyof Params_7> = PathParams, RequestBodyType_7 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_7 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<RestRequestResolverExtras<Params_7>, RequestBodyType_7, ResponseBodyType_7>, options?: RequestHandlerPublicOptions) => RestHandler;
+declare const http: {
+    all: <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    head: <Params_1 extends PathParams<keyof Params_1> = PathParams, RequestBodyType_1 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_1 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_1>, RequestBodyType_1, ResponseBodyType_1>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    get: <Params_2 extends PathParams<keyof Params_2> = PathParams, RequestBodyType_2 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_2 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_2>, RequestBodyType_2, ResponseBodyType_2>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    post: <Params_3 extends PathParams<keyof Params_3> = PathParams, RequestBodyType_3 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_3 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_3>, RequestBodyType_3, ResponseBodyType_3>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    put: <Params_4 extends PathParams<keyof Params_4> = PathParams, RequestBodyType_4 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_4 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_4>, RequestBodyType_4, ResponseBodyType_4>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    delete: <Params_5 extends PathParams<keyof Params_5> = PathParams, RequestBodyType_5 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_5 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_5>, RequestBodyType_5, ResponseBodyType_5>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    patch: <Params_6 extends PathParams<keyof Params_6> = PathParams, RequestBodyType_6 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_6 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_6>, RequestBodyType_6, ResponseBodyType_6>, options?: RequestHandlerPublicOptions) => HttpHandler;
+    options: <Params_7 extends PathParams<keyof Params_7> = PathParams, RequestBodyType_7 extends DefaultBodyType = DefaultBodyType, ResponseBodyType_7 extends DefaultBodyType = undefined>(path: Path, resolver: ResponseResolver<HttpRequestResolverExtras<Params_7>, RequestBodyType_7, ResponseBodyType_7>, options?: RequestHandlerPublicOptions) => HttpHandler;
 };
 
-export { rest };
+export { http };

package/lib/core/{rest.js → http.js}

@@ -16,24 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rest_exports = {};
-__export(rest_exports, {
-  rest: () => rest
+var http_exports = {};
+__export(http_exports, {
+  http: () => http
 });
-module.exports = __toCommonJS(rest_exports);
-var import_RestHandler = require("./handlers/RestHandler.js");
-function createRestHandler(method) {
+module.exports = __toCommonJS(http_exports);
+var import_HttpHandler = require("./handlers/HttpHandler.js");
+function createHttpHandler(method) {
   return (path, resolver, options = {}) => {
-    return new import_RestHandler.RestHandler(method, path, resolver, options);
+    return new import_HttpHandler.HttpHandler(method, path, resolver, options);
   };
 }
-const rest = {
-  all: createRestHandler(/.+/),
-  head: createRestHandler(import_RestHandler.RESTMethods.HEAD),
-  get: createRestHandler(import_RestHandler.RESTMethods.GET),
-  post: createRestHandler(import_RestHandler.RESTMethods.POST),
-  put: createRestHandler(import_RestHandler.RESTMethods.PUT),
-  delete: createRestHandler(import_RestHandler.RESTMethods.DELETE),
-  patch: createRestHandler(import_RestHandler.RESTMethods.PATCH),
-  options: createRestHandler(import_RestHandler.RESTMethods.OPTIONS)
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(import_HttpHandler.HttpMethods.HEAD),
+  get: createHttpHandler(import_HttpHandler.HttpMethods.GET),
+  post: createHttpHandler(import_HttpHandler.HttpMethods.POST),
+  put: createHttpHandler(import_HttpHandler.HttpMethods.PUT),
+  delete: createHttpHandler(import_HttpHandler.HttpMethods.DELETE),
+  patch: createHttpHandler(import_HttpHandler.HttpMethods.PATCH),
+  options: createHttpHandler(import_HttpHandler.HttpMethods.OPTIONS)
 };

package/lib/core/http.mjs

@@ -0,0 +1,22 @@
+import {
+  HttpMethods,
+  HttpHandler
+} from './handlers/HttpHandler.mjs';
+function createHttpHandler(method) {
+  return (path, resolver, options = {}) => {
+    return new HttpHandler(method, path, resolver, options);
+  };
+}
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(HttpMethods.HEAD),
+  get: createHttpHandler(HttpMethods.GET),
+  post: createHttpHandler(HttpMethods.POST),
+  put: createHttpHandler(HttpMethods.PUT),
+  delete: createHttpHandler(HttpMethods.DELETE),
+  patch: createHttpHandler(HttpMethods.PATCH),
+  options: createHttpHandler(HttpMethods.OPTIONS)
+};
+export {
+  http
+};

package/lib/core/{rest.spec.js → http.spec.js}

@@ -1,8 +1,8 @@
 "use strict";
-var import_rest = require("./rest.js");
+var import_http = require("./http.js");
 test("exports all REST API methods", () => {
-  expect(import_rest.rest).toBeDefined();
-  expect(Object.keys(import_rest.rest)).toEqual([
+  expect(import_http.http).toBeDefined();
+  expect(Object.keys(import_http.http)).toEqual([
     "all",
     "head",
     "get",

package/lib/core/{rest.spec.mjs → http.spec.mjs}

@@ -1,7 +1,7 @@
-import { rest } from './rest.mjs';
+import { http } from './http.mjs';
 test("exports all REST API methods", () => {
-  expect(rest).toBeDefined();
-  expect(Object.keys(rest)).toEqual([
+  expect(http).toBeDefined();
+  expect(Object.keys(http)).toEqual([
     "all",
     "head",
     "get",

package/lib/core/index.d.ts

@@ -1,7 +1,7 @@
 export { SetupApi } from './SetupApi.js';
 export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, c as DefaultRequestMultipartBody, e as HttpResponse, H as HttpResponseInit, R as RequestHandler, a as ResponseResolver, b as ResponseResolverReturnType, S as StrictRequest, d as StrictResponse } from './RequestHandler-e964183f.js';
-export { rest } from './rest.js';
-export { RESTMethods, RequestQuery, RestHandler, RestRequestParsedResult } from './handlers/RestHandler.js';
+export { http } from './http.js';
+export { HttpHandler, HttpMethods, HttpRequestParsedResult, RequestQuery } from './handlers/HttpHandler.js';
 export { graphql } from './graphql.js';
 export { G as GraphQLHandler, c as GraphQLJsonRequestBody, b as GraphQLRequestBody, a as GraphQLVariables, P as ParsedGraphQLRequest } from './GraphQLHandler-2e60cda6.js';
 export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.js';

package/lib/core/index.js

@@ -20,24 +20,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var core_exports = {};
 __export(core_exports, {
   GraphQLHandler: () => import_GraphQLHandler.GraphQLHandler,
+  HttpHandler: () => import_HttpHandler.HttpHandler,
+  HttpMethods: () => import_HttpHandler.HttpMethods,
   NetworkError: () => import_NetworkError.NetworkError,
-  RESTMethods: () => import_RestHandler.RESTMethods,
   RequestHandler: () => import_RequestHandler.RequestHandler,
-  RestHandler: () => import_RestHandler.RestHandler,
   SetupApi: () => import_SetupApi.SetupApi,
   bypass: () => import_bypass.bypass,
   cleanUrl: () => import_cleanUrl.cleanUrl,
   graphql: () => import_graphql.graphql,
+  http: () => import_http.http,
   matchRequestUrl: () => import_matchRequestUrl.matchRequestUrl,
-  passthrough: () => import_passthrough.passthrough,
-  rest: () => import_rest.rest
+  passthrough: () => import_passthrough.passthrough
 });
 module.exports = __toCommonJS(core_exports);
 var import_checkGlobals = require("./utils/internal/checkGlobals.js");
 var import_SetupApi = require("./SetupApi.js");
 var import_RequestHandler = require("./handlers/RequestHandler.js");
-var import_rest = require("./rest.js");
-var import_RestHandler = require("./handlers/RestHandler.js");
+var import_http = require("./http.js");
+var import_HttpHandler = require("./handlers/HttpHandler.js");
 var import_graphql = require("./graphql.js");
 var import_GraphQLHandler = require("./handlers/GraphQLHandler.js");
 var import_matchRequestUrl = require("./utils/matching/matchRequestUrl.js");

package/lib/core/index.mjs

@@ -1,8 +1,8 @@
 import { checkGlobals } from './utils/internal/checkGlobals.mjs';
 import { SetupApi } from './SetupApi.mjs';
 import { RequestHandler } from './handlers/RequestHandler.mjs';
-import { rest } from './rest.mjs';
-import { RestHandler, RESTMethods } from './handlers/RestHandler.mjs';
+import { http } from './http.mjs';
+import { HttpHandler, HttpMethods } from './handlers/HttpHandler.mjs';
 import { graphql } from './graphql.mjs';
 import { GraphQLHandler } from './handlers/GraphQLHandler.mjs';
 import { matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
@@ -16,15 +16,15 @@ import { NetworkError } from './NetworkError.mjs';
 checkGlobals();
 export {
   GraphQLHandler,
+  HttpHandler,
+  HttpMethods,
   NetworkError,
-  RESTMethods,
   RequestHandler,
-  RestHandler,
   SetupApi,
   bypass,
   cleanUrl,
   graphql,
+  http,
   matchRequestUrl,
-  passthrough,
-  rest
+  passthrough
 };

package/lib/core/passthrough.d.ts

@@ -1,9 +1,12 @@
 /**
- * Instruct Mock Service Worker to perform this request as-is.
+ * Performs the captured request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
  * Unlike `bypass()`, this will not trigger an additional request.
  *
  * @example
- * rest.get('/user', () => {
+ * http.get('/resource', () => {
  *   return passthrough()
  * })
  */