@zimic/interceptor 1.3.6-canary.2 → 1.3.6-canary.4

package/dist/http.mjs

@@ -1,8 +1,6 @@
 import { InvalidFormDataError as InvalidFormDataError$1, InvalidJSONError as InvalidJSONError$1, HTTP_METHODS, HttpHeaders, HttpSearchParams, HttpFormData, parseHttpBody } from '@zimic/http';
 import color2 from 'picocolors';
 import { http, bypass, passthrough } from 'msw';
-import * as mswBrowser from 'msw/browser';
-import * as mswNode from 'msw/node';
 import ClientSocket from 'isomorphic-ws';
 
 // src/http/index.ts
@@ -1713,8 +1711,14 @@ var HttpInterceptorImplementation = class {
   }
 };
 var HttpInterceptorImplementation_default = HttpInterceptorImplementation;
-var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
-  internalWorker;
+var importMSWNode = createCachedDynamicImport_default(() => import('msw/node'));
+var importMSWBrowser = createCachedDynamicImport_default(() => import('msw/browser'));
+var LocalHttpInterceptorWorker = class _LocalHttpInterceptorWorker extends HttpInterceptorWorker_default {
+  // Re-creating MSW workers may cause issues, so we should keep a single worker instance, even if all interceptor
+  // workers are stopped. See https://github.com/mswjs/msw/issues/2597.
+  static mswWorker;
+  static isMSWWorkerRunning = false;
+  mswHttpHandler;
   httpHandlersByMethod = {
     GET: [],
     POST: [],
@@ -1727,52 +1731,66 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   constructor(_options) {
     super();
   }
+  get class() {
+    return _LocalHttpInterceptorWorker;
+  }
   get type() {
     return "local";
   }
-  get internalWorkerOrThrow() {
-    if (!this.internalWorker) {
+  get mswWorkerOrThrow() {
+    if (!this.class.mswWorker) {
       throw new NotRunningHttpInterceptorError_default();
     }
-    return this.internalWorker;
+    return this.class.mswWorker;
   }
-  get internalWorkerOrCreate() {
-    this.internalWorker ??= this.createInternalWorker();
-    return this.internalWorker;
+  async getMSWWorkerOrCreate() {
+    this.class.mswWorker ??= await this.createMSWWorker();
+    return this.class.mswWorker;
   }
-  createInternalWorker() {
-    const mswHttpHandler = http.all("*", async (context) => {
-      const request = context.request;
-      const response = await this.createResponseForRequest(request);
-      return response;
-    });
-    if (isServerSide() && "setupServer" in mswNode) {
-      return mswNode.setupServer(mswHttpHandler);
+  async createMSWWorker() {
+    if (isServerSide()) {
+      const mswNode = await importMSWNode();
+      if ("setupServer" in mswNode) {
+        return mswNode.setupServer();
+      }
     }
-    if (isClientSide() && "setupWorker" in mswBrowser) {
-      return mswBrowser.setupWorker(mswHttpHandler);
+    if (isClientSide()) {
+      const mswBrowser = await importMSWBrowser();
+      if ("setupWorker" in mswBrowser) {
+        return mswBrowser.setupWorker();
+      }
     }
     throw new UnknownHttpInterceptorPlatformError_default();
   }
   async start() {
     await super.sharedStart(async () => {
-      const internalWorker = this.internalWorkerOrCreate;
+      const mswWorker = await this.getMSWWorkerOrCreate();
       const sharedOptions = {
         onUnhandledRequest: "bypass"
       };
-      if (this.isInternalBrowserWorker(internalWorker)) {
+      this.mswHttpHandler = http.all("*", async (context) => {
+        const request = context.request;
+        const response = await this.createResponseForRequest(request);
+        return response;
+      });
+      mswWorker.use(this.mswHttpHandler);
+      if (this.isInternalBrowserWorker(mswWorker)) {
         this.platform = "browser";
-        await this.startInBrowser(internalWorker, sharedOptions);
+        if (!this.class.isMSWWorkerRunning) {
+          await this.startInBrowser(mswWorker, sharedOptions);
+          this.class.isMSWWorkerRunning = true;
+        }
       } else {
         this.platform = "node";
-        this.startInNode(internalWorker, sharedOptions);
+        this.startInNode(mswWorker, sharedOptions);
+        this.class.isMSWWorkerRunning = true;
       }
       this.isRunning = true;
     });
   }
-  async startInBrowser(internalWorker, sharedOptions) {
+  async startInBrowser(mswWorker, sharedOptions) {
     try {
-      await internalWorker.start({ ...sharedOptions, quiet: true });
+      await mswWorker.start({ ...sharedOptions, quiet: true });
     } catch (error) {
       this.handleBrowserWorkerStartError(error);
     }
@@ -1780,36 +1798,35 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   handleBrowserWorkerStartError(error) {
     if (UnregisteredBrowserServiceWorkerError_default.matchesRawError(error)) {
       throw new UnregisteredBrowserServiceWorkerError_default();
+    } else {
+      throw error;
     }
-    throw error;
   }
-  startInNode(internalWorker, sharedOptions) {
-    internalWorker.listen(sharedOptions);
+  startInNode(mswWorker, sharedOptions) {
+    mswWorker.listen(sharedOptions);
   }
   async stop() {
-    await super.sharedStop(() => {
-      const internalWorker = this.internalWorkerOrCreate;
-      if (this.isInternalBrowserWorker(internalWorker)) {
-        this.stopInBrowser(internalWorker);
-      } else {
-        this.stopInNode(internalWorker);
-      }
+    await super.sharedStop(async () => {
+      const mswWorker = await this.getMSWWorkerOrCreate();
       this.clearHandlers();
-      this.internalWorker = void 0;
+      const newMSWHandlers = mswWorker.listHandlers().filter((handler) => handler !== this.mswHttpHandler);
+      mswWorker.resetHandlers(...newMSWHandlers);
+      if (this.isInternalBrowserWorker(mswWorker)) ; else {
+        this.stopInNode(mswWorker);
+        this.class.isMSWWorkerRunning = false;
+      }
+      this.mswHttpHandler = void 0;
       this.isRunning = false;
     });
   }
-  stopInBrowser(internalWorker) {
-    internalWorker.stop();
-  }
-  stopInNode(internalWorker) {
-    internalWorker.close();
+  stopInNode(mswWorker) {
+    mswWorker.close();
   }
   isInternalBrowserWorker(worker) {
     return "start" in worker && "stop" in worker;
   }
   hasInternalBrowserWorker() {
-    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
+    return this.isInternalBrowserWorker(this.mswWorkerOrThrow);
   }
   hasInternalNodeWorker() {
     return !this.hasInternalBrowserWorker();
@@ -2640,12 +2657,8 @@ var LocalHttpInterceptor = class {
     this.implementation = new HttpInterceptorImplementation_default({
       store: this.store,
       baseURL,
-      createWorker: () => {
-        return this.store.getOrCreateLocalWorker({});
-      },
-      deleteWorker: () => {
-        this.store.deleteLocalWorker();
-      },
+      createWorker: () => this.store.getOrCreateLocalWorker({}),
+      deleteWorker: () => this.store.deleteLocalWorker(),
       Handler: LocalHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
@@ -2868,15 +2881,26 @@ var InvalidJSONError = class extends InvalidJSONError$1 {
 };
 /* istanbul ignore else -- @preserve
  * The else is a fallback for when the error is not an instance of Error. */
+/* istanbul ignore next -- @preserve
+ * This if statement only runs if concurrent calls to stop() are made, which is an edge case that is hard to
+ * reliably reproduce in tests. */
 /* istanbul ignore if -- @preserve
  * This is just a type guard to ensure the value is valid. In practice, this condition should never be true. */
 /* istanbul ignore next -- @preserve
  * Ignoring because there will always be a handler for the given method and path at this point. */
 /* istanbul ignore if -- @preserve
  * Trying to access the internal worker when it does not exist should not happen. */
+/* istanbul ignore else -- @preserve
+ * We still check if we actually imported the server module in case our `isServerSide()` check returns true, but
+ * the environment actually resolves the browser module. */
 /* istanbul ignore else -- @preserve */
+/* istanbul ignore else -- @preserve
+ * We still check if we actually imported the browser module in case our `isClientSide()` check returns true, but
+ * the environment actually resolves the server module. */
 /* istanbul ignore next -- @preserve
  * Ignoring because checking unknown platforms is not configured in our test setup. */
+/* istanbul ignore else -- @preserve
+ * Since we start the internal worker once and do not stop it, tests may not be able exercise this branch. */
 /* istanbul ignore next -- @preserve
  * Ignoring as Node.js >=20 provides a global crypto and the import fallback won't run. */
 /* istanbul ignore else -- @preserve