msw 0.47.3 → 0.48.0

package/lib/index.d.ts

@@ -1,11 +1,12 @@
-import { R as ResponseTransformer, s as status, a as set, d as delay, f as fetch, b as RequestHandler, S as SetupWorkerApi, D as DefaultContext, c as DefaultBodyType, M as MockedRequest, e as ResponseResolver, g as ResponseResolutionContext, h as SerializedResponse, i as RequestHandlerDefaultInfo, j as MockedResponse, k as ResponseLookupResult, l as SharedOptions, m as ServerLifecycleEventsMap } from './glossary-dc3fd077.js';
-export { A as AsyncResponseResolverReturnType, c as DefaultBodyType, u as DefaultRequestMultipartBody, y as DelayMode, M as MockedRequest, H as MockedRequestInit, j as MockedResponse, z as RequestCache, E as RequestDestination, b as RequestHandler, B as RequestMode, F as RequestPriority, C as RequestRedirect, G as RequestReferrerPolicy, v as ResponseComposition, w as ResponseCompositionOptions, x as ResponseFunction, e as ResponseResolver, t as ResponseResolverReturnType, R as ResponseTransformer, S as SetupWorkerApi, l as SharedOptions, q as StartOptions, o as createResponseComposition, p as defaultContext, n as defaultResponse, r as response } from './glossary-dc3fd077.js';
+import { R as ResponseTransformer, s as status, a as set, d as delay, f as fetch, b as RequestHandler, S as SetupApi, W as WorkerLifecycleEventsMap, c as StartOptions, e as StartReturnType, D as DefaultContext, g as DefaultBodyType, M as MockedRequest, h as ResponseResolver, i as ResponseResolutionContext, j as SerializedResponse, k as RequestHandlerDefaultInfo, l as MockedResponse, m as ResponseLookupResult, n as SharedOptions } from './SetupApi-75fbec12.js';
+export { A as AsyncResponseResolverReturnType, g as DefaultBodyType, v as DefaultRequestMultipartBody, z as DelayMode, M as MockedRequest, I as MockedRequestInit, l as MockedResponse, B as RequestCache, F as RequestDestination, b as RequestHandler, C as RequestMode, G as RequestPriority, E as RequestRedirect, H as RequestReferrerPolicy, w as ResponseComposition, x as ResponseCompositionOptions, y as ResponseFunction, h as ResponseResolver, u as ResponseResolverReturnType, R as ResponseTransformer, S as SetupApi, t as SetupWorkerApi, n as SharedOptions, c as StartOptions, p as createResponseComposition, q as defaultContext, o as defaultResponse, r as response } from './SetupApi-75fbec12.js';
 import * as cookieUtils from 'cookie';
 import { GraphQLError, OperationTypeNode, DocumentNode } from 'graphql';
 import { StrictEventEmitter } from 'strict-event-emitter';
-import 'type-fest';
-import '@mswjs/interceptors';
+import { S as ServerLifecycleEventsMap } from './glossary-a22f5c13.js';
 import 'headers-polyfill';
+import '@mswjs/interceptors';
+import 'type-fest';
 
 declare type Path = string | RegExp;
 declare type PathParams<KeyType extends keyof any = string> = {
@@ -122,13 +123,23 @@ declare namespace index {
   };
 }
 
+declare class SetupWorkerApi extends SetupApi<WorkerLifecycleEventsMap> {
+    private context;
+    private startHandler;
+    private stopHandler;
+    private listeners;
+    constructor(handlers: Array<RequestHandler>);
+    private createWorkerContext;
+    start(options?: StartOptions): StartReturnType;
+    printHandlers(): void;
+    stop(): void;
+}
 /**
- * Creates a new mock Service Worker registration
- * with the given request handlers.
- * @param {RequestHandler[]} requestHandlers List of request handlers
+ * Sets up a requests interception in the browser with the given request handlers.
+ * @param {RequestHandler[]} handlers List of request handlers.
  * @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker`}
  */
-declare function setupWorker(...requestHandlers: RequestHandler[]): SetupWorkerApi;
+declare function setupWorker(...handlers: Array<RequestHandler>): SetupWorkerApi;
 
 declare type RestHandlerMethod = string | RegExp;
 interface RestHandlerInfo extends RequestHandlerDefaultInfo {

package/lib/index.js

@@ -56,6 +56,7 @@ __export(src_exports, {
   RESTMethods: () => RESTMethods,
   RequestHandler: () => RequestHandler,
   RestHandler: () => RestHandler,
+  SetupApi: () => SetupApi,
   cleanUrl: () => cleanUrl,
   compose: () => compose,
   context: () => context_exports,
@@ -253,7 +254,7 @@ var errors = (errorsList) => {
 // src/context/fetch.ts
 var import_is_node_process2 = require("is-node-process");
 var import_headers_polyfill2 = require("headers-polyfill");
-var useFetch = (0, import_is_node_process2.isNodeProcess)() ? require("node-fetch") : window.fetch;
+var useFetch = (0, import_is_node_process2.isNodeProcess)() ? (input, init) => Promise.resolve().then(() => __toESM(require("node-fetch"))).then(({ default: nodeFetch }) => nodeFetch(input, init)) : window.fetch;
 var augmentRequestInit = (requestInit) => {
   const headers = new import_headers_polyfill2.Headers(requestInit.headers);
   headers.set("x-msw-bypass", "true");
@@ -304,8 +305,8 @@ var xml = (body2) => {
 };
 
 // src/setupWorker/setupWorker.ts
+var import_outvariant4 = require("outvariant");
 var import_is_node_process3 = require("is-node-process");
-var import_strict_event_emitter = require("strict-event-emitter");
 
 // src/setupWorker/start/createStartHandler.ts
 var import_until4 = require("@open-draft/until");
@@ -814,7 +815,7 @@ function prepareResponse(res) {
 
 // src/utils/matching/matchRequestUrl.ts
 var import_path_to_regexp = require("path-to-regexp");
-var import_getCleanUrl = require("@mswjs/interceptors/lib/utils/getCleanUrl");
+var import_getCleanUrl = require("@mswjs/interceptors/lib/utils/getCleanUrl.js");
 
 // src/utils/url/cleanUrl.ts
 var REDUNDANT_CHARACTERS_EXP = /[\?|#].*$/g;
@@ -921,7 +922,7 @@ var response = Object.assign(createResponseComposition(), {
 });
 
 // src/utils/internal/getCallFrame.ts
-var SOURCE_FRAME = /\/msw\/src\/(.+)/;
+var SOURCE_FRAME = /[\/\\]msw[\/\\]src[\/\\](.+)/;
 var BUILD_FRAME = /(node_modules)?[\/\\]lib[\/\\](umd|esm|iief|cjs)[\/\\]|^[^\/\\]*$/;
 function getCallFrame(error2) {
   const stack = error2.stack;
@@ -1383,6 +1384,7 @@ function serializeResponse(source) {
 // src/setupWorker/start/createRequestListener.ts
 var createRequestListener = (context, options) => {
   return async (event, message) => {
+    var _a;
     const messageChannel = new WorkerChannel(event.ports[0]);
     const request = parseWorkerRequest(message.payload);
     try {
@@ -1421,7 +1423,7 @@ var createRequestListener = (context, options) => {
 
 %s
 
-This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/recipes/mocking-error-responses`, request.method, request.url, error2);
+This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/recipes/mocking-error-responses`, request.method, request.url, (_a = error2.stack) != null ? _a : error2);
         messageChannel.postMessage("MOCK_RESPONSE", {
           status: 500,
           statusText: "Request Handler Error",
@@ -1452,8 +1454,8 @@ function transformResponse(response2) {
 async function requestIntegrityCheck(context, serviceWorker) {
   context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
   const { payload: actualChecksum } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
-  if (actualChecksum !== "b3066ef78c2f9090b4ce87e874965995") {
-    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"b3066ef78c2f9090b4ce87e874965995"}).`);
+  if (actualChecksum !== "3d6b9f06410d179a7f7404d4bf4c3c70") {
+    throw new Error(`Currently active Service Worker (${actualChecksum}) is behind the latest published one (${"3d6b9f06410d179a7f7404d4bf4c3c70"}).`);
   }
   return serviceWorker;
 }
@@ -1594,19 +1596,6 @@ var createStop = (context) => {
   };
 };
 
-// src/utils/internal/requestHandlerUtils.ts
-function use(currentHandlers, ...handlers) {
-  currentHandlers.unshift(...handlers);
-}
-function restoreHandlers(handlers) {
-  handlers.forEach((handler) => {
-    handler.markAsSkipped(false);
-  });
-}
-function resetHandlers(initialHandlers, ...nextHandlers) {
-  return nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers];
-}
-
 // src/setupWorker/start/utils/prepareStartHandler.ts
 var DEFAULT_START_OPTIONS = {
   serviceWorker: {
@@ -1620,15 +1609,6 @@ var DEFAULT_START_OPTIONS = {
     return scriptURL === mockServiceWorkerUrl;
   }
 };
-function resolveStartOptions(initialOptions) {
-  return mergeRight(DEFAULT_START_OPTIONS, initialOptions || {});
-}
-function prepareStartHandler(handler, context) {
-  return (initialOptions) => {
-    context.startOptions = resolveStartOptions(initialOptions);
-    return handler(context.startOptions, initialOptions || {});
-  };
-}
 
 // src/setupWorker/start/createFallbackRequestListener.ts
 var import_interceptors4 = require("@mswjs/interceptors");
@@ -1734,6 +1714,10 @@ function createFallbackStop(context) {
   };
 }
 
+// src/SetupApi.ts
+var import_outvariant3 = require("outvariant");
+var import_strict_event_emitter = require("strict-event-emitter");
+
 // src/utils/internal/pipeEvents.ts
 function pipeEvents(source, destination) {
   const rawEmit = source.emit;
@@ -1754,131 +1738,163 @@ function toReadonlyArray(source) {
   return clone;
 }
 
-// src/setupWorker/setupWorker.ts
-var listeners = [];
-function setupWorker(...requestHandlers) {
-  requestHandlers.forEach((handler) => {
-    if (Array.isArray(handler))
-      throw new Error(devUtils.formatMessage('Failed to call "setupWorker" given an Array of request handlers (setupWorker([a, b])), expected to receive each handler individually: setupWorker(a, b).'));
-  });
-  if ((0, import_is_node_process3.isNodeProcess)()) {
-    throw new Error(devUtils.formatMessage("Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."));
-  }
-  const emitter = new import_strict_event_emitter.StrictEventEmitter();
-  const publicEmitter = new import_strict_event_emitter.StrictEventEmitter();
-  pipeEvents(emitter, publicEmitter);
-  const context = {
-    isMockingEnabled: false,
-    startOptions: void 0,
-    worker: null,
-    registration: null,
-    requestHandlers: [...requestHandlers],
-    emitter,
-    workerChannel: {
-      on(eventType, callback) {
-        context.events.addListener(navigator.serviceWorker, "message", (event) => {
-          if (event.source !== context.worker) {
-            return;
-          }
-          const message = event.data;
-          if (!message) {
-            return;
-          }
-          if (message.type === eventType) {
-            callback(event, message);
-          }
-        });
+// src/SetupApi.ts
+var SetupApi = class {
+  constructor(initialHandlers) {
+    this.validateHandlers(initialHandlers);
+    this.initialHandlers = toReadonlyArray(initialHandlers);
+    this.currentHandlers = [...initialHandlers];
+    this.emitter = new import_strict_event_emitter.StrictEventEmitter();
+    this.publicEmitter = new import_strict_event_emitter.StrictEventEmitter();
+    pipeEvents(this.emitter, this.publicEmitter);
+    this.events = this.createLifeCycleEvents();
+  }
+  validateHandlers(handlers) {
+    for (const handler of handlers) {
+      (0, import_outvariant3.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);
+    }
+  }
+  dispose() {
+    this.emitter.removeAllListeners();
+    this.publicEmitter.removeAllListeners();
+  }
+  use(...runtimeHandlers) {
+    this.currentHandlers.unshift(...runtimeHandlers);
+  }
+  restoreHandlers() {
+    this.currentHandlers.forEach((handler) => {
+      handler.markAsSkipped(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);
       },
-      send(type) {
-        var _a;
-        (_a = context.worker) == null ? void 0 : _a.postMessage(type);
-      }
-    },
-    events: {
-      addListener(target, eventType, callback) {
-        target.addEventListener(eventType, callback);
-        listeners.push({ eventType, target, callback });
-        return () => {
-          target.removeEventListener(eventType, callback);
-        };
+      removeListener: (...args) => {
+        return this.publicEmitter.removeListener(...args);
       },
-      removeAllListeners() {
-        for (const { target, eventType, callback } of listeners) {
-          target.removeEventListener(eventType, callback);
+      removeAllListeners: (...args) => {
+        return this.publicEmitter.removeAllListeners(...args);
+      }
+    };
+  }
+};
+
+// src/setupWorker/setupWorker.ts
+var SetupWorkerApi = class extends SetupApi {
+  constructor(handlers) {
+    super(handlers);
+    this.startHandler = null;
+    this.stopHandler = null;
+    (0, import_outvariant4.invariant)(!(0, import_is_node_process3.isNodeProcess)(), devUtils.formatMessage("Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."));
+    this.listeners = [];
+    this.context = this.createWorkerContext();
+  }
+  createWorkerContext() {
+    const context = {
+      isMockingEnabled: false,
+      startOptions: null,
+      worker: null,
+      registration: null,
+      requestHandlers: this.currentHandlers,
+      emitter: this.emitter,
+      workerChannel: {
+        on: (eventType, callback) => {
+          this.context.events.addListener(navigator.serviceWorker, "message", (event) => {
+            if (event.source !== this.context.worker) {
+              return;
+            }
+            const message = event.data;
+            if (!message) {
+              return;
+            }
+            if (message.type === eventType) {
+              callback(event, message);
+            }
+          });
+        },
+        send: (type) => {
+          var _a;
+          (_a = this.context.worker) == null ? void 0 : _a.postMessage(type);
         }
-        listeners = [];
       },
-      once(eventType) {
-        const bindings = [];
-        return new Promise((resolve, reject) => {
-          const handleIncomingMessage = (event) => {
-            try {
-              const message = event.data;
-              if (message.type === eventType) {
-                resolve(message);
-              }
-            } catch (error2) {
-              reject(error2);
-            }
+      events: {
+        addListener: (target, eventType, callback) => {
+          target.addEventListener(eventType, callback);
+          this.listeners.push({ eventType, target, callback });
+          return () => {
+            target.removeEventListener(eventType, callback);
           };
-          bindings.push(context.events.addListener(navigator.serviceWorker, "message", handleIncomingMessage), context.events.addListener(navigator.serviceWorker, "messageerror", reject));
-        }).finally(() => {
-          bindings.forEach((unbind) => unbind());
-        });
-      }
-    },
-    useFallbackMode: !("serviceWorker" in navigator) || location.protocol === "file:"
-  };
-  const startHandler = context.useFallbackMode ? createFallbackStart(context) : createStartHandler(context);
-  const stopHandler = context.useFallbackMode ? createFallbackStop(context) : createStop(context);
-  return {
-    start: prepareStartHandler(startHandler, context),
-    stop() {
-      context.events.removeAllListeners();
-      context.emitter.removeAllListeners();
-      publicEmitter.removeAllListeners();
-      stopHandler();
-    },
-    use(...handlers) {
-      use(context.requestHandlers, ...handlers);
-    },
-    restoreHandlers() {
-      restoreHandlers(context.requestHandlers);
-    },
-    resetHandlers(...nextHandlers) {
-      context.requestHandlers = resetHandlers(requestHandlers, ...nextHandlers);
-    },
-    listHandlers() {
-      return toReadonlyArray(context.requestHandlers);
-    },
-    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);
-        if (handler instanceof RestHandler) {
-          console.log("Match:", `https://mswjs.io/repl?path=${handler.info.path}`);
+        },
+        removeAllListeners: () => {
+          for (const { target, eventType, callback } of this.listeners) {
+            target.removeEventListener(eventType, callback);
+          }
+          this.listeners = [];
+        },
+        once: (eventType) => {
+          const bindings = [];
+          return new Promise((resolve, reject) => {
+            const handleIncomingMessage = (event) => {
+              try {
+                const message = event.data;
+                if (message.type === eventType) {
+                  resolve(message);
+                }
+              } catch (error2) {
+                reject(error2);
+              }
+            };
+            bindings.push(this.context.events.addListener(navigator.serviceWorker, "message", handleIncomingMessage), this.context.events.addListener(navigator.serviceWorker, "messageerror", reject));
+          }).finally(() => {
+            bindings.forEach((unbind) => unbind());
+          });
         }
-        console.groupEnd();
-      });
-    },
-    events: {
-      on(...args) {
-        return publicEmitter.on(...args);
-      },
-      removeListener(...args) {
-        return publicEmitter.removeListener(...args);
       },
-      removeAllListeners(...args) {
-        return publicEmitter.removeAllListeners(...args);
+      useFallbackMode: !("serviceWorker" in navigator) || location.protocol === "file:"
+    };
+    Object.defineProperties(context, {
+      requestHandlers: {
+        get: () => this.currentHandlers
       }
-    }
-  };
+    });
+    this.startHandler = context.useFallbackMode ? createFallbackStart(context) : createStartHandler(context);
+    this.stopHandler = context.useFallbackMode ? createFallbackStop(context) : createStop(context);
+    return context;
+  }
+  async start(options = {}) {
+    this.context.startOptions = mergeRight(DEFAULT_START_OPTIONS, options);
+    return await 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();
+    this.context.emitter.removeAllListeners();
+    this.stopHandler();
+  }
+};
+function setupWorker(...handlers) {
+  return new SetupWorkerApi(handlers);
 }
 
 // src/rest.ts
@@ -1931,6 +1947,7 @@ var graphql = __spreadProps(__spreadValues({}, standardGraphQLHandlers), {
   RESTMethods,
   RequestHandler,
   RestHandler,
+  SetupApi,
   cleanUrl,
   compose,
   context,