@zimic/interceptor 0.15.0-canary.0 → 0.15.0-canary.2

package/src/http/interceptorWorker/HttpInterceptorWorker.ts

@@ -41,8 +41,9 @@ import { HttpResponseFactory } from './types/requests';
 abstract class HttpInterceptorWorker {
   abstract readonly type: 'local' | 'remote';
 
-  private _platform: HttpInterceptorPlatform | null = null;
-  private _isRunning = false;
+  platform: HttpInterceptorPlatform | null = null;
+  isRunning = false;
+
   private startingPromise?: Promise<void>;
   private stoppingPromise?: Promise<void>;
 
@@ -50,26 +51,10 @@ abstract class HttpInterceptorWorker {
 
   private runningInterceptors: AnyHttpInterceptorClient[] = [];
 
-  platform() {
-    return this._platform;
-  }
-
-  protected setPlatform(platform: HttpInterceptorPlatform) {
-    this._platform = platform;
-  }
-
-  isRunning() {
-    return this._isRunning;
-  }
-
-  protected setIsRunning(isRunning: boolean) {
-    this._isRunning = isRunning;
-  }
-
   abstract start(): Promise<void>;
 
   protected async sharedStart(internalStart: () => Promise<void>) {
-    if (this.isRunning()) {
+    if (this.isRunning) {
       return;
     }
 
@@ -98,7 +83,7 @@ abstract class HttpInterceptorWorker {
   abstract stop(): Promise<void>;
 
   protected async sharedStop(internalStop: () => PossiblePromise<void>) {
-    if (!this.isRunning()) {
+    if (!this.isRunning) {
       return;
     }
     if (this.stoppingPromise) {
@@ -194,8 +179,7 @@ abstract class HttpInterceptorWorker {
 
   private findInterceptorByRequestBaseURL(request: Request) {
     const interceptor = this.runningInterceptors.findLast((interceptor) => {
-      const baseURL = interceptor.baseURL();
-      return request.url.startsWith(baseURL);
+      return request.url.startsWith(interceptor.baseURLAsString);
     });
 
     return interceptor;
@@ -217,14 +201,12 @@ abstract class HttpInterceptorWorker {
   }
 
   private async getInterceptorUnhandledRequestStrategy(request: Request, interceptor: AnyHttpInterceptorClient) {
-    const interceptorStrategyOrFactory = interceptor.onUnhandledRequest();
-
-    if (typeof interceptorStrategyOrFactory === 'function') {
+    if (typeof interceptor.onUnhandledRequest === 'function') {
       const parsedRequest = await HttpInterceptorWorker.parseRawUnhandledRequest(request);
-      return interceptorStrategyOrFactory(parsedRequest);
+      return interceptor.onUnhandledRequest(parsedRequest);
     }
 
-    return interceptorStrategyOrFactory;
+    return interceptor.onUnhandledRequest;
   }
 
   abstract clearHandlers(): PossiblePromise<void>;
@@ -233,7 +215,7 @@ abstract class HttpInterceptorWorker {
     interceptor: HttpInterceptorClient<Schema>,
   ): PossiblePromise<void>;
 
-  abstract interceptorsWithHandlers(): AnyHttpInterceptorClient[];
+  abstract get interceptorsWithHandlers(): AnyHttpInterceptorClient[];
 
   static createResponseFromDeclaration(
     request: Request,

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -19,7 +19,7 @@ import { BrowserHttpWorker, HttpResponseFactory, HttpWorker, NodeHttpWorker } fr
 class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   readonly type: 'local';
 
-  private _internalWorker?: HttpWorker;
+  private internalWorker?: HttpWorker;
 
   private defaultHttpHandler: MSWHttpHandler;
 
@@ -38,18 +38,18 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     });
   }
 
-  internalWorkerOrThrow() {
-    if (!this._internalWorker) {
+  get internalWorkerOrThrow() {
+    if (!this.internalWorker) {
       throw new NotStartedHttpInterceptorError();
     }
-    return this._internalWorker;
+    return this.internalWorker;
   }
 
-  internalWorkerOrCreate() {
-    if (!this._internalWorker) {
-      this._internalWorker = this.createInternalWorker();
+  get internalWorkerOrCreate() {
+    if (!this.internalWorker) {
+      this.internalWorker = this.createInternalWorker();
     }
-    return this._internalWorker;
+    return this.internalWorker;
   }
 
   private createInternalWorker() {
@@ -67,21 +67,21 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async start() {
     await super.sharedStart(async () => {
-      const internalWorker = this.internalWorkerOrCreate();
+      const internalWorker = this.internalWorkerOrCreate;
 
       const sharedOptions: MSWWorkerSharedOptions = {
         onUnhandledRequest: 'bypass',
       };
 
       if (this.isInternalBrowserWorker(internalWorker)) {
-        super.setPlatform('browser');
+        this.platform = 'browser';
         await this.startInBrowser(internalWorker, sharedOptions);
       } else {
-        super.setPlatform('node');
+        this.platform = 'node';
         this.startInNode(internalWorker, sharedOptions);
       }
 
-      super.setIsRunning(true);
+      this.isRunning = true;
     });
   }
 
@@ -106,7 +106,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
 
   async stop() {
     await super.sharedStop(() => {
-      const internalWorker = this.internalWorkerOrCreate();
+      const internalWorker = this.internalWorkerOrCreate;
 
       if (this.isInternalBrowserWorker(internalWorker)) {
         this.stopInBrowser(internalWorker);
@@ -115,8 +115,8 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
       }
       this.clearHandlers();
 
-      this._internalWorker = undefined;
-      super.setIsRunning(false);
+      this.internalWorker = undefined;
+      this.isRunning = false;
     });
   }
 
@@ -133,7 +133,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   hasInternalBrowserWorker() {
-    return this.isInternalBrowserWorker(this.internalWorkerOrThrow());
+    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
   }
 
   hasInternalNodeWorker() {
@@ -146,7 +146,6 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     rawURL: string | URL,
     createResponse: HttpResponseFactory,
   ) {
-    const internalWorker = this.internalWorkerOrThrow();
     const lowercaseMethod = method.toLowerCase<typeof method>();
 
     const url = new URL(rawURL);
@@ -180,7 +179,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
       return response;
     });
 
-    internalWorker.use(httpHandler);
+    this.internalWorkerOrThrow.use(httpHandler);
 
     this.httpHandlerGroups.push({ interceptor, httpHandler });
   }
@@ -199,25 +198,22 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   clearHandlers() {
-    const internalWorker = this.internalWorkerOrThrow();
-    internalWorker.resetHandlers();
+    this.internalWorkerOrThrow.resetHandlers();
     this.httpHandlerGroups = [];
   }
 
   clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
-    const internalWorker = this.internalWorkerOrThrow();
-
     const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
     removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
 
-    internalWorker.resetHandlers();
+    this.internalWorkerOrThrow.resetHandlers();
 
     for (const { httpHandler } of this.httpHandlerGroups) {
-      internalWorker.use(httpHandler);
+      this.internalWorkerOrThrow.use(httpHandler);
     }
   }
 
-  interceptorsWithHandlers() {
+  get interceptorsWithHandlers() {
     return this.httpHandlerGroups.map((group) => group.interceptor);
   }
 }

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -28,7 +28,8 @@ interface HttpHandler {
 class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
   readonly type: 'remote';
 
-  private _webSocketClient: WebSocketClient<InterceptorServerWebSocketSchema>;
+  webSocketClient: WebSocketClient<InterceptorServerWebSocketSchema>;
+
   private httpHandlers = new Map<HttpHandler['id'], HttpHandler>();
 
   constructor(options: RemoteHttpInterceptorWorkerOptions) {
@@ -36,7 +37,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     this.type = options.type;
 
     const webSocketServerURL = this.deriveWebSocketServerURL(options.serverURL);
-    this._webSocketClient = new WebSocketClient({
+    this.webSocketClient = new WebSocketClient({
       url: webSocketServerURL.toString(),
     });
   }
@@ -47,20 +48,15 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     return webSocketServerURL;
   }
 
-  webSocketClient() {
-    return this._webSocketClient;
-  }
-
   async start() {
     await super.sharedStart(async () => {
-      await this._webSocketClient.start();
+      await this.webSocketClient.start();
 
-      this._webSocketClient.onEvent('interceptors/responses/create', this.createResponse);
-      this._webSocketClient.onEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+      this.webSocketClient.onEvent('interceptors/responses/create', this.createResponse);
+      this.webSocketClient.onEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
 
-      const platform = this.readPlatform();
-      super.setPlatform(platform);
-      super.setIsRunning(true);
+      this.platform = this.readPlatform();
+      this.isRunning = true;
     });
   }
 
@@ -118,12 +114,12 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     await super.sharedStop(async () => {
       await this.clearHandlers();
 
-      this._webSocketClient.offEvent('interceptors/responses/create', this.createResponse);
-      this._webSocketClient.offEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
+      this.webSocketClient.offEvent('interceptors/responses/create', this.createResponse);
+      this.webSocketClient.offEvent('interceptors/responses/unhandled', this.handleUnhandledServerRequest);
 
-      await this._webSocketClient.stop();
+      await this.webSocketClient.stop();
 
-      super.setIsRunning(false);
+      this.isRunning = false;
     });
   }
 
@@ -133,7 +129,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     rawURL: string | URL,
     createResponse: HttpResponseFactory,
   ) {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError();
     }
 
@@ -146,7 +142,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     const handler: HttpHandler = {
       id: crypto.randomUUID(),
       url: {
-        base: interceptor.baseURL(),
+        base: interceptor.baseURLAsString,
         full: url.toString(),
       },
       method,
@@ -159,7 +155,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
     this.httpHandlers.set(handler.id, handler);
 
-    await this._webSocketClient.request('interceptors/workers/use/commit', {
+    await this.webSocketClient.request('interceptors/workers/use/commit', {
       id: handler.id,
       url: handler.url,
       method,
@@ -167,19 +163,19 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
   }
 
   async clearHandlers() {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError();
     }
 
     this.httpHandlers.clear();
 
-    if (this._webSocketClient.isRunning()) {
-      await this._webSocketClient.request('interceptors/workers/use/reset', undefined);
+    if (this.webSocketClient.isRunning) {
+      await this.webSocketClient.request('interceptors/workers/use/reset', undefined);
     }
   }
 
   async clearInterceptorHandlers<Schema extends HttpSchema>(interceptor: HttpInterceptorClient<Schema>) {
-    if (!super.isRunning()) {
+    if (!this.isRunning) {
       throw new NotStartedHttpInterceptorError();
     }
 
@@ -189,18 +185,18 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
       }
     }
 
-    if (this._webSocketClient.isRunning()) {
+    if (this.webSocketClient.isRunning) {
       const groupsToRecommit = Array.from<HttpHandler, HttpHandlerCommit>(this.httpHandlers.values(), (handler) => ({
         id: handler.id,
         url: handler.url,
         method: handler.method,
       }));
 
-      await this._webSocketClient.request('interceptors/workers/use/reset', groupsToRecommit);
+      await this.webSocketClient.request('interceptors/workers/use/reset', groupsToRecommit);
     }
   }
 
-  interceptorsWithHandlers() {
+  get interceptorsWithHandlers() {
     const interceptors = Array.from(this.httpHandlers.values(), (handler) => handler.interceptor);
     return interceptors;
   }

package/src/http/requestHandler/HttpRequestHandlerClient.ts

@@ -58,8 +58,7 @@ class HttpRequestHandlerClient<
 
   private numberOfMatchedRequests = 0;
   private unmatchedRequestGroups: UnmatchedHttpInterceptorRequestGroup[] = [];
-  private interceptedRequests: InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] =
-    [];
+  private _requests: InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] = [];
 
   private createResponseDeclaration?: HttpRequestHandlerResponseDeclarationFactory<
     Path,
@@ -69,19 +68,11 @@ class HttpRequestHandlerClient<
 
   constructor(
     private interceptor: HttpInterceptorClient<Schema>,
-    private _method: Method,
-    private _path: Path,
+    public method: Method,
+    public path: Path,
     private handler: InternalHttpRequestHandler<Schema, Method, Path, StatusCode>,
   ) {}
 
-  method() {
-    return this._method;
-  }
-
-  path() {
-    return this._path;
-  }
-
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
     this.restrictions.push(restriction);
     return this;
@@ -100,7 +91,7 @@ class HttpRequestHandlerClient<
 
     newThis.numberOfMatchedRequests = 0;
     newThis.unmatchedRequestGroups.length = 0;
-    newThis.interceptedRequests.length = 0;
+    newThis._requests.length = 0;
 
     this.interceptor.registerRequestHandler(this.handler);
 
@@ -141,7 +132,7 @@ class HttpRequestHandlerClient<
         declarationPointer: this.timesDeclarationPointer,
         unmatchedRequestGroups: this.unmatchedRequestGroups,
         hasRestrictions: this.restrictions.length > 0,
-        hasSavedRequests: this.interceptor.shouldSaveRequests(),
+        hasSavedRequests: this.interceptor.shouldSaveRequests,
       });
     }
   }
@@ -157,7 +148,7 @@ class HttpRequestHandlerClient<
 
     this.numberOfMatchedRequests = 0;
     this.unmatchedRequestGroups.length = 0;
-    this.interceptedRequests.length = 0;
+    this._requests.length = 0;
 
     this.createResponseDeclaration = undefined;
 
@@ -177,7 +168,7 @@ class HttpRequestHandlerClient<
       this.numberOfMatchedRequests++;
     } else {
       const shouldSaveUnmatchedGroup =
-        this.interceptor.shouldSaveRequests() &&
+        this.interceptor.shouldSaveRequests &&
         this.restrictions.length > 0 &&
         this.timesDeclarationPointer !== undefined;
 
@@ -388,7 +379,7 @@ class HttpRequestHandlerClient<
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
     const interceptedRequest = this.createInterceptedRequest(request, response);
-    this.interceptedRequests.push(interceptedRequest);
+    this._requests.push(interceptedRequest);
   }
 
   private createInterceptedRequest(
@@ -411,14 +402,12 @@ class HttpRequestHandlerClient<
     return interceptedRequest;
   }
 
-  requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
-    if (!this.interceptor.shouldSaveRequests()) {
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    if (!this.interceptor.shouldSaveRequests) {
       throw new DisabledRequestSavingError();
     }
 
-    const interceptedRequestsCopy = [...this.interceptedRequests];
-    Object.freeze(interceptedRequestsCopy);
-    return interceptedRequestsCopy;
+    return this._requests;
   }
 }
 

package/src/http/requestHandler/LocalHttpRequestHandler.ts

@@ -22,26 +22,22 @@ class LocalHttpRequestHandler<
 {
   readonly type = 'local';
 
-  private _client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 
   constructor(interceptor: HttpInterceptorClient<Schema>, method: Method, path: Path) {
-    this._client = new HttpRequestHandlerClient(interceptor, method, path, this);
+    this.client = new HttpRequestHandlerClient(interceptor, method, path, this);
   }
 
-  client() {
-    return this._client;
+  get method() {
+    return this.client.method;
   }
 
-  method() {
-    return this._client.method();
-  }
-
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
 
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this;
   }
 
@@ -50,45 +46,45 @@ class LocalHttpRequestHandler<
       | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
       | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): LocalHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
-    this._client.respond(declaration);
+    this.client.respond(declaration);
 
     const newThis = this as unknown as LocalHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
     return newThis;
   }
 
   times(minNumberOfRequests: number, maxNumberOfRequests?: number): this {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
 
   checkTimes() {
-    this._client.checkTimes();
+    this.client.checkTimes();
   }
 
   clear(): this {
-    this._client.clear();
+    this.client.clear();
     return this;
   }
 
-  requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
-    return this._client.requests();
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    return this.client.requests;
   }
 
   matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
 
   async applyResponseDeclaration(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
   ): Promise<HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, StatusCode>> {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
 
   saveInterceptedRequest(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
 }
 

package/src/http/requestHandler/RemoteHttpRequestHandler.ts

@@ -27,7 +27,7 @@ class RemoteHttpRequestHandler<
 {
   readonly type = 'remote';
 
-  private _client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
+  client: HttpRequestHandlerClient<Schema, Method, Path, StatusCode>;
 
   private syncPromises: Promise<unknown>[] = [];
 
@@ -35,7 +35,7 @@ class RemoteHttpRequestHandler<
   private synced: this;
 
   constructor(interceptor: HttpInterceptorClient<Schema, typeof RemoteHttpRequestHandler>, method: Method, path: Path) {
-    this._client = new HttpRequestHandlerClient(interceptor, method, path, this);
+    this.client = new HttpRequestHandlerClient(interceptor, method, path, this);
     this.unsynced = this;
     this.synced = this.createSyncedProxy();
   }
@@ -62,20 +62,16 @@ class RemoteHttpRequestHandler<
     return PENDING_PROPERTIES.has(property);
   }
 
-  client() {
-    return this._client;
+  get method() {
+    return this.client.method;
   }
 
-  method() {
-    return this._client.method();
-  }
-
-  path() {
-    return this._client.path();
+  get path() {
+    return this.client.path;
   }
 
   with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
-    this._client.with(restriction);
+    this.client.with(restriction);
     return this.unsynced;
   }
 
@@ -85,19 +81,19 @@ class RemoteHttpRequestHandler<
       | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
     const newUnsyncedThis = this.unsynced as unknown as RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
-    newUnsyncedThis._client.respond(declaration);
+    newUnsyncedThis.client.respond(declaration);
     return newUnsyncedThis;
   }
 
   times(minNumberOfRequests: number, maxNumberOfRequests?: number): this {
-    this._client.times(minNumberOfRequests, maxNumberOfRequests);
+    this.client.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
 
   async checkTimes() {
     return new Promise<void>((resolve, reject) => {
       try {
-        this._client.checkTimes();
+        this.client.checkTimes();
         resolve();
       } catch (error) {
         reject(error);
@@ -106,42 +102,36 @@ class RemoteHttpRequestHandler<
   }
 
   clear(): this {
-    this._client.clear();
+    this.client.clear();
     return this.unsynced;
   }
 
-  requests(): Promise<readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[]> {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this._client.requests());
-      } catch (error) {
-        reject(error);
-      }
-    });
+  get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
+    return this.client.requests;
   }
 
   matchesRequest(request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>): Promise<boolean> {
-    return this._client.matchesRequest(request);
+    return this.client.matchesRequest(request);
   }
 
   async applyResponseDeclaration(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
   ): Promise<HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, StatusCode>> {
-    return this._client.applyResponseDeclaration(request);
+    return this.client.applyResponseDeclaration(request);
   }
 
   saveInterceptedRequest(
     request: HttpInterceptorRequest<Path, Default<Schema[Path][Method]>>,
     response: HttpInterceptorResponse<Default<Schema[Path][Method]>, StatusCode>,
   ) {
-    this._client.saveInterceptedRequest(request, response);
+    this.client.saveInterceptedRequest(request, response);
   }
 
   registerSyncPromise(promise: Promise<unknown>) {
     this.syncPromises.push(promise);
   }
 
-  isSynced(): boolean {
+  get isSynced() {
     return this.syncPromises.length === 0;
   }
 
@@ -162,7 +152,7 @@ class RemoteHttpRequestHandler<
       .then(() => {
         this.syncPromises = this.syncPromises.filter((promise) => !promisesToWait.has(promise));
 
-        return this.isSynced() ? this.synced : this.unsynced;
+        return this.isSynced ? this.synced : this.unsynced;
       })
       .then(onFulfilled, onRejected);
   }