refactor: Remove no-shadowed-variable tslint override

Author: benlesh

src/internal/Observable.ts

@@ -435,11 +435,11 @@ export class Observable<T> implements Subscribable<T> {
 
   /* tslint:disable:max-line-length */
   /** @deprecated Deprecated use {@link firstValueFrom} or {@link lastValueFrom} instead */
-  toPromise<T>(this: Observable<T>): Promise<T | undefined>;
+  toPromise(): Promise<T | undefined>;
   /** @deprecated Deprecated use {@link firstValueFrom} or {@link lastValueFrom} instead */
-  toPromise<T>(this: Observable<T>, PromiseCtor: typeof Promise): Promise<T | undefined>;
+  toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
   /** @deprecated Deprecated use {@link firstValueFrom} or {@link lastValueFrom} instead */
-  toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+  toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
   /* tslint:enable:max-line-length */
 
   /**

src/internal/Scheduler.ts

@@ -26,7 +26,7 @@ export class Scheduler implements SchedulerLike {
 
   public static now: () => number = dateTimestampProvider.now;
 
-  constructor(private SchedulerAction: typeof Action,
+  constructor(private schedulerActionCtor: typeof Action,
               now: () => number = Scheduler.now) {
     this.now = now;
   }
@@ -59,6 +59,6 @@ export class Scheduler implements SchedulerLike {
    * the scheduled work.
    */
   public schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number = 0, state?: T): Subscription {
-    return new this.SchedulerAction<T>(this, work).schedule(state, delay);
+    return new this.schedulerActionCtor<T>(this, work).schedule(state, delay);
   }
 }

src/internal/ajax/errors.ts

@@ -56,7 +56,7 @@ export interface AjaxErrorCtor {
  */
 export const AjaxError: AjaxErrorCtor = createErrorClass(
   (_super) =>
-    function AjaxError(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest) {
+    function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest) {
       this.message = message;
       this.name = 'AjaxError';
       this.xhr = xhr;
@@ -85,16 +85,6 @@ export interface AjaxTimeoutErrorCtor {
   new (xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
 }
 
-const AjaxTimeoutErrorImpl = (() => {
-  function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
-    AjaxError.call(this, 'ajax timeout', xhr, request);
-    this.name = 'AjaxTimeoutError';
-    return this;
-  }
-  AjaxTimeoutErrorImpl.prototype = Object.create(AjaxError.prototype);
-  return AjaxTimeoutErrorImpl;
-})();
-
 /**
  * Thrown when an AJAX request timesout. Not to be confused with {@link TimeoutError}.
  *
@@ -105,4 +95,12 @@ const AjaxTimeoutErrorImpl = (() => {
  * @class AjaxTimeoutError
  * @see ajax
  */
-export const AjaxTimeoutError: AjaxTimeoutErrorCtor = AjaxTimeoutErrorImpl as any;
+export const AjaxTimeoutError: AjaxTimeoutErrorCtor = (() => {
+  function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
+    AjaxError.call(this, 'ajax timeout', xhr, request);
+    this.name = 'AjaxTimeoutError';
+    return this;
+  }
+  AjaxTimeoutErrorImpl.prototype = Object.create(AjaxError.prototype);
+  return AjaxTimeoutErrorImpl;
+})() as any;

src/internal/observable/combineLatest.ts

@@ -359,7 +359,7 @@ export function combineLatest<R>(
 
 // combineLatest({})
 export function combineLatest(sourcesObject: {}): Observable<never>;
-export function combineLatest<T, K extends keyof T>(sourcesObject: T): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;
+export function combineLatest<T>(sourcesObject: T): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;
 
 /* tslint:enable:max-line-length */
 
@@ -504,10 +504,10 @@ export function combineLatest<O extends ObservableInput<any>, R>(...args: any[])
       scheduler,
       keys
         ? // A handler for scrubbing the array of args into a dictionary.
-          (args: any[]) => {
+          (values: any[]) => {
             const value: any = {};
-            for (let i = 0; i < args.length; i++) {
-              value[keys![i]] = args[i];
+            for (let i = 0; i < values.length; i++) {
+              value[keys![i]] = values[i];
             }
             return value;
           }

src/internal/observable/dom/WebSocketSubject.ts

@@ -278,7 +278,7 @@ export class WebSocketSubject<T> extends AnonymousSubject<T> {
       }
     });
 
-    socket.onopen = (e: Event) => {
+    socket.onopen = (evt: Event) => {
       const { _socket } = this;
       if (!_socket) {
         socket!.close();
@@ -287,7 +287,7 @@ export class WebSocketSubject<T> extends AnonymousSubject<T> {
       }
       const { openObserver } = this._config;
       if (openObserver) {
-        openObserver.next(e);
+        openObserver.next(evt);
       }
 
       const queue = this.destination;
@@ -303,13 +303,13 @@ export class WebSocketSubject<T> extends AnonymousSubject<T> {
             }
           }
         },
-        (e) => {
+        (err) => {
           const { closingObserver } = this._config;
           if (closingObserver) {
             closingObserver.next(undefined);
           }
-          if (e && e.code) {
-            socket!.close(e.code, e.reason);
+          if (err && err.code) {
+            socket!.close(err.code, err.reason);
           } else {
             observer.error(new TypeError(WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT));
           }

src/internal/observable/forkJoin.ts

@@ -57,7 +57,7 @@ export function forkJoin<A extends ObservableInput<any>[]>(sources: A): Observab
 
 // forkJoin({})
 export function forkJoin(sourcesObject: {}): Observable<never>;
-export function forkJoin<T, K extends keyof T>(sourcesObject: T): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;
+export function forkJoin<T>(sourcesObject: T): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;
 
 /** @deprecated resultSelector is deprecated, pipe to map instead */
 export function forkJoin(...args: Array<ObservableInput<any> | ((...args: any[]) => any)>): Observable<any>;
@@ -183,8 +183,8 @@ function forkJoinInternal(sources: ObservableInput<any>[], keys: string[] | null
     const values = new Array(len);
     let completed = 0;
     let emitted = 0;
-    for (let i = 0; i < len; i++) {
-      const source = innerFrom(sources[i]);
+    for (let sourceIndex = 0; sourceIndex < len; sourceIndex++) {
+      const source = innerFrom(sources[sourceIndex]);
       let hasValue = false;
       subscriber.add(
         source.subscribe({
@@ -193,7 +193,7 @@ function forkJoinInternal(sources: ObservableInput<any>[], keys: string[] | null
               hasValue = true;
               emitted++;
             }
-            values[i] = value;
+            values[sourceIndex] = value;
           },
           error: (err) => subscriber.error(err),
           complete: () => {

src/internal/observable/fromEvent.ts

@@ -214,7 +214,7 @@ export function fromEvent<T>(
     }
 
     if (isArrayLike(target)) {
-      return (mergeMap((target: any) => fromEvent(target, eventName, options as any))(internalFromArray(target)) as Observable<
+      return (mergeMap((subTarget: any) => fromEvent(subTarget, eventName, options as any))(internalFromArray(target)) as Observable<
         T
       >).subscribe(subscriber);
     }

src/internal/observable/zip.ts

@@ -204,12 +204,12 @@ export function zip<O extends ObservableInput<any>, R>(
         // Loop over our sources and subscribe to each one. The index `i` is
         // especially important here, because we use it in closures below to
         // access the related buffers and completion properties
-        for (let i = 0; !subscriber.closed && i < sources.length; i++) {
-          innerFrom(sources[i]).subscribe(
+        for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
+          innerFrom(sources[sourceIndex]).subscribe(
             new OperatorSubscriber(
               subscriber,
               (value) => {
-                buffers[i].push(value);
+                buffers[sourceIndex].push(value);
                 // if every buffer has at least one value in it, then we
                 // can shift out the oldest value from each buffer and emit
                 // them as an array.
@@ -230,11 +230,11 @@ export function zip<O extends ObservableInput<any>, R>(
               () => {
                 // This source completed. Mark it as complete so we can check it later
                 // if we have to.
-                completed[i] = true;
+                completed[sourceIndex] = true;
                 // But, if this complete source has nothing in its buffer, then we
                 // can complete the result, because we can't possibly have any more
                 // values from this to zip together with the oterh values.
-                !buffers[i].length && subscriber.complete();
+                !buffers[sourceIndex].length && subscriber.complete();
               }
             )
           );

src/internal/operators/buffer.ts

@@ -45,24 +45,24 @@ import { OperatorSubscriber } from './OperatorSubscriber';
  */
 export function buffer<T>(closingNotifier: Observable<any>): OperatorFunction<T, T[]> {
   return operate((source, subscriber) => {
-    let buffer: T[] = [];
+    let currentBuffer: T[] = [];
 
     // Subscribe to our source.
-    source.subscribe(new OperatorSubscriber(subscriber, (value) => buffer.push(value)));
+    source.subscribe(new OperatorSubscriber(subscriber, (value) => currentBuffer.push(value)));
 
     // Subscribe to the closing notifier.
     closingNotifier.subscribe(
       new OperatorSubscriber(subscriber, () => {
         // Start a new buffer and emit the previous one.
-        const b = buffer;
-        buffer = [];
+        const b = currentBuffer;
+        currentBuffer = [];
         subscriber.next(b);
       })
     );
 
     return () => {
       // Ensure buffered values are released on teardown.
-      buffer = null!;
+      currentBuffer = null!;
     };
   });
 }

src/internal/operators/count.ts

@@ -56,5 +56,5 @@ import { reduce } from './reduce';
  */
 
 export function count<T>(predicate?: (value: T, index: number) => boolean): OperatorFunction<T, number> {
-  return reduce((count, value, i) => (!predicate || predicate(value, i) ? count + 1 : count), 0);
+  return reduce((total, value, i) => (!predicate || predicate(value, i) ? total + 1 : total), 0);
 }