@zimic/interceptor 0.15.0-canary.1 → 0.15.0-canary.3

package/dist/http.js

@@ -53,43 +53,6 @@ var UnknownHttpInterceptorTypeError_default = UnknownHttpInterceptorTypeError;
 var __defProp2 = Object.defineProperty;
 var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
 
-// ../zimic-utils/dist/url/excludeURLParams.mjs
-function excludeURLParams(url) {
-  url.hash = "";
-  url.search = "";
-  url.username = "";
-  url.password = "";
-  return url;
-}
-__name(excludeURLParams, "excludeURLParams");
-__name2(excludeURLParams, "excludeURLParams");
-var excludeURLParams_default = excludeURLParams;
-
-// ../zimic-utils/dist/url/validateURLProtocol.mjs
-var UnsupportedURLProtocolError = class extends TypeError {
-  static {
-    __name(this, "UnsupportedURLProtocolError");
-  }
-  static {
-    __name2(this, "UnsupportedURLProtocolError");
-  }
-  constructor(protocol, availableProtocols) {
-    super(
-      `Unsupported URL protocol: '${protocol}'. The available options are ${availableProtocols.map((protocol2) => `'${protocol2}'`).join(", ")}`
-    );
-    this.name = "UnsupportedURLProtocolError";
-  }
-};
-function validateURLProtocol(url, protocols) {
-  const protocol = url.protocol.replace(/:$/, "");
-  if (!protocols.includes(protocol)) {
-    throw new UnsupportedURLProtocolError(protocol, protocols);
-  }
-}
-__name(validateURLProtocol, "validateURLProtocol");
-__name2(validateURLProtocol, "validateURLProtocol");
-var validateURLProtocol_default = validateURLProtocol;
-
 // ../zimic-utils/dist/data/blobContains.mjs
 async function blobContains(blob, otherBlob) {
   return blob.type === otherBlob.type && blob.size >= otherBlob.size && (await blob.text()).includes(await otherBlob.text());
@@ -478,7 +441,7 @@ var HttpRequestHandlerClient = class {
         declarationPointer: this.timesDeclarationPointer,
         unmatchedRequestGroups: this.unmatchedRequestGroups,
         hasRestrictions: this.restrictions.length > 0,
-        hasSavedRequests: this.interceptor.shouldSaveRequests
+        hasSavedRequests: this.interceptor.saveRequests
       });
     }
   }
@@ -503,7 +466,7 @@ var HttpRequestHandlerClient = class {
     if (restrictionsMatch.value) {
       this.numberOfMatchedRequests++;
     } else {
-      const shouldSaveUnmatchedGroup = this.interceptor.shouldSaveRequests && this.restrictions.length > 0 && this.timesDeclarationPointer !== void 0;
+      const shouldSaveUnmatchedGroup = this.interceptor.saveRequests && this.restrictions.length > 0 && this.timesDeclarationPointer !== void 0;
       if (shouldSaveUnmatchedGroup) {
         this.unmatchedRequestGroups.push({ request, diff: restrictionsMatch.diff });
       }
@@ -649,7 +612,7 @@ var HttpRequestHandlerClient = class {
     return interceptedRequest;
   }
   get requests() {
-    if (!this.interceptor.shouldSaveRequests) {
+    if (!this.interceptor.saveRequests) {
       throw new DisabledRequestSavingError_default();
     }
     return this._requests;
@@ -719,6 +682,18 @@ __name(createRegExpFromURL, "createRegExpFromURL");
 __name2(createRegExpFromURL, "createRegExpFromURL");
 var createRegExpFromURL_default = createRegExpFromURL;
 
+// ../zimic-utils/dist/url/excludeURLParams.mjs
+function excludeURLParams(url) {
+  url.hash = "";
+  url.search = "";
+  url.username = "";
+  url.password = "";
+  return url;
+}
+__name(excludeURLParams, "excludeURLParams");
+__name2(excludeURLParams, "excludeURLParams");
+var excludeURLParams_default = excludeURLParams;
+
 // ../zimic-utils/dist/url/joinURL.mjs
 function joinURL(...parts) {
   return parts.map((part, index) => {
@@ -738,6 +713,31 @@ __name(joinURL, "joinURL");
 __name2(joinURL, "joinURL");
 var joinURL_default = joinURL;
 
+// ../zimic-utils/dist/url/validateURLProtocol.mjs
+var UnsupportedURLProtocolError = class extends TypeError {
+  static {
+    __name(this, "UnsupportedURLProtocolError");
+  }
+  static {
+    __name2(this, "UnsupportedURLProtocolError");
+  }
+  constructor(protocol, availableProtocols) {
+    super(
+      `Unsupported URL protocol: '${protocol}'. The available options are ${availableProtocols.map((protocol2) => `'${protocol2}'`).join(", ")}`
+    );
+    this.name = "UnsupportedURLProtocolError";
+  }
+};
+function validateURLProtocol(url, protocols) {
+  const protocol = url.protocol.replace(/:$/, "");
+  if (!protocols.includes(protocol)) {
+    throw new UnsupportedURLProtocolError(protocol, protocols);
+  }
+}
+__name(validateURLProtocol, "validateURLProtocol");
+__name2(validateURLProtocol, "validateURLProtocol");
+var validateURLProtocol_default = validateURLProtocol;
+
 // src/utils/arrays.ts
 function removeArrayIndex(array, index) {
   if (index >= 0 && index < array.length) {
@@ -1207,17 +1207,17 @@ __name(validateURLPathParams, "validateURLPathParams");
 __name2(validateURLPathParams, "validateURLPathParams");
 var validateURLPathParams_default = validateURLPathParams;
 
-// src/http/interceptor/errors/NotStartedHttpInterceptorError.ts
-var NotStartedHttpInterceptorError = class extends Error {
+// src/http/interceptor/errors/NotRunningHttpInterceptorError.ts
+var NotRunningHttpInterceptorError = class extends Error {
   static {
-    __name(this, "NotStartedHttpInterceptorError");
+    __name(this, "NotRunningHttpInterceptorError");
   }
   constructor() {
     super("Interceptor is not running. Did you forget to call `await interceptor.start()`?");
-    this.name = "NotStartedHttpInterceptorError";
+    this.name = "NotRunningHttpInterceptorError";
   }
 };
-var NotStartedHttpInterceptorError_default = NotStartedHttpInterceptorError;
+var NotRunningHttpInterceptorError_default = NotRunningHttpInterceptorError;
 
 // src/http/interceptor/errors/UnknownHttpInterceptorPlatformError.ts
 var UnknownHttpInterceptorPlatformError = class extends Error {
@@ -1262,21 +1262,22 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   static {
     __name(this, "LocalHttpInterceptorWorker");
   }
-  type;
   internalWorker;
   defaultHttpHandler;
   httpHandlerGroups = [];
-  constructor(options) {
+  constructor(_options) {
     super();
-    this.type = options.type;
     this.defaultHttpHandler = msw.http.all("*", async (context) => {
       const request = context.request;
       return this.bypassOrRejectUnhandledRequest(request);
     });
   }
+  get type() {
+    return "local";
+  }
   get internalWorkerOrThrow() {
     if (!this.internalWorker) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     return this.internalWorker;
   }
@@ -1514,6 +1515,18 @@ var RemoteHttpRequestHandler = class {
 };
 var RemoteHttpRequestHandler_default = RemoteHttpRequestHandler;
 
+// src/http/interceptor/errors/RunningHttpInterceptorError.ts
+var RunningHttpInterceptorError = class extends Error {
+  static {
+    __name(this, "RunningHttpInterceptorError");
+  }
+  constructor(additionalMessage) {
+    super(`The interceptor is running.${additionalMessage}`);
+    this.name = "RunningHttpInterceptorError";
+  }
+};
+var RunningHttpInterceptorError_default = RunningHttpInterceptorError;
+
 // src/http/interceptor/HttpInterceptorClient.ts
 var SUPPORTED_BASE_URL_PROTOCOLS = Object.freeze(["http", "https"]);
 var HttpInterceptorClient = class {
@@ -1523,9 +1536,9 @@ var HttpInterceptorClient = class {
   worker;
   store;
   _baseURL;
-  isRunning = false;
+  _saveRequests = false;
   onUnhandledRequest;
-  shouldSaveRequests = false;
+  isRunning = false;
   Handler;
   handlerClientsByMethod = {
     GET: /* @__PURE__ */ new Map(),
@@ -1539,17 +1552,35 @@ var HttpInterceptorClient = class {
   constructor(options) {
     this.worker = options.worker;
     this.store = options.store;
-    this._baseURL = options.baseURL;
-    this.Handler = options.Handler;
+    this.baseURL = options.baseURL;
+    this._saveRequests = options.saveRequests ?? false;
     this.onUnhandledRequest = options.onUnhandledRequest;
-    this.shouldSaveRequests = options.saveRequests ?? false;
+    this.Handler = options.Handler;
+  }
+  get baseURL() {
+    return this._baseURL;
+  }
+  set baseURL(newBaseURL) {
+    if (this.isRunning) {
+      throw new RunningHttpInterceptorError_default(
+        "Did you forget to call `await interceptor.stop()` before changing the base URL?"
+      );
+    }
+    validateURLProtocol_default(newBaseURL, SUPPORTED_BASE_URL_PROTOCOLS);
+    excludeURLParams_default(newBaseURL);
+    this._baseURL = newBaseURL;
   }
   get baseURLAsString() {
-    const baseURL = this._baseURL;
-    if (baseURL.href === `${baseURL.origin}/`) {
-      return baseURL.origin;
+    if (this.baseURL.href === `${this.baseURL.origin}/`) {
+      return this.baseURL.origin;
     }
-    return baseURL.href;
+    return this.baseURL.href;
+  }
+  get saveRequests() {
+    return this._saveRequests;
+  }
+  set saveRequests(saveRequests) {
+    this._saveRequests = saveRequests;
   }
   get platform() {
     return this.worker.platform;
@@ -1571,7 +1602,7 @@ var HttpInterceptorClient = class {
     if (this.worker instanceof LocalHttpInterceptorWorker_default) {
       this.store.markLocalInterceptorAsRunning(this, isRunning);
     } else {
-      this.store.markRemoteInterceptorAsRunning(this, isRunning, this._baseURL);
+      this.store.markRemoteInterceptorAsRunning(this, isRunning, this.baseURL);
     }
     this.isRunning = isRunning;
   }
@@ -1579,7 +1610,7 @@ var HttpInterceptorClient = class {
     if (this.worker instanceof LocalHttpInterceptorWorker_default) {
       return this.store.numberOfRunningLocalInterceptors;
     } else {
-      return this.store.numberOfRunningRemoteInterceptors(this._baseURL);
+      return this.store.numberOfRunningRemoteInterceptors(this.baseURL);
     }
   }
   get(path) {
@@ -1605,7 +1636,7 @@ var HttpInterceptorClient = class {
   }
   createHttpRequestHandler(method, path) {
     if (!this.isRunning) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     const handler = new this.Handler(this, method, path);
     this.registerRequestHandler(handler);
@@ -1648,7 +1679,7 @@ var HttpInterceptorClient = class {
     }
     const responseDeclaration = await matchedHandler.applyResponseDeclaration(parsedRequest);
     const response = HttpInterceptorWorker_default.createResponseFromDeclaration(request, responseDeclaration);
-    if (this.shouldSaveRequests) {
+    if (this._saveRequests) {
       const responseClone = response.clone();
       const parsedResponse = await HttpInterceptorWorker_default.parseRawResponse(responseClone);
       matchedHandler.saveInterceptedRequest(parsedRequest, parsedResponse);
@@ -1677,7 +1708,7 @@ var HttpInterceptorClient = class {
   }
   clear(options = {}) {
     if (!this.isRunning) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     const clearResults = [];
     for (const method of http.HTTP_METHODS) {
@@ -1882,17 +1913,17 @@ var InvalidWebSocketMessage = class extends Error {
 };
 var InvalidWebSocketMessage_default = InvalidWebSocketMessage;
 
-// src/webSocket/errors/NotStartedWebSocketHandlerError.ts
-var NotStartedWebSocketHandlerError = class extends Error {
+// src/webSocket/errors/NotRunningWebSocketHandlerError.ts
+var NotRunningWebSocketHandlerError = class extends Error {
   static {
-    __name(this, "NotStartedWebSocketHandlerError");
+    __name(this, "NotRunningWebSocketHandlerError");
   }
   constructor() {
     super("Web socket handler is not running.");
-    this.name = "NotStartedWebSocketHandlerError";
+    this.name = "NotRunningWebSocketHandlerError";
   }
 };
-var NotStartedWebSocketHandlerError_default = NotStartedWebSocketHandlerError;
+var NotRunningWebSocketHandlerError_default = NotRunningWebSocketHandlerError;
 
 // src/webSocket/WebSocketHandler.ts
 var WebSocketHandler = class {
@@ -2070,7 +2101,7 @@ var WebSocketHandler = class {
   }
   sendMessage(message, sockets = this.sockets) {
     if (!this.isRunning) {
-      throw new NotStartedWebSocketHandlerError_default();
+      throw new NotRunningWebSocketHandlerError_default();
     }
     const stringifiedMessage = JSON.stringify(message);
     for (const socket of sockets) {
@@ -2177,17 +2208,18 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   static {
     __name(this, "RemoteHttpInterceptorWorker");
   }
-  type;
   webSocketClient;
   httpHandlers = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
-    this.type = options.type;
     const webSocketServerURL = this.deriveWebSocketServerURL(options.serverURL);
     this.webSocketClient = new WebSocketClient_default({
       url: webSocketServerURL.toString()
     });
   }
+  get type() {
+    return "remote";
+  }
   deriveWebSocketServerURL(serverURL) {
     const webSocketServerURL = new URL(serverURL);
     webSocketServerURL.protocol = serverURL.protocol.replace(/^http(s)?:$/, "ws$1:");
@@ -2246,7 +2278,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async use(interceptor, method, rawURL, createResponse) {
     if (!this.isRunning) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     const crypto = await importCrypto();
     const url = new URL(rawURL);
@@ -2274,7 +2306,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async clearHandlers() {
     if (!this.isRunning) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     this.httpHandlers.clear();
     if (this.webSocketClient.isRunning) {
@@ -2283,7 +2315,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   }
   async clearInterceptorHandlers(interceptor) {
     if (!this.isRunning) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     for (const handler of this.httpHandlers.values()) {
       if (handler.interceptor === interceptor) {
@@ -2391,14 +2423,10 @@ var LocalHttpInterceptor = class {
   static {
     __name(this, "LocalHttpInterceptor");
   }
-  type;
   store = new HttpInterceptorStore_default();
   client;
   constructor(options) {
-    this.type = options.type;
     const baseURL = new URL(options.baseURL);
-    validateURLProtocol_default(baseURL, SUPPORTED_BASE_URL_PROTOCOLS);
-    excludeURLParams_default(baseURL);
     const worker = this.store.getOrCreateLocalWorker({});
     this.client = new HttpInterceptorClient_default({
       worker,
@@ -2409,9 +2437,27 @@ var LocalHttpInterceptor = class {
       saveRequests: options.saveRequests
     });
   }
+  get type() {
+    return "local";
+  }
   get baseURL() {
     return this.client.baseURLAsString;
   }
+  set baseURL(baseURL) {
+    this.client.baseURL = new URL(baseURL);
+  }
+  get saveRequests() {
+    return this.client.saveRequests;
+  }
+  set saveRequests(saveRequests) {
+    this.client.saveRequests = saveRequests;
+  }
+  get onUnhandledRequest() {
+    return this.client.onUnhandledRequest;
+  }
+  set onUnhandledRequest(onUnhandledRequest) {
+    this.client.onUnhandledRequest = onUnhandledRequest;
+  }
   get platform() {
     return this.client.platform;
   }
@@ -2466,14 +2512,10 @@ var RemoteHttpInterceptor = class {
   static {
     __name(this, "RemoteHttpInterceptor");
   }
-  type;
   store = new HttpInterceptorStore_default();
   client;
   constructor(options) {
-    this.type = options.type;
     const baseURL = new URL(options.baseURL);
-    validateURLProtocol_default(baseURL, SUPPORTED_BASE_URL_PROTOCOLS);
-    excludeURLParams_default(baseURL);
     const serverURL = new URL(baseURL.origin);
     const worker = this.store.getOrCreateRemoteWorker({ serverURL });
     this.client = new HttpInterceptorClient_default({
@@ -2485,9 +2527,27 @@ var RemoteHttpInterceptor = class {
       saveRequests: options.saveRequests
     });
   }
+  get type() {
+    return "remote";
+  }
   get baseURL() {
     return this.client.baseURLAsString;
   }
+  set baseURL(baseURL) {
+    this.client.baseURL = new URL(baseURL);
+  }
+  get saveRequests() {
+    return this.client.saveRequests;
+  }
+  set saveRequests(saveRequests) {
+    this.client.saveRequests = saveRequests;
+  }
+  get onUnhandledRequest() {
+    return this.client.onUnhandledRequest;
+  }
+  set onUnhandledRequest(onUnhandledRequest) {
+    this.client.onUnhandledRequest = onUnhandledRequest;
+  }
   get platform() {
     return this.client.platform;
   }
@@ -2635,7 +2695,8 @@ var httpInterceptor = Object.freeze(new HttpInterceptorNamespace_default());
 exports.DisabledRequestSavingError = DisabledRequestSavingError_default;
 exports.InvalidFormDataError = InvalidFormDataError_default;
 exports.InvalidJSONError = InvalidJSONError_default;
-exports.NotStartedHttpInterceptorError = NotStartedHttpInterceptorError_default;
+exports.NotRunningHttpInterceptorError = NotRunningHttpInterceptorError_default;
+exports.RunningHttpInterceptorError = RunningHttpInterceptorError_default;
 exports.TimesCheckError = TimesCheckError_default;
 exports.UnknownHttpInterceptorPlatformError = UnknownHttpInterceptorPlatformError_default;
 exports.UnknownHttpInterceptorTypeError = UnknownHttpInterceptorTypeError_default;