style(typings): Added enhanced typings for combineLatest

Author: david-driscoll

src/CoreOperators.ts

@@ -16,7 +16,7 @@ export interface CoreOperators<T> {
   bufferWhen?: (closingSelector: () => Observable<any>) => Observable<T[]>;
   catch?: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
   combineAll?: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
-  combineLatest?: <R>(...observables: Array<Observable<any> | ((...values: Array<any>) => R)>) => Observable<R>;
+  combineLatest: operator.operator_proto_combineLatest<T>;
   concat?: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
   concatAll?: () => Observable<T>;
   concatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;

src/Observable.ts

@@ -19,11 +19,11 @@ import {combineLatest as combineLatestStatic} from './operator/combineLatest-sta
 import {concat as concatStatic} from './operator/concat-static';
 import {merge as mergeStatic} from './operator/merge-static';
 import {zip as zipStatic} from './operator/zip-static';
-import {BoundCallbackObservable} from './observable/bindCallback';
 import {DeferObservable} from './observable/defer';
 import {EmptyObservable} from './observable/empty';
 import {ForkJoinObservable} from './observable/forkJoin';
 import {FromObservable} from './observable/from';
+import {CallbackObservable} from './observable/fromCallback';
 import {ArrayObservable} from './observable/fromArray';
 import {FromEventObservable} from './observable/fromEvent';
 import {FromEventPatternObservable} from './observable/fromEventPattern';
@@ -178,7 +178,7 @@ export class Observable<T> implements CoreOperators<T>  {
   }
 
   // static method stubs
-  static bindCallback: typeof BoundCallbackObservable.create;
+  static bindCallback: typeof CallbackObservable.create;
   static combineLatest: typeof combineLatestStatic;
   static concat: typeof concatStatic;
   static defer: typeof DeferObservable.create;
@@ -206,9 +206,7 @@ export class Observable<T> implements CoreOperators<T>  {
   bufferWhen: (closingSelector: () => Observable<any>) => Observable<T[]>;
   catch: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
   combineAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
-  combineLatest: <R>(...observables: Array<Observable<any> |
-                                     Array<Observable<any>> |
-                                     ((...values: Array<any>) => R)>) => Observable<R>;
+  combineLatest: operator.operator_proto_combineLatest<T>;
   concat: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
   concatAll: () => Observable<any>;
   concatMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
@@ -269,9 +267,9 @@ export class Observable<T> implements CoreOperators<T>  {
   startWith: (x: T) => Observable<T>;
   subscribeOn: (scheduler: Scheduler, delay?: number) => Observable<T>;
   switch: <R>() => Observable<R>;
-  exhaust: <T>() => Observable<T>;
+  switchFirst: <T>() => Observable<T>;
   switchMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  exhaustMap: <T, R, R2>(project: (x: T, ix: number) => Observable<R>, rSelector?: (x: T, y: R, ix: number, iy: number) => R2) => Observable<R>;
+  switchFirstMap: <T, R, R2>(project: (x: T, ix: number) => Observable<R>, rSelector?: (x: T, y: R, ix: number, iy: number) => R2) => Observable<R>;
   switchMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   take: (count: number) => Observable<T>;
   takeUntil: (notifier: Observable<any>) => Observable<T>;

src/operator/combineLatest.ts

@@ -2,6 +2,7 @@ import {Observable} from '../Observable';
 import {ArrayObservable} from '../observable/fromArray';
 import {CombineLatestOperator} from './combineLatest-support';
 import {isArray} from '../util/isArray';
+import {ObservableInput} from '../types';
 
 /**
  * Combines the values from this observable with values from observables passed as arguments. This is done by subscribing
@@ -13,18 +14,58 @@ import {isArray} from '../util/isArray';
  * @returns {Observable} an observable of other projected values from the most recent values from each observable, or an array of each of
  * the most recent values from each observable.
  */
-export function combineLatest<R>(...observables: Array<Observable<any> |
-                                                       Array<Observable<any>> |
-                                                       ((...values: Array<any>) => R)>): Observable<R> {
-  let project: (...values: Array<any>) => R =  null;
+export function combineLatest<T, TResult>(project: (v1: T) => TResult): Observable<TResult>;
+export function combineLatest<T, TResult>(project: (v1: T) => TResult): Observable<TResult>;
+export function combineLatest<T, T2>(second: ObservableInput<T2>): Observable<[T, T2]>;
+export function combineLatest<T, T2>(array: [ObservableInput<T2>]): Observable<[T, T2]>;
+export function combineLatest<T, T2, TResult>(second: ObservableInput<T2>,
+                                              project: (v1: T, v2: T2) => TResult): Observable<TResult>;
+export function combineLatest<T, T2, TResult>(array: [
+                                                ObservableInput<T2>
+                                              ], project: (v1: T, v2: T2) => TResult): Observable<TResult>;
+export function combineLatest<T, T2, T3>(second: ObservableInput<T2>, third: ObservableInput<T3>): Observable<[T, T2, T3]>;
+export function combineLatest<T, T2, T3>(array: [
+                                            ObservableInput<T2>,
+                                            ObservableInput<T3>
+                                         ]): Observable<[T, T2, T3]>;
+export function combineLatest<T, T2, T3, TResult>(second: ObservableInput<T2>,
+                                                  third: ObservableInput<T3>,
+                                                  project: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+export function combineLatest<T, T2, T3, TResult>(array: [ObservableInput<T2>, ObservableInput<T3>],
+                                                  project: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+export function combineLatest<T, T2, T3, T4>(second: ObservableInput<T2>,
+                                             third: ObservableInput<T3>,
+                                             forth: ObservableInput<T4>): Observable<[T, T2, T3, T4]>;
+export function combineLatest<T, T2, T3, T4>(array: [
+                                                ObservableInput<T2>,
+                                                ObservableInput<T3>,
+                                                ObservableInput<T4>
+                                            ]): Observable<[T, T2, T3, T4]>;
+export function combineLatest<T, T2, T3, T4, TResult>(second: ObservableInput<T2>,
+                                                      third: ObservableInput<T3>,
+                                                      forth: ObservableInput<T4>,
+                                                      project: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+export function combineLatest<T, T2, T3, T4, TResult>(array: [
+                                                        ObservableInput<T2>,
+                                                        ObservableInput<T3>,
+                                                        ObservableInput<T4>
+                                                      ],
+                                                      project: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+export function combineLatest<T, TResult>(array: ObservableInput<any>[], project?: Function): Observable<TResult[]>;
+export function combineLatest<T>(...observables: Array<ObservableInput<T>>): Observable<T[]>;
+export function combineLatest<T, R>(...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): Observable<R>;
+export function combineLatest<R>(...observables: Array<any | Observable<any> |
+  Array<Promise<any>> |
+  ((...values: Array<any>) => R)>): Observable<R> {
+  let project: (...values: Array<any>) => R = null;
   if (typeof observables[observables.length - 1] === 'function') {
     project = <(...values: Array<any>) => R>observables.pop();
   }
 
   // if the first and only other argument besides the resultSelector is an array
   // assume it's been called with `combineLatest([obs1, obs2, obs3], project)`
   if (observables.length === 1 && isArray(observables[0])) {
-    observables = <Array<Observable<any>>>observables[0];
+    observables = <any>observables[0];
   }
 
   observables.unshift(this);