style(typings): added enhanced typings for bindCallback and combineLatest

Author: david-driscoll

package.json

@@ -19,7 +19,7 @@
     "build_closure": "java -jar ./node_modules/google-closure-compiler/compiler.jar ./dist/global/Rx.umd.js --language_in ECMASCRIPT5 --create_source_map ./dist/global/Rx.umd.min.js.map --js_output_file ./dist/global/Rx.umd.min.js",
     "build_global": "rm -rf dist/global && mkdir \"dist/global\" && node tools/make-umd-bundle.js && node tools/make-system-bundle.js && npm run build_closure",
     "build_perf": "npm run build_cjs && npm run build_global && webdriver-manager update && npm run perf",
-    "build_test": "rm -rf dist/ && npm run lint && npm run build_cjs && jasmine",
+    "build_test": "rm -rf dist/ && npm run lint && npm run build_cjs && tsc spec/typings/typing-tpecs.ts --outDir dist/tpec --target ES6 --diagnostics --pretty && jasmine",
     "build_cover": "rm -rf dist/ && npm run lint && npm run build_cjs && npm run cover",
     "build_docs": "./docgen.sh",
     "lint_perf": "eslint perf/",

spec/typings/observable/bindCallback-tpec.ts

@@ -0,0 +1,47 @@
+import {BoundCallbackObservable} from '../../../src/observable/bindCallback';
+import {Observable} from '../../../src/Observable';
+import {asap} from '../../../src/scheduler/asap';
+
+type t = { a: string };
+type t2 = { b: string };
+type t3 = { c: string };
+type t4 = { d: string };
+type t5 = { e: string };
+type t6 = { f: string };
+
+let observable: Observable<t>;
+let observable2: Observable<t2>;
+let observable3: Observable<t3>;
+let observable4: Observable<t4>;
+let observable5: Observable<t5>;
+let observable6: Observable<t6>;
+let numberObservable: Observable<number>;
+let booleanObservable: Observable<boolean>;
+
+/* tslint:disable:no-unused-variable *//* tslint:disable:max-line-length */
+observable = BoundCallbackObservable.create((callback: (a: t) => void) => { /* */ })();
+observable2 = BoundCallbackObservable.create((a: string, callback: (a: t2) => void) => { /* */ })('a');
+observable3 = BoundCallbackObservable.create((a: string, b: number, callback: (r: t3) => void) => { /* */ })('a', 2);
+observable4 = BoundCallbackObservable.create((a: string, b: number, c: boolean, callback: (r: t4) => void) => { /* */ })('a', 2, false);
+observable5 = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, callback: (r: t5) => void) => { /* */ })('a', 2, false, 4);
+observable6 = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, e: string, callback: (r: t6) => void) => { /* */ })('a', 2, false, 4, 'e');
+numberObservable = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, e: string, f: boolean, callback: (r: number) => void) => { /* */ })('a', 2, false, 4, 'e', true);
+
+observable = BoundCallbackObservable.create((callback: (a: t) => void) => { /* */ }, null, asap)();
+observable2 = BoundCallbackObservable.create((a: string, callback: (a: t2) => void) => { /* */ }, null, asap)('a');
+observable3 = BoundCallbackObservable.create((a: string, b: number, callback: (r: t3) => void) => { /* */ }, null, asap)('a', 2);
+observable4 = BoundCallbackObservable.create((a: string, b: number, c: boolean, callback: (r: t4) => void) => { /* */ }, null, asap)('a', 2, false);
+observable5 = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, callback: (r: t5) => void) => { /* */ }, null, asap)('a', 2, false, 4);
+observable6 = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, e: string, callback: (r: t6) => void) => { /* */ }, null, asap)('a', 2, false, 4, 'e');
+numberObservable = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, e: string, f: boolean, callback: (r: number) => void) => { /* */ }, null, asap)('a', 2, false, 4, 'e', true);
+
+let observableArr: Observable<t[]>;
+observableArr = BoundCallbackObservable.create<t[]>((callback: (...args: t2[]) => void) => { /* */ })();
+
+observable6 = BoundCallbackObservable.create((callback: (a: t, b: t2, c: t3) => void) => { /* */ }, (a: t, b: t2, c: t3) => <t6>{}, asap)();
+observable = BoundCallbackObservable.create((a: string, callback: (a: t2, b: t3, c: t4) => void) => { /* */ }, (a: t, b: t2, c: t3) => <t>{}, asap)('a');
+observable2 = BoundCallbackObservable.create((a: string, b: number, callback: (r: t3, b: t4, c: t5) => void) => { /* */ }, (a: t, b: t2, c: t3) => <t2>{}, asap)('a', 2);
+observable3 = BoundCallbackObservable.create((a: string, b: number, c: boolean, callback: (r: t4, b: t5, c: t6) => void) => { /* */ }, (a: t, b: t2, c: t3) => <t3>{}, asap)('a', 2, false);
+observable4 = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, callback: (r: t5, b: t5, c: t) => void) => { /* */ }, (a: t, b: t2, c: t3) => <t4>{}, asap)('a', 2, false, 4);
+observable5 = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, e: string, callback: (r: t6, b: t, c: t2) => void) => { /* */ }, (a: t, b: t2, c: t3) => <t5>{}, asap)('a', 2, false, 4, 'e');
+booleanObservable = BoundCallbackObservable.create((a: string, b: number, c: boolean, d: number, e: string, f: boolean, callback: (r: number) => void) => { /* */ }, (a: t, b: t2, c: t3) => false, asap)('a', 2, false, 4, 'e', true);

spec/typings/operator/combineLatest-tpec.ts

@@ -0,0 +1,45 @@
+import {CombineLatestDeclaration} from '../../../src/operator/combineLatest';
+import {Observable} from '../../../src/Observable';
+
+interface Tester<T> extends Observable<T> {
+  combineLatest: CombineLatestDeclaration<T>;
+}
+
+type t = { a: string };
+type t2 = { b: string };
+type t3 = { c: string };
+type t4 = { d: string };
+type t5 = { e: string };
+type t6 = { f: string };
+
+let observable: Tester<t>;
+let observable2: Observable<t2>;
+let observable3: Observable<t3>;
+let observable4: Observable<t4>;
+let observable5: Observable<t5>;
+let observable6: Observable<t6>;
+
+/* tslint:disable:no-unused-variable */
+let result0: Observable<[t]> = observable.combineLatest();
+let result1: Observable<[t, t2]> = observable.combineLatest(observable2);
+let result2: Observable<[t, t2, t3]> = observable.combineLatest(observable2, observable3);
+let result3: Observable<[t, t2, t3, t4]> = observable.combineLatest(observable2, observable3, observable4);
+let result4: Observable<[t, t2, t3, t4, t5]> = observable.combineLatest(observable2, observable3, observable4, observable5);
+let result5: Observable<[t, t2, t3, t4, t5, t6]> = observable.combineLatest(observable2, observable3, observable4, observable5, observable6);
+
+let project1: Observable<number> = observable.combineLatest(observable2,
+  (a, b) => a.a.length + b.b.length);
+let project2: Observable<number> = observable.combineLatest(observable2, observable3,
+  (a, b, c) => a.a.length + b.b.length + c.c.length);
+let project3: Observable<number> = observable.combineLatest(observable2, observable3, observable4,
+  (a, b, c, d) => a.a.length + b.b.length + c.c.length + d.d.length);
+let project4: Observable<number> = observable.combineLatest(observable2, observable3, observable4, observable5,
+  (a, b, c, d, e) => a.a.length + b.b.length + c.c.length + d.d.length + e.e.length);
+let project5: Observable<number> = observable.combineLatest(observable2, observable3, observable4, observable5, observable6,
+  (a, b, c, d, e, f) => a.a.length + b.b.length + c.c.length + d.d.length + e.e.length + f.f.length);
+
+let array: Observable<[t, t2, t3]> = observable.combineLatest<[t, t2, t3]>([observable2, observable3]);
+let arrayBool: Observable<boolean> = observable.combineLatest([observable2, observable3], (...args: any[]) => !!args.length);
+
+let rest: Observable<[t, t2, t3]> = observable.combineLatest<[t, t2, t3]>(...[observable2, observable3]);
+let restBool: Observable<boolean> = observable.combineLatest(...[observable2, observable3, (...args: any[]) => !!args.length]);

spec/typings/typing-tpecs.ts

@@ -0,0 +1,2 @@
+import './observable/bindCallback-tpec';
+import './operator/combineLatest-tpec';

src/CoreOperators.ts

@@ -5,6 +5,8 @@ import {Subject} from './Subject';
 import {GroupedObservable} from './operator/groupBy-support';
 import {Notification} from './Notification';
 
+import {CombineLatestDeclaration} from './operator/combineLatest';
+
 export interface CoreOperators<T> {
   buffer?: (closingNotifier: Observable<any>) => Observable<T[]>;
   bufferCount?: (bufferSize: number, startBufferEvery: number) => Observable<T[]>;
@@ -13,7 +15,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: CombineLatestDeclaration<this>;
   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

@@ -35,6 +35,8 @@ import {ErrorObservable} from './observable/throw';
 import {AjaxCreationMethod} from './observable/dom/ajax';
 import {WebSocketSubject} from './observable/dom/webSocket';
 
+import {CombineLatestDeclaration} from './operator/combineLatest';
+
 /**
  * A representation of any set of values over any amount of time. This the most basic building block
  * of RxJS.
@@ -196,9 +198,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: CombineLatestDeclaration<this>;
   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>;

src/add/operator/combineLatest.ts

@@ -5,6 +5,6 @@
 import {Observable} from '../../Observable';
 import {combineLatest} from '../../operator/combineLatest';
 
-Observable.prototype.combineLatest = combineLatest;
+Observable.prototype.combineLatest = <any>combineLatest;
 
 export var _void: void;

src/observable/bindCallback.ts

@@ -9,6 +9,24 @@ import {AsyncSubject} from '../subject/AsyncSubject';
 export class BoundCallbackObservable<T> extends Observable<T> {
   subject: AsyncSubject<T>;
 
+  /* tslint:disable:max-line-length */
+  static create<TResult>(callbackFunc: (callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): () => Observable<TResult>;
+  static create<T, TResult>(callbackFunc: (v1: T, callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): (v1: T) => Observable<TResult>;
+  static create<T, T2, TResult>(callbackFunc: (v1: T, v2: T2, callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): (v1: T, v2: T2) => Observable<TResult>;
+  static create<T, T2, T3, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3) => Observable<TResult>;
+  static create<T, T2, T3, T4, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, v4: T4, callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3, v4: T4) => Observable<TResult>;
+  static create<T, T2, T3, T4, T5, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => Observable<TResult>;
+  static create<T, T2, T3, T4, T5, T6, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, callback: (result: TResult) => any) => any, selector?: void, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => Observable<TResult>;
+  static create<TResult>(callbackFunc: (callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): () => Observable<TResult>;
+  static create<T, TResult>(callbackFunc: (v1: T, callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): (v1: T) => Observable<TResult>;
+  static create<T, T2, TResult>(callbackFunc: (v1: T, v2: T2, callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): (v1: T, v2: T2) => Observable<TResult>;
+  static create<T, T2, T3, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3) => Observable<TResult>;
+  static create<T, T2, T3, T4, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, v4: T4, callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3, v4: T4) => Observable<TResult>;
+  static create<T, T2, T3, T4, T5, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => Observable<TResult>;
+  static create<T, T2, T3, T4, T5, T6, TResult>(callbackFunc: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, callback: (...args: any[]) => any) => any, selector: (...args: any[]) => TResult, scheduler?: Scheduler): (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => Observable<TResult>;
+  static create<T>(callbackFunc: Function, selector?: void, scheduler?: Scheduler): (...args: any[]) => Observable<T>;
+  static create<T>(callbackFunc: Function, selector?: (...args: any[]) => T, scheduler?: Scheduler): (...args: any[]) => Observable<T>;
+  /* tslint:enable:max-line-length */
   static create<T>(callbackFunc: Function,
                    selector: Function | void = undefined,
                    scheduler?: Scheduler): (...args: any[]) => Observable<T> {

src/operator/combineLatest.ts

@@ -31,3 +31,28 @@ export function combineLatest<T, R>(...observables: Array<Observable<any> |
 
   return new ArrayObservable(observables).lift<T, R>(new CombineLatestOperator<T, R>(project));
 }
+
+/* These types would be come standard types used through-out the library */
+export type ObservableOrPromise<T> = Observable<T> | Promise<T>;
+export type ArrayOrIterator<T> = Iterator<T> | ArrayLike<T> | Array<T>;
+export type ObservableInput<T> = Observable<T> | Promise<T> | Iterator<T> | ArrayLike<T>;
+
+/* tslint:disable:max-line-length */
+export interface CombineLatestDeclaration<T> {
+  <T2>(v2: ObservableInput<T2>): Observable<[T, T2]>;
+  <T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<[T, T2, T3]>;
+  <T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<[T, T2, T3, T4]>;
+  <T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<[T, T2, T3, T4, T5]>;
+  <T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<[T, T2, T3, T4, T5, T6]>;
+
+  <R>(project: (v1: T) => R): Observable<R>;
+  <T2, R>(v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R): Observable<R>;
+  <T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R): Observable<R>;
+  <T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable<R>;
+  <T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable<R>;
+  <T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable<R>;
+
+  <R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;
+  <R>(array: ObservableInput<any>[]): Observable<R>;
+  <R>(array: ObservableInput<any>[], project: (...values: Array<any>) => R): Observable<R>;
+}

tsconfig.json

@@ -15,6 +15,7 @@
   },
    "files": [
      "src/Rx.ts",
-     "src/Rx.KitchenSink.ts"
+     "src/Rx.KitchenSink.ts",
+     "spec/typings/typing-tpecs.ts"
    ]
 }