Align codebase to generics naming styleguide

Author: nebarf

src/cache/http-cache-store.ts

@@ -4,12 +4,12 @@ export interface HttpCacheStore {
   /**
    * Gets the cached entry for the given identifier.
    */
-  get<T>(identifier: string): HttpCacheEntry<T> | undefined;
+  get<HttpResponseT>(identifier: string): HttpCacheEntry<HttpResponseT> | undefined;
 
   /**
    * Stores the entry.
    */
-  put<T>(identifier: string, entry: HttpCacheEntry<T>): () => void;
+  put<HttpResponseT>(identifier: string, entry: HttpCacheEntry<HttpResponseT>): () => void;
 
   /**
    * Determines if the entry is in the store.

src/cache/http-in-memory-cache-store.ts

@@ -11,14 +11,14 @@ export class HttpInMemoryCacheStore implements HttpCacheStore {
   /**
    * @inheritdoc
    */
-  get<T>(identifier: string): HttpCacheEntry<T> | undefined {
-    return this.store.get(identifier) as HttpCacheEntry<T>;
+  get<HttpResponseT>(identifier: string): HttpCacheEntry<HttpResponseT> | undefined {
+    return this.store.get(identifier) as HttpCacheEntry<HttpResponseT>;
   }
 
   /**
    * @inheritdoc
    */
-  put<T>(identifier: string, entry: HttpCacheEntry<T>): () => void {
+  put<HttpResponseT>(identifier: string, entry: HttpCacheEntry<HttpResponseT>): () => void {
     this.store.set(identifier, entry);
     return () => this.delete(identifier);
   }

src/cache/prefix-decorator.ts

@@ -34,15 +34,15 @@ export class HttpCacheStorePrefixDecorator implements HttpCacheStore {
   /**
    * @inheritdoc
    */
-  get<T>(entryIdentifier: string): HttpCacheEntry<T> | undefined {
+  get<HttpResponseT>(entryIdentifier: string): HttpCacheEntry<HttpResponseT> | undefined {
     const prefixedIdentifier = this.getPrefixedIdentifier(entryIdentifier);
     return this.store.get(prefixedIdentifier);
   }
 
   /**
    * @inheritdoc
    */
-  put<T>(entryIdentifier: string, entry: HttpCacheEntry<T>): () => void {
+  put<HttpResponseT>(entryIdentifier: string, entry: HttpCacheEntry<HttpResponseT>): () => void {
     const prefixedIdentifier = this.getPrefixedIdentifier(entryIdentifier);
     return this.store.put(prefixedIdentifier, entry);
   }

src/cache/types.ts

@@ -1,4 +1,4 @@
-export interface HttpCacheEntry<T> {
+export interface HttpCacheEntry<HttpResponseT> {
   /**
    * The identifier for the cached entry.
    */
@@ -7,7 +7,7 @@ export interface HttpCacheEntry<T> {
   /**
    * The cached parsed reponse for the remote call.
    */
-  response: T;
+  response: HttpResponseT;
 
   /**
    * Keeps track of the Date the entry was cached.

src/config/response-parser.ts

@@ -1,3 +1,3 @@
-export function httpResponseParser<HttpResponse>(res: Response): Promise<HttpResponse> {
+export function httpResponseParser<HttpResponseT>(res: Response): Promise<HttpResponseT> {
   return res.json();
 }

src/events-manager/event-bus.ts

@@ -14,15 +14,15 @@ export class EventBus {
   /**
    * Gets the set of subscriptions associated with the provided http event class type.
    */
-  private _ensureEventSubscriptionInit<T>(
-    httpEventType: HttpEventClassType<T>
-  ): Set<HttpEventHandler<T>> {
+  private _ensureEventSubscriptionInit<PayloadT>(
+    httpEventType: HttpEventClassType<PayloadT>
+  ): Set<HttpEventHandler<PayloadT>> {
     const currentEventSubscriptions = this._subscriptions.get(httpEventType);
     if (currentEventSubscriptions) {
       return currentEventSubscriptions;
     }
 
-    const newEventSubscriptionsSet = new Set<HttpEventHandler<T>>();
+    const newEventSubscriptionsSet = new Set<HttpEventHandler<PayloadT>>();
     this._subscriptions.set(httpEventType, newEventSubscriptionsSet);
     return newEventSubscriptionsSet;
   }
@@ -31,7 +31,7 @@ export class EventBus {
    * Gets the number of subscriptions for the given event.
    * @param {*} eventName
    */
-  getEventSubscriptionsCount<T>(httpEventType: HttpEventClassType<T>): number {
+  getEventSubscriptionsCount<PayloadT>(httpEventType: HttpEventClassType<PayloadT>): number {
     const eventSubscriptions = this._subscriptions.get(httpEventType);
     return eventSubscriptions ? eventSubscriptions.size : 0;
   }
@@ -41,7 +41,10 @@ export class EventBus {
    * @param {*} eventName
    * @param {*} handler
    */
-  subscribe<T>(httpEventType: HttpEventClassType<T>, handler: HttpEventHandler<T>): () => void {
+  subscribe<PayloadT>(
+    httpEventType: HttpEventClassType<PayloadT>,
+    handler: HttpEventHandler<PayloadT>
+  ): () => void {
     const eventSubscriptions = this._ensureEventSubscriptionInit(httpEventType);
     eventSubscriptions.add(handler);
 
@@ -53,8 +56,8 @@ export class EventBus {
    * @param {*} eventName
    * @param {*} payload
    */
-  publish<T>(httpEvent: HttpEvent<T>): void {
-    const httpEventType = httpEvent.constructor as HttpEventClassType<T>;
+  publish<PayloadT>(httpEvent: HttpEvent<PayloadT>): void {
+    const httpEventType = httpEvent.constructor as HttpEventClassType<PayloadT>;
     // Do nothing if the subscriptions set for the given event is empty.
     const eventHandlers = this._subscriptions.get(httpEventType);
     if (!eventHandlers || eventHandlers.size === 0) {
@@ -69,7 +72,10 @@ export class EventBus {
    * @param {*} eventName
    * @param {*} subscription
    */
-  unsubscribe<T>(httpEventType: HttpEventClassType<T>, handler: HttpEventHandler<T>): void {
+  unsubscribe<PayloadT>(
+    httpEventType: HttpEventClassType<PayloadT>,
+    handler: HttpEventHandler<PayloadT>
+  ): void {
     const eventSubscriptionsSet = this._subscriptions.get(httpEventType);
     if (!eventSubscriptionsSet || eventSubscriptionsSet.size === 0) {
       return;
@@ -86,7 +92,7 @@ export class EventBus {
    * Detaches all subscriptions for the given event.
    * @param {*} eventName
    */
-  detachEventSubscriptions<T>(httpEventType: HttpEventClassType<T>): void {
+  detachEventSubscriptions<PayloadT>(httpEventType: HttpEventClassType<PayloadT>): void {
     if (!this._subscriptions.has(httpEventType)) {
       return;
     }

src/events-manager/events/http-event.ts

@@ -1,6 +1,6 @@
-export abstract class HttpEvent<T> {
+export abstract class HttpEvent<PayloadT> {
   /**
    * A payload.
    */
-  abstract payload: T;
+  abstract payload: PayloadT;
 }

src/events-manager/events/request-started-event.ts

@@ -1,7 +1,7 @@
 import { HttpRequest } from '../../client';
 import { HttpEvent } from './http-event';
 
-export class RequestStartedEvent<HttpRequestBodyT = unknown> extends HttpEvent<
+export class RequestStartedEvent<HttpRequestBodyT> extends HttpEvent<
   HttpRequest<HttpRequestBodyT>
 > {
   /**

src/events-manager/events/request-succeded-event.ts

@@ -1,18 +1,20 @@
 import { HttpRequest } from '../../client';
 import { HttpEvent } from './http-event';
 
-export interface RequestSuccededEventPayload<T, U> {
-  request: HttpRequest<U>;
-  response: T;
+export interface RequestSuccededEventPayload<HttpResponseT, HttpRequestBodyT> {
+  request: HttpRequest<HttpRequestBodyT>;
+  response: HttpResponseT;
 }
 
-export class RequestSuccededEvent<T, U> extends HttpEvent<RequestSuccededEventPayload<T, U>> {
+export class RequestSuccededEvent<HttpResponseT, HttpRequestBodyT> extends HttpEvent<
+  RequestSuccededEventPayload<HttpResponseT, HttpRequestBodyT>
+> {
   /**
    * @inheritdoc
    */
-  payload: RequestSuccededEventPayload<T, U>;
+  payload: RequestSuccededEventPayload<HttpResponseT, HttpRequestBodyT>;
 
-  constructor(payload: RequestSuccededEventPayload<T, U>) {
+  constructor(payload: RequestSuccededEventPayload<HttpResponseT, HttpRequestBodyT>) {
     super();
     this.payload = payload;
   }

src/events-manager/types.ts

@@ -6,6 +6,6 @@ export enum HttpEventIdentifier {
   RequestErrored = 'RequestErrored',
 }
 
-export type HttpEventHandler<T> = (payload: T) => void;
+export type HttpEventHandler<PayloadT> = (payload: PayloadT) => void;
 
-export type HttpEventClassType<T> = new (...args: unknown[]) => HttpEvent<T>;
+export type HttpEventClassType<PayloadT> = new (...args: unknown[]) => HttpEvent<PayloadT>;