@zimic/interceptor 1.3.5 → 1.3.6-canary.1

package/dist/http.js

@@ -413,7 +413,7 @@ async function formatValueToLog(value, options = {}) {
   });
 }
 
-// src/http/requestHandler/errors/TimesCheckError.ts
+// src/http/errors/HttpTimesCheckError.ts
 function createMessageHeader({
   requestLimits,
   hasRestrictions,
@@ -498,7 +498,13 @@ var TimesCheckError = class extends TypeError {
     this.cause = options.declarationPointer;
   }
 };
-var TimesCheckError_default = TimesCheckError;
+var HttpTimesCheckError = class extends TimesCheckError {
+  constructor(options) {
+    super(options);
+    this.name = "HttpTimesCheckError";
+  }
+};
+var HttpTimesCheckError_default = HttpTimesCheckError;
 
 // ../zimic-utils/dist/time.mjs
 function waitForDelay(milliseconds) {
@@ -559,21 +565,21 @@ function random(lowerLimit, upperLimit) {
   return Math.random() * range + lowerLimit;
 }
 
-// src/http/requestHandler/errors/TimesDeclarationPointer.ts
-var TimesDeclarationPointer = class extends Error {
+// src/http/errors/HttpTimesDeclarationPointer.ts
+var HttpTimesDeclarationPointer = class extends Error {
   constructor(minNumberOfRequests, maxNumberOfRequests) {
     super("declared at:");
     this.name = `handler.times(${minNumberOfRequests}${maxNumberOfRequests === void 0 ? "" : `, ${maxNumberOfRequests}`})`;
   }
 };
-var TimesDeclarationPointer_default = TimesDeclarationPointer;
+var HttpTimesDeclarationPointer_default = HttpTimesDeclarationPointer;
 
-// src/http/requestHandler/HttpRequestHandlerClient.ts
+// src/http/requestHandler/HttpRequestHandlerImplementation.ts
 var DEFAULT_NUMBER_OF_REQUEST_LIMITS = Object.freeze({
   min: 0,
   max: Infinity
 });
-var HttpRequestHandlerClient = class {
+var HttpRequestHandlerImplementation = class {
   constructor(interceptor, method, path, handler) {
     this.interceptor = interceptor;
     this.method = method;
@@ -587,7 +593,7 @@ var HttpRequestHandlerClient = class {
   timesPointer;
   numberOfMatchedRequests = 0;
   unmatchedRequestGroups = [];
-  _requests = [];
+  savedInterceptedRequests = [];
   createResponseDeclaration;
   createResponseDelay;
   with(restriction) {
@@ -626,13 +632,13 @@ var HttpRequestHandlerClient = class {
       min: minNumberOfRequests,
       max: maxNumberOfRequests ?? minNumberOfRequests
     };
-    this.timesPointer = new TimesDeclarationPointer_default(minNumberOfRequests, maxNumberOfRequests);
+    this.timesPointer = new HttpTimesDeclarationPointer_default(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
   checkTimes() {
     const isWithinLimits = this.numberOfMatchedRequests >= this.limits.numberOfRequests.min && this.numberOfMatchedRequests <= this.limits.numberOfRequests.max;
     if (!isWithinLimits) {
-      throw new TimesCheckError_default({
+      throw new HttpTimesCheckError_default({
         requestLimits: this.limits.numberOfRequests,
         numberOfMatchedRequests: this.numberOfMatchedRequests,
         declarationPointer: this.timesPointer,
@@ -818,12 +824,12 @@ var HttpRequestHandlerClient = class {
   }
   saveInterceptedRequest(request, response) {
     const interceptedRequest = this.createInterceptedRequest(request, response);
-    this._requests.push(interceptedRequest);
+    this.savedInterceptedRequests.push(interceptedRequest);
     this.interceptor.incrementNumberOfSavedRequests(1);
   }
   clearInterceptedRequests() {
-    this.interceptor.incrementNumberOfSavedRequests(-this._requests.length);
-    this._requests.length = 0;
+    this.interceptor.incrementNumberOfSavedRequests(-this.savedInterceptedRequests.length);
+    this.savedInterceptedRequests.length = 0;
   }
   createInterceptedRequest(request, response) {
     const interceptedRequest = request;
@@ -839,67 +845,67 @@ var HttpRequestHandlerClient = class {
     if (!this.interceptor.requestSaving.enabled) {
       throw new DisabledRequestSavingError_default();
     }
-    return this._requests;
+    return this.savedInterceptedRequests;
   }
 };
-var HttpRequestHandlerClient_default = HttpRequestHandlerClient;
+var HttpRequestHandlerImplementation_default = HttpRequestHandlerImplementation;
 
 // src/http/requestHandler/LocalHttpRequestHandler.ts
 var LocalHttpRequestHandler = class {
   type = "local";
-  client;
+  implementation;
   constructor(interceptor, method, path) {
-    this.client = new HttpRequestHandlerClient_default(interceptor, method, path, this);
+    this.implementation = new HttpRequestHandlerImplementation_default(interceptor, method, path, this);
   }
   get method() {
-    return this.client.method;
+    return this.implementation.method;
   }
   get path() {
-    return this.client.path;
+    return this.implementation.path;
   }
   with(restriction) {
-    this.client.with(restriction);
+    this.implementation.with(restriction);
     return this;
   }
   delay(minMilliseconds, maxMilliseconds) {
-    this.client.delay(minMilliseconds, maxMilliseconds);
+    this.implementation.delay(minMilliseconds, maxMilliseconds);
     return this;
   }
   respond(declaration) {
-    this.client.respond(declaration);
+    this.implementation.respond(declaration);
     const newThis = this;
     return newThis;
   }
   times(minNumberOfRequests, maxNumberOfRequests) {
-    this.client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.implementation.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
   checkTimes() {
-    this.client.checkTimes();
+    this.implementation.checkTimes();
   }
   clear() {
-    this.client.clear();
+    this.implementation.clear();
     return this;
   }
   get requests() {
-    return this.client.requests;
+    return this.implementation.requests;
   }
   async matchesRequest(request) {
-    const requestMatch = await this.client.matchesRequest(request);
+    const requestMatch = await this.implementation.matchesRequest(request);
     if (requestMatch.success) {
-      this.client.markRequestAsMatched(request);
+      this.implementation.markRequestAsMatched(request);
     } else if (requestMatch.cause === "unmatchedRestrictions") {
-      this.client.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+      this.implementation.markRequestAsUnmatched(request, { diff: requestMatch.diff });
     } else {
-      this.client.markRequestAsMatched(request);
+      this.implementation.markRequestAsMatched(request);
     }
     return requestMatch;
   }
   async applyResponseDeclaration(request) {
-    return this.client.applyResponseDeclaration(request);
+    return this.implementation.applyResponseDeclaration(request);
   }
   saveInterceptedRequest(request, response) {
-    this.client.saveInterceptedRequest(request, response);
+    this.implementation.saveInterceptedRequest(request, response);
   }
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
@@ -1371,64 +1377,64 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
 var HttpInterceptorWorker_default = HttpInterceptorWorker;
 
 // src/http/requestHandler/RemoteHttpRequestHandler.ts
-var PENDING_PROPERTIES = /* @__PURE__ */ new Set(["then"]);
+var UNSYNCED_PROPERTIES = /* @__PURE__ */ new Set(["then"]);
 var RemoteHttpRequestHandler = class {
   type = "remote";
-  client;
+  implementation;
   syncPromises = [];
   unsynced;
   synced;
   constructor(interceptor, method, path) {
-    this.client = new HttpRequestHandlerClient_default(interceptor, method, path, this);
+    this.implementation = new HttpRequestHandlerImplementation_default(interceptor, method, path, this);
     this.unsynced = this;
     this.synced = this.createSyncedProxy();
   }
   createSyncedProxy() {
     return new Proxy(this, {
       has: (target, property) => {
-        if (this.isHiddenPropertyWhenSynced(property)) {
+        if (this.shouldBeHiddenPropertyWhenSynced(property)) {
           return false;
         }
         return Reflect.has(target, property);
       },
       get: (target, property) => {
-        if (this.isHiddenPropertyWhenSynced(property)) {
+        if (this.shouldBeHiddenPropertyWhenSynced(property)) {
           return void 0;
         }
         return Reflect.get(target, property);
       }
     });
   }
-  isHiddenPropertyWhenSynced(property) {
-    return PENDING_PROPERTIES.has(property);
+  shouldBeHiddenPropertyWhenSynced(property) {
+    return UNSYNCED_PROPERTIES.has(property);
   }
   get method() {
-    return this.client.method;
+    return this.implementation.method;
   }
   get path() {
-    return this.client.path;
+    return this.implementation.path;
   }
   with(restriction) {
-    this.client.with(restriction);
+    this.implementation.with(restriction);
     return this.unsynced;
   }
   delay(minMilliseconds, maxMilliseconds) {
-    this.client.delay(minMilliseconds, maxMilliseconds);
+    this.implementation.delay(minMilliseconds, maxMilliseconds);
     return this.unsynced;
   }
   respond(declaration) {
     const newUnsyncedThis = this.unsynced;
-    newUnsyncedThis.client.respond(declaration);
+    newUnsyncedThis.implementation.respond(declaration);
     return newUnsyncedThis;
   }
   times(minNumberOfRequests, maxNumberOfRequests) {
-    this.client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.implementation.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
   async checkTimes() {
     return new Promise((resolve, reject) => {
       try {
-        this.client.checkTimes();
+        this.implementation.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -1436,28 +1442,28 @@ var RemoteHttpRequestHandler = class {
     });
   }
   clear() {
-    this.client.clear();
+    this.implementation.clear();
     return this.unsynced;
   }
   get requests() {
-    return this.client.requests;
+    return this.implementation.requests;
   }
   async matchesRequest(request) {
-    const requestMatch = await this.client.matchesRequest(request);
+    const requestMatch = await this.implementation.matchesRequest(request);
     if (requestMatch.success) {
-      this.client.markRequestAsMatched(request);
+      this.implementation.markRequestAsMatched(request);
     } else if (requestMatch.cause === "unmatchedRestrictions") {
-      this.client.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+      this.implementation.markRequestAsUnmatched(request, { diff: requestMatch.diff });
     } else {
-      this.client.markRequestAsMatched(request);
+      this.implementation.markRequestAsMatched(request);
     }
     return requestMatch;
   }
   async applyResponseDeclaration(request) {
-    return this.client.applyResponseDeclaration(request);
+    return this.implementation.applyResponseDeclaration(request);
   }
   saveInterceptedRequest(request, response) {
-    this.client.saveInterceptedRequest(request, response);
+    this.implementation.saveInterceptedRequest(request, response);
   }
   registerSyncPromise(promise) {
     this.syncPromises.push(promise);
@@ -1481,12 +1487,12 @@ var RemoteHttpRequestHandler = class {
 };
 var RemoteHttpRequestHandler_default = RemoteHttpRequestHandler;
 
-// src/http/interceptor/HttpInterceptorClient.ts
+// src/http/interceptor/HttpInterceptorImplementation.ts
 var SUPPORTED_BASE_URL_PROTOCOLS = Object.freeze(["http", "https"]);
 var DEFAULT_REQUEST_SAVING_SAFE_LIMIT = 1e3;
-var HttpInterceptorClient = class {
+var HttpInterceptorImplementation = class {
   store;
-  _baseURL;
+  #baseURL;
   createWorker;
   deleteWorker;
   worker;
@@ -1520,7 +1526,7 @@ var HttpInterceptorClient = class {
     return isServerSide() ? process.env.NODE_ENV === "test" : false;
   }
   get baseURL() {
-    return this._baseURL;
+    return this.#baseURL;
   }
   set baseURL(newBaseURL) {
     if (this.isRunning) {
@@ -1530,7 +1536,7 @@ var HttpInterceptorClient = class {
     }
     validateURLProtocol_default(newBaseURL, SUPPORTED_BASE_URL_PROTOCOLS);
     excludeNonPathParams_default(newBaseURL);
-    this._baseURL = newBaseURL;
+    this.#baseURL = newBaseURL;
   }
   get baseURLAsString() {
     if (this.baseURL.href === `${this.baseURL.origin}/`) {
@@ -1611,17 +1617,21 @@ var HttpInterceptorClient = class {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError_default();
     }
-    const handler = new this.Handler(this, method, path);
+    const handler = new this.Handler(
+      this,
+      method,
+      path
+    );
     this.registerRequestHandler(handler);
     return handler;
   }
   registerRequestHandler(handler) {
     const pathHandlers = this.handlers[handler.method].get(handler.path) ?? [];
-    const isAlreadyRegistered = pathHandlers.includes(handler.client);
+    const isAlreadyRegistered = pathHandlers.includes(handler.implementation);
     if (isAlreadyRegistered) {
       return;
     }
-    pathHandlers.push(handler.client);
+    pathHandlers.push(handler.implementation);
     const isFirstHandlerForMethodPath = pathHandlers.length === 1;
     if (!isFirstHandlerForMethodPath) {
       return;
@@ -1729,7 +1739,7 @@ var HttpInterceptorClient = class {
     return clearResults;
   }
 };
-var HttpInterceptorClient_default = HttpInterceptorClient;
+var HttpInterceptorImplementation_default = HttpInterceptorImplementation;
 var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   internalWorker;
   httpHandlersByMethod = {
@@ -1987,7 +1997,7 @@ async function serializeResponse(response) {
   };
 }
 
-// src/webSocket/errors/UnauthorizedWebSocketConnectionError.ts
+// src/utils/webSocket/errors/UnauthorizedWebSocketConnectionError.ts
 var UnauthorizedWebSocketConnectionError = class extends Error {
   constructor(event) {
     super(`${event.reason} (code ${event.code})`);
@@ -2106,10 +2116,10 @@ async function closeClientSocket(socket, options = {}) {
   });
 }
 
-// src/webSocket/constants.ts
+// src/utils/webSocket/constants.ts
 var WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(["socket:auth:valid"]);
 
-// src/webSocket/errors/InvalidWebSocketMessageError.ts
+// src/utils/webSocket/errors/InvalidWebSocketMessageError.ts
 var InvalidWebSocketMessageError = class extends Error {
   constructor(message) {
     super(`Web socket message is invalid and could not be parsed: ${message}`);
@@ -2118,7 +2128,7 @@ var InvalidWebSocketMessageError = class extends Error {
 };
 var InvalidWebSocketMessageError_default = InvalidWebSocketMessageError;
 
-// src/webSocket/errors/NotRunningWebSocketHandlerError.ts
+// src/utils/webSocket/errors/NotRunningWebSocketHandlerError.ts
 var NotRunningWebSocketHandlerError = class extends Error {
   constructor() {
     super("Web socket handler is not running.");
@@ -2127,7 +2137,7 @@ var NotRunningWebSocketHandlerError = class extends Error {
 };
 var NotRunningWebSocketHandlerError_default = NotRunningWebSocketHandlerError;
 
-// src/webSocket/WebSocketHandler.ts
+// src/utils/webSocket/WebSocketHandler.ts
 var WebSocketHandler = class {
   sockets = /* @__PURE__ */ new Set();
   socketTimeout;
@@ -2382,7 +2392,7 @@ var WebSocketHandler = class {
 };
 var WebSocketHandler_default = WebSocketHandler;
 
-// src/webSocket/WebSocketClient.ts
+// src/utils/webSocket/WebSocketClient.ts
 var SUPPORTED_WEB_SOCKET_PROTOCOLS = ["ws", "wss"];
 var WebSocketClient = class extends WebSocketHandler_default {
   url;
@@ -2651,10 +2661,10 @@ var HttpInterceptorStore_default = HttpInterceptorStore;
 // src/http/interceptor/LocalHttpInterceptor.ts
 var LocalHttpInterceptor = class {
   store = new HttpInterceptorStore_default();
-  client;
+  implementation;
   constructor(options) {
     const baseURL = new URL(options.baseURL);
-    this.client = new HttpInterceptorClient_default({
+    this.implementation = new HttpInterceptorImplementation_default({
       store: this.store,
       baseURL,
       createWorker: () => {
@@ -2672,68 +2682,68 @@ var LocalHttpInterceptor = class {
     return "local";
   }
   get baseURL() {
-    return this.client.baseURLAsString;
+    return this.implementation.baseURLAsString;
   }
   set baseURL(baseURL) {
-    this.client.baseURL = new URL(baseURL);
+    this.implementation.baseURL = new URL(baseURL);
   }
   get requestSaving() {
-    return this.client.requestSaving;
+    return this.implementation.requestSaving;
   }
   set requestSaving(requestSaving) {
-    this.client.requestSaving = requestSaving;
+    this.implementation.requestSaving = requestSaving;
   }
   get onUnhandledRequest() {
-    return this.client.onUnhandledRequest;
+    return this.implementation.onUnhandledRequest;
   }
   set onUnhandledRequest(onUnhandledRequest) {
-    this.client.onUnhandledRequest = onUnhandledRequest;
+    this.implementation.onUnhandledRequest = onUnhandledRequest;
   }
   get platform() {
-    return this.client.platform;
+    return this.implementation.platform;
   }
   get isRunning() {
-    return this.client.isRunning;
+    return this.implementation.isRunning;
   }
   async start() {
     if (this.isRunning) {
       return;
     }
-    await this.client.start();
+    await this.implementation.start();
   }
   async stop() {
     if (!this.isRunning) {
       return;
     }
     this.clear();
-    await this.client.stop();
+    await this.implementation.stop();
   }
   get = ((path) => {
-    return this.client.get(path);
+    return this.implementation.get(path);
   });
   post = ((path) => {
-    return this.client.post(path);
+    return this.implementation.post(path);
   });
   patch = ((path) => {
-    return this.client.patch(path);
+    return this.implementation.patch(path);
   });
   put = ((path) => {
-    return this.client.put(path);
+    return this.implementation.put(path);
   });
   delete = ((path) => {
-    return this.client.delete(path);
+    return this.implementation.delete(path);
   });
   head = ((path) => {
-    return this.client.head(path);
+    return this.implementation.head(path);
   });
   options = ((path) => {
-    return this.client.options(path);
+    return this.implementation.options(path);
   });
   checkTimes() {
-    this.client.checkTimes();
+    this.implementation.checkTimes();
   }
   clear() {
-    void this.client.clear();
+    void this.implementation.clear();
   }
 };
 var LocalHttpInterceptor_default = LocalHttpInterceptor;
@@ -2741,18 +2751,18 @@ var LocalHttpInterceptor_default = LocalHttpInterceptor;
 // src/http/interceptor/RemoteHttpInterceptor.ts
 var RemoteHttpInterceptor = class {
   store = new HttpInterceptorStore_default();
-  client;
-  _auth;
+  implementation;
+  #auth;
   constructor(options) {
-    this._auth = options.auth;
+    this.#auth = options.auth;
     const baseURL = new URL(options.baseURL);
-    this.client = new HttpInterceptorClient_default({
+    this.implementation = new HttpInterceptorImplementation_default({
       store: this.store,
       baseURL,
       createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
           serverURL: baseURL,
-          auth: this._auth
+          auth: this.#auth
         });
       },
       deleteWorker: () => {
@@ -2767,19 +2777,19 @@ var RemoteHttpInterceptor = class {
     return "remote";
   }
   get baseURL() {
-    return this.client.baseURLAsString;
+    return this.implementation.baseURLAsString;
   }
   set baseURL(baseURL) {
-    this.client.baseURL = new URL(baseURL);
+    this.implementation.baseURL = new URL(baseURL);
   }
   get requestSaving() {
-    return this.client.requestSaving;
+    return this.implementation.requestSaving;
   }
   set requestSaving(requestSaving) {
-    this.client.requestSaving = requestSaving;
+    this.implementation.requestSaving = requestSaving;
   }
   get auth() {
-    return this._auth;
+    return this.#auth;
   }
   set auth(auth) {
     const cannotChangeAuthWhileRunningMessage = "Did you forget to call `await interceptor.stop()` before changing the authentication parameters?";
@@ -2787,10 +2797,10 @@ var RemoteHttpInterceptor = class {
       throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
     }
     if (!auth) {
-      this._auth = void 0;
+      this.#auth = void 0;
       return;
     }
-    this._auth = new Proxy(auth, {
+    this.#auth = new Proxy(auth, {
       set: (target, property, value) => {
         if (this.isRunning) {
           throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
@@ -2800,55 +2810,55 @@ var RemoteHttpInterceptor = class {
     });
   }
   get onUnhandledRequest() {
-    return this.client.onUnhandledRequest;
+    return this.implementation.onUnhandledRequest;
   }
   set onUnhandledRequest(onUnhandledRequest) {
-    this.client.onUnhandledRequest = onUnhandledRequest;
+    this.implementation.onUnhandledRequest = onUnhandledRequest;
   }
   get platform() {
-    return this.client.platform;
+    return this.implementation.platform;
   }
   get isRunning() {
-    return this.client.isRunning;
+    return this.implementation.isRunning;
   }
   async start() {
     if (this.isRunning) {
       return;
     }
-    await this.client.start();
+    await this.implementation.start();
   }
   async stop() {
     if (!this.isRunning) {
       return;
     }
     await this.clear();
-    await this.client.stop();
+    await this.implementation.stop();
   }
   get = ((path) => {
-    return this.client.get(path);
+    return this.implementation.get(path);
   });
   post = ((path) => {
-    return this.client.post(path);
+    return this.implementation.post(path);
   });
   patch = ((path) => {
-    return this.client.patch(path);
+    return this.implementation.patch(path);
   });
   put = ((path) => {
-    return this.client.put(path);
+    return this.implementation.put(path);
   });
   delete = ((path) => {
-    return this.client.delete(path);
+    return this.implementation.delete(path);
   });
   head = ((path) => {
-    return this.client.head(path);
+    return this.implementation.head(path);
   });
   options = ((path) => {
-    return this.client.options(path);
+    return this.implementation.options(path);
   });
   checkTimes() {
     return new Promise((resolve, reject) => {
       try {
-        this.client.checkTimes();
+        this.implementation.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -2856,7 +2866,7 @@ var RemoteHttpInterceptor = class {
     });
   }
   async clear() {
-    await this.client.clear();
+    await this.implementation.clear();
   }
 };
 var RemoteHttpInterceptor_default = RemoteHttpInterceptor;
@@ -2920,12 +2930,13 @@ var InvalidJSONError = class extends http.InvalidJSONError {
 /* istanbul ignore next -- @preserve */
 
 exports.DisabledRequestSavingError = DisabledRequestSavingError_default;
+exports.HttpTimesCheckError = HttpTimesCheckError_default;
 exports.InvalidFormDataError = InvalidFormDataError;
 exports.InvalidJSONError = InvalidJSONError;
 exports.NotRunningHttpInterceptorError = NotRunningHttpInterceptorError_default;
 exports.RequestSavingSafeLimitExceededError = RequestSavingSafeLimitExceededError_default;
 exports.RunningHttpInterceptorError = RunningHttpInterceptorError_default;
-exports.TimesCheckError = TimesCheckError_default;
+exports.TimesCheckError = TimesCheckError;
 exports.UnknownHttpInterceptorPlatformError = UnknownHttpInterceptorPlatformError_default;
 exports.UnknownHttpInterceptorTypeError = UnknownHttpInterceptorTypeError_default;
 exports.UnregisteredBrowserServiceWorkerError = UnregisteredBrowserServiceWorkerError_default;