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

package/dist/http.mjs

@@ -26,43 +26,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());
@@ -451,7 +414,7 @@ var HttpRequestHandlerClient = class {
         declarationPointer: this.timesDeclarationPointer,
         unmatchedRequestGroups: this.unmatchedRequestGroups,
         hasRestrictions: this.restrictions.length > 0,
-        hasSavedRequests: this.interceptor.shouldSaveRequests
+        hasSavedRequests: this.interceptor.saveRequests
       });
     }
   }
@@ -476,7 +439,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 });
       }
@@ -622,7 +585,7 @@ var HttpRequestHandlerClient = class {
     return interceptedRequest;
   }
   get requests() {
-    if (!this.interceptor.shouldSaveRequests) {
+    if (!this.interceptor.saveRequests) {
       throw new DisabledRequestSavingError_default();
     }
     return this._requests;
@@ -692,6 +655,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) => {
@@ -711,6 +686,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) {
@@ -1180,17 +1180,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 {
@@ -1235,21 +1235,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 = 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;
   }
@@ -1487,6 +1488,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 {
@@ -1496,9 +1509,9 @@ var HttpInterceptorClient = class {
   worker;
   store;
   _baseURL;
-  isRunning = false;
+  _saveRequests = false;
   onUnhandledRequest;
-  shouldSaveRequests = false;
+  isRunning = false;
   Handler;
   handlerClientsByMethod = {
     GET: /* @__PURE__ */ new Map(),
@@ -1512,17 +1525,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;
@@ -1544,7 +1575,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;
   }
@@ -1552,7 +1583,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) {
@@ -1578,7 +1609,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);
@@ -1621,7 +1652,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);
@@ -1650,7 +1681,7 @@ var HttpInterceptorClient = class {
   }
   clear(options = {}) {
     if (!this.isRunning) {
-      throw new NotStartedHttpInterceptorError_default();
+      throw new NotRunningHttpInterceptorError_default();
     }
     const clearResults = [];
     for (const method of HTTP_METHODS) {
@@ -1855,17 +1886,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 {
@@ -2043,7 +2074,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) {
@@ -2150,17 +2181,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:");
@@ -2219,7 +2251,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);
@@ -2247,7 +2279,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) {
@@ -2256,7 +2288,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) {
@@ -2364,14 +2396,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,
@@ -2382,9 +2410,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;
   }
@@ -2439,14 +2485,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({
@@ -2458,9 +2500,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;
   }
@@ -2605,6 +2665,6 @@ var httpInterceptor = Object.freeze(new HttpInterceptorNamespace_default());
  * Reply listeners are always present when notified in normal conditions. If they were not present, the request
  * would reach a timeout and not be responded. The empty set serves as a fallback. */
 
-export { DisabledRequestSavingError_default as DisabledRequestSavingError, InvalidFormDataError_default as InvalidFormDataError, InvalidJSONError_default as InvalidJSONError, NotStartedHttpInterceptorError_default as NotStartedHttpInterceptorError, TimesCheckError_default as TimesCheckError, UnknownHttpInterceptorPlatformError_default as UnknownHttpInterceptorPlatformError, UnknownHttpInterceptorTypeError_default as UnknownHttpInterceptorTypeError, UnregisteredBrowserServiceWorkerError_default as UnregisteredBrowserServiceWorkerError, httpInterceptor };
+export { DisabledRequestSavingError_default as DisabledRequestSavingError, InvalidFormDataError_default as InvalidFormDataError, InvalidJSONError_default as InvalidJSONError, NotRunningHttpInterceptorError_default as NotRunningHttpInterceptorError, RunningHttpInterceptorError_default as RunningHttpInterceptorError, TimesCheckError_default as TimesCheckError, UnknownHttpInterceptorPlatformError_default as UnknownHttpInterceptorPlatformError, UnknownHttpInterceptorTypeError_default as UnknownHttpInterceptorTypeError, UnregisteredBrowserServiceWorkerError_default as UnregisteredBrowserServiceWorkerError, httpInterceptor };
 //# sourceMappingURL=http.mjs.map
 //# sourceMappingURL=http.mjs.map