From e19cecf8d9cf3c7cb1386b4479bd7daff1c678fa Mon Sep 17 00:00:00 2001 From: David Driscoll Date: Sat, 13 Feb 2016 21:49:40 -0500 Subject: [PATCH] chore(typings): added type signatures for concat/exhaust/merge/switch also adds signatures for the "All", "Map", and "MapTo" variants. --- src/CoreOperators.ts | 49 +++++++++++------- src/Observable.ts | 50 +++++++++++-------- src/Rx.KitchenSink.ts | 7 +-- src/observable/BoundNodeCallbackObservable.ts | 2 +- src/observable/FromObservable.ts | 6 +-- src/observable/dom/WebSocketSubject.ts | 2 +- src/operator/combineAll.ts | 7 ++- src/operator/concat.ts | 33 ++++++++++-- src/operator/concatAll.ts | 6 ++- src/operator/concatMap.ts | 11 +++- src/operator/concatMapTo.ts | 17 ++++--- src/operator/exhaust.ts | 6 ++- src/operator/exhaustMap.ts | 37 +++++++------- src/operator/map.ts | 11 ++-- src/operator/merge.ts | 41 +++++++++++++-- src/operator/mergeAll.ts | 6 ++- src/operator/mergeMap.ts | 40 +++++++++------ src/operator/mergeMapTo.ts | 50 +++++++++++-------- src/operator/race.ts | 2 +- src/operator/switch.ts | 4 ++ src/operator/switchMap.ts | 37 +++++++------- src/operator/switchMapTo.ts | 41 ++++++++------- src/operator/zipAll.ts | 5 ++ src/util/input-types.ts | 5 ++ 24 files changed, 313 insertions(+), 162 deletions(-) create mode 100644 src/util/input-types.ts diff --git a/src/CoreOperators.ts b/src/CoreOperators.ts index 53e51e3eba9..edc88f34f73 100644 --- a/src/CoreOperators.ts +++ b/src/CoreOperators.ts @@ -18,6 +18,20 @@ import {WindowCountSignature} from './operator/windowCount'; import {WindowTimeSignature} from './operator/windowTime'; import {WindowToggleSignature} from './operator/windowToggle'; import {WindowWhenSignature} from './operator/windowWhen'; +import {CombineAllSignature} from './operator/combineAll'; +import {ConcatSignature} from './operator/concat'; +import {ConcatAllSignature} from './operator/concatAll'; +import {ConcatMapSignature} from './operator/concatMap'; +import {ConcatMapToSignature} from './operator/concatMapTo'; +import {MapSignature} from './operator/map'; +import {MergeSignature} from './operator/merge'; +import {MergeAllSignature} from './operator/mergeAll'; +import {MergeMapSignature} from './operator/mergeMap'; +import {MergeMapToSignature} from './operator/mergeMapTo'; +import {SwitchSignature} from './operator/switch'; +import {SwitchMapSignature} from './operator/switchMap'; +import {SwitchMapToSignature} from './operator/switchMapTo'; +import {ZipAllSignature} from './operator/zipAll'; export interface CoreOperators { buffer: BufferSignature; @@ -26,12 +40,12 @@ export interface CoreOperators { bufferToggle: BufferToggleSignature; bufferWhen: BufferWhenSignature; catch?: (selector: (err: any, source: Observable, caught: Observable) => Observable) => Observable; - combineAll?: (project?: (...values: Array) => R) => Observable; + combineAll: CombineAllSignature; combineLatest: CombineLatestSignature; - concat?: (...observables: (Observable | Scheduler)[]) => Observable; - concatAll?: () => Observable; - concatMap?: (project: ((x: T, ix: number) => Observable), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; - concatMapTo?: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; + concat: ConcatSignature; + concatAll: ConcatAllSignature; + concatMap: ConcatMapSignature; + concatMapTo: ConcatMapToSignature; count?: (predicate?: (value: T, index: number, source: Observable) => boolean) => Observable; dematerialize?: () => Observable; debounce?: (durationSelector: (value: T) => Observable | Promise) => Observable; @@ -46,10 +60,8 @@ export interface CoreOperators { finally?: (finallySelector: () => void) => Observable; first?: (predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable | Observable; - flatMap?: (project: ((x: T, ix: number) => Observable), - projectResult?: (x: T, y: any, ix: number, iy: number) => R, - concurrent?: number) => Observable; - flatMapTo?: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable; + flatMap: MergeMapSignature; + flatMapTo: MergeMapToSignature; groupBy?: (keySelector: (value: T) => string, elementSelector?: (value: T) => R, durationSelector?: (group: GroupedObservable) => Observable) => Observable>; @@ -60,14 +72,13 @@ export interface CoreOperators { resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable | Observable; every?: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable; - map?: (project: (x: T, ix?: number) => R, thisArg?: any) => Observable; + map: MapSignature; mapTo?: (value: R) => Observable; materialize?: () => Observable>; - merge?: (...observables: any[]) => Observable; - mergeAll?: (concurrent?: number) => Observable; - mergeMap?: (project: ((x: T, ix: number) => Observable), - projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable; - mergeMapTo?: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable; + merge: MergeSignature; + mergeAll: MergeAllSignature; + mergeMap: MergeMapSignature; + mergeMapTo: MergeMapToSignature; multicast?: (subjectOrSubjectFactory: Subject|(() => Subject)) => ConnectableObservable; observeOn?: (scheduler: Scheduler, delay?: number) => Observable; partition?: (predicate: (x: T) => boolean) => Observable[]; @@ -89,9 +100,9 @@ export interface CoreOperators { skipWhile?: (predicate: (x: T, index: number) => boolean) => Observable; startWith?: (x: T) => Observable; subscribeOn?: (scheduler: Scheduler, delay?: number) => Observable; - switch?: () => Observable; - switchMap?: (project: ((x: T, ix: number) => Observable), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; - switchMapTo?: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; + switch: SwitchSignature; + switchMap: SwitchMapSignature; + switchMapTo: SwitchMapToSignature; take?: (count: number) => Observable; takeLast?: (count: number) => Observable; takeUntil?: (notifier: Observable) => Observable; @@ -109,5 +120,5 @@ export interface CoreOperators { windowWhen: WindowWhenSignature; withLatestFrom: WithLatestFromSignature; zip: ZipSignature; - zipAll?: (project?: (...values: Array) => R) => Observable; + zipAll: ZipAllSignature; } diff --git a/src/Observable.ts b/src/Observable.ts index a31a6a44695..88d247f30f4 100644 --- a/src/Observable.ts +++ b/src/Observable.ts @@ -50,6 +50,20 @@ import {WindowCountSignature} from './operator/windowCount'; import {WindowTimeSignature} from './operator/windowTime'; import {WindowToggleSignature} from './operator/windowToggle'; import {WindowWhenSignature} from './operator/windowWhen'; +import {CombineAllSignature} from './operator/combineAll'; +import {ConcatSignature} from './operator/concat'; +import {ConcatAllSignature} from './operator/concatAll'; +import {ConcatMapSignature} from './operator/concatMap'; +import {ConcatMapToSignature} from './operator/concatMapTo'; +import {MapSignature} from './operator/map'; +import {MergeSignature} from './operator/merge'; +import {MergeAllSignature} from './operator/mergeAll'; +import {MergeMapSignature} from './operator/mergeMap'; +import {MergeMapToSignature} from './operator/mergeMapTo'; +import {SwitchSignature} from './operator/switch'; +import {SwitchMapSignature} from './operator/switchMap'; +import {SwitchMapToSignature} from './operator/switchMapTo'; +import {ZipAllSignature} from './operator/zipAll'; export type ObservableOrPromise = Observable | Promise; export type ArrayOrIterator = Iterator | ArrayLike; @@ -212,12 +226,12 @@ export class Observable implements CoreOperators { bufferWhen: BufferWhenSignature; cache: (bufferSize?: number, windowTime?: number, scheduler?: Scheduler) => Observable; catch: (selector: (err: any, source: Observable, caught: Observable) => Observable) => Observable; - combineAll: (project?: (...values: Array) => R) => Observable; + combineAll: CombineAllSignature; combineLatest: CombineLatestSignature; - concat: (...observables: (Observable | Scheduler)[]) => Observable; - concatAll: () => Observable; - concatMap: (project: ((x: T, ix: number) => Observable), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; - concatMapTo: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; + concat: ConcatSignature; + concatAll: ConcatAllSignature; + concatMap: ConcatMapSignature; + concatMapTo: ConcatMapToSignature; count: (predicate?: (value: T, index: number, source: Observable) => boolean) => Observable; dematerialize: () => Observable; debounce: (durationSelector: (value: T) => Observable | Promise) => Observable; @@ -232,10 +246,8 @@ export class Observable implements CoreOperators { finally: (finallySelector: () => void) => Observable; first: (predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable | Observable; - flatMap: (project: ((x: T, ix: number) => Observable), - projectResult?: (x: T, y: any, ix: number, iy: number) => R, - concurrent?: number) => Observable; - flatMapTo: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable; + flatMap: MergeMapSignature; + flatMapTo: MergeMapToSignature; groupBy: (keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (group: GroupedObservable) => Observable) => Observable>; @@ -248,15 +260,13 @@ export class Observable implements CoreOperators { let: (func: (selector: Observable) => Observable) => Observable; letBind: (func: (selector: Observable) => Observable) => Observable; every: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable; - map: (project: (x: T, ix?: number) => R, thisArg?: any) => Observable; + map: MapSignature; mapTo: (value: R) => Observable; materialize: () => Observable>; - merge: (...observables: any[]) => Observable; - mergeAll: (concurrent?: any) => Observable; - mergeMap: (project: ((x: T, ix: number) => Observable), - projectResult?: (x: T, y: any, ix: number, iy: number) => R, - concurrent?: number) => Observable; - mergeMapTo: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable; + merge: MergeSignature; + mergeAll: MergeAllSignature; + mergeMap: MergeMapSignature; + mergeMapTo: MergeMapToSignature; multicast: (subjectOrSubjectFactory: Subject|(() => Subject)) => ConnectableObservable; observeOn: (scheduler: Scheduler, delay?: number) => Observable; partition: (predicate: (x: T) => boolean) => Observable[]; @@ -280,9 +290,9 @@ export class Observable implements CoreOperators { skipWhile: (predicate: (x: T, index: number) => boolean) => Observable; startWith: (x: T) => Observable; subscribeOn: (scheduler: Scheduler, delay?: number) => Observable; - switch: () => Observable; - switchMap: (project: ((x: T, ix: number) => Observable), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; - switchMapTo: (observable: Observable, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; + switch: SwitchSignature; + switchMap: SwitchMapSignature; + switchMapTo: SwitchMapToSignature; take: (count: number) => Observable; takeLast: (count: number) => Observable; takeUntil: (notifier: Observable) => Observable; @@ -300,7 +310,7 @@ export class Observable implements CoreOperators { windowWhen: WindowWhenSignature; withLatestFrom: WithLatestFromSignature; zip: ZipSignature; - zipAll: (project?: (...values: Array) => R) => Observable; + zipAll: ZipAllSignature; /** * @method Symbol.observable diff --git a/src/Rx.KitchenSink.ts b/src/Rx.KitchenSink.ts index 99cfc51337c..831a7761b49 100644 --- a/src/Rx.KitchenSink.ts +++ b/src/Rx.KitchenSink.ts @@ -4,6 +4,8 @@ import {Subject} from './Subject'; import {Observable} from './Observable'; import {CoreOperators} from './CoreOperators'; import {Scheduler as IScheduler} from './Scheduler'; +import {SwitchFirstSignature} from './operator/exhaust'; +import {SwitchFirstMapSignature} from './operator/exhaustMap'; export interface KitchenSinkOperators extends CoreOperators { isEmpty?: () => Observable; @@ -18,9 +20,8 @@ export interface KitchenSinkOperators extends CoreOperators { pairwise?: () => Observable; timeInterval?: (scheduler?: IScheduler) => Observable; mergeScan?: (project: (acc: R, x: T) => Observable, seed: R, concurrent?: number) => Observable; - exhaust?: () => Observable; - exhaustMap?: (project: ((x: T, ix: number) => Observable), - projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable; + exhaust?: SwitchFirstSignature; + exhaustMap?: SwitchFirstMapSignature; } // statics diff --git a/src/observable/BoundNodeCallbackObservable.ts b/src/observable/BoundNodeCallbackObservable.ts index 6512d72e9cd..847058b6e3d 100644 --- a/src/observable/BoundNodeCallbackObservable.ts +++ b/src/observable/BoundNodeCallbackObservable.ts @@ -24,7 +24,7 @@ export class BoundNodeCallbackObservable extends Observable { selector: Function | void = undefined, scheduler?: Scheduler): Function { return (...args: any[]): Observable => { - return new BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler); + return new BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler); }; } diff --git a/src/observable/FromObservable.ts b/src/observable/FromObservable.ts index ef54497e6d9..18f4fbac381 100644 --- a/src/observable/FromObservable.ts +++ b/src/observable/FromObservable.ts @@ -35,11 +35,11 @@ export class FromObservable extends Observable { if (ish instanceof Observable && !scheduler) { return ish; } - return new FromObservable(ish, scheduler); + return new FromObservable(ish, scheduler); } else if (isArray(ish)) { - return new ArrayObservable(ish, scheduler); + return new ArrayObservable(ish, scheduler); } else if (isPromise(ish)) { - return new PromiseObservable(ish, scheduler); + return new PromiseObservable(ish, scheduler); } else if (typeof ish[SymbolShim.iterator] === 'function' || typeof ish === 'string') { return new IteratorObservable(ish, null, null, scheduler); } else if (isArrayLike(ish)) { diff --git a/src/observable/dom/WebSocketSubject.ts b/src/observable/dom/WebSocketSubject.ts index 5806b86fc04..3fdba0656ea 100644 --- a/src/observable/dom/WebSocketSubject.ts +++ b/src/observable/dom/WebSocketSubject.ts @@ -34,7 +34,7 @@ export class WebSocketSubject extends Subject { } static create(urlConfigOrSource: string | WebSocketSubjectConfig): WebSocketSubject { - return new WebSocketSubject(urlConfigOrSource); + return new WebSocketSubject(urlConfigOrSource); } constructor(urlConfigOrSource: string | WebSocketSubjectConfig | Observable, destination?: Observer) { diff --git a/src/operator/combineAll.ts b/src/operator/combineAll.ts index 3dd1adfae90..902349fa4dd 100644 --- a/src/operator/combineAll.ts +++ b/src/operator/combineAll.ts @@ -13,6 +13,11 @@ import {Observable} from '../Observable'; * most recent values from each collected observable as arguments, in order. * @returns {Observable} an observable of projected results or arrays of recent values. */ -export function combineAll(project?: (...values: Array) => R): Observable { +export function combineAll(project?: (...values: Array) => R): Observable { return this.lift(new CombineLatestOperator(project)); } + +export interface CombineAllSignature { + (): Observable; + (project?: (...values: Array) => R): Observable; +} diff --git a/src/operator/concat.ts b/src/operator/concat.ts index e4594c9c56c..1fdf8cab63d 100644 --- a/src/operator/concat.ts +++ b/src/operator/concat.ts @@ -1,4 +1,4 @@ -import {Observable} from '../Observable'; +import {Observable, ObservableInput} from '../Observable'; import {Scheduler} from '../Scheduler'; import {isScheduler} from '../util/isScheduler'; import {ArrayObservable} from '../observable/ArrayObservable'; @@ -12,10 +12,23 @@ import {MergeAllOperator} from './mergeAll'; * @params {Scheduler} [scheduler] an optional scheduler to schedule each observable subscription on. * @returns {Observable} All values of each passed observable merged into a single observable, in order, in serial fashion. */ -export function concat(...observables: Array | Scheduler>): Observable { - return concatStatic(this, ...observables); +export function concat(...observables: Array | Scheduler>): Observable { + return concatStatic(this, ...observables); } +/* tslint:disable:max-line-length */ +export interface ConcatSignature { + (scheduler?: Scheduler): Observable; + (v2: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; + (...observables: Array | Scheduler>): Observable; + (...observables: Array | Scheduler>): Observable; +} +/* tslint:enable:max-line-length */ + /** * Joins multiple observables together by subscribing to them one at a time and merging their results * into the returned observable. Will wait for each observable to complete before moving on to the next. @@ -23,12 +36,22 @@ export function concat(...observables: Array | Scheduler>) * @params {Scheduler} [scheduler] an optional scheduler to schedule each observable subscription on. * @returns {Observable} All values of each passed observable merged into a single observable, in order, in serial fashion. */ -export function concatStatic(...observables: Array | Scheduler>): Observable { +/* tslint:disable:max-line-length */ +export function concatStatic(v1: ObservableInput, scheduler?: Scheduler): Observable; +export function concatStatic(v1: ObservableInput, v2: ObservableInput, scheduler?: Scheduler): Observable; +export function concatStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; +export function concatStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; +export function concatStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; +export function concatStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; +export function concatStatic(...observables: (ObservableInput | Scheduler)[]): Observable; +export function concatStatic(...observables: (ObservableInput | Scheduler)[]): Observable; +/* tslint:enable:max-line-length */ +export function concatStatic(...observables: Array | Scheduler>): Observable { let scheduler: Scheduler = null; let args = observables; if (isScheduler(args[observables.length - 1])) { scheduler = args.pop(); } - return new ArrayObservable(observables, scheduler).lift(new MergeAllOperator(1)); + return new ArrayObservable(observables, scheduler).lift(new MergeAllOperator(1)); } diff --git a/src/operator/concatAll.ts b/src/operator/concatAll.ts index 1f5eb64cbbd..b0edd13c945 100644 --- a/src/operator/concatAll.ts +++ b/src/operator/concatAll.ts @@ -12,5 +12,9 @@ import {MergeAllOperator} from './mergeAll'; * @returns {Observable} an observable of values merged from the incoming observables. */ export function concatAll(): T { - return this.lift(new MergeAllOperator(1)); + return this.lift(new MergeAllOperator(1)); +} + +export interface ConcatAllSignature { + (): T; } diff --git a/src/operator/concatMap.ts b/src/operator/concatMap.ts index 2dfcf02adfe..831e0986b64 100644 --- a/src/operator/concatMap.ts +++ b/src/operator/concatMap.ts @@ -1,5 +1,6 @@ import {MergeMapOperator} from './mergeMap'; import {Observable} from '../Observable'; +import {_mergeMapProject, _mergeMapResultSelector} from '../util/input-types'; /** * Maps values from the source observable into new Observables, then merges them in a serialized fashion, @@ -20,7 +21,13 @@ import {Observable} from '../Observable'; * @returns {Observable} an observable of values merged from the projected Observables as they were subscribed to, * one at a time. Optionally, these values may have been projected from a passed `projectResult` argument. */ -export function concatMap(project: (value: T, index: number) => Observable, - resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { +export function concatMap(project: _mergeMapProject, + resultSelector?: _mergeMapResultSelector) { return this.lift(new MergeMapOperator(project, resultSelector, 1)); } + +export interface ConcatMapSignature { + (project: _mergeMapProject): Observable; + (project: _mergeMapProject, + resultSelector: _mergeMapResultSelector): Observable; +} diff --git a/src/operator/concatMapTo.ts b/src/operator/concatMapTo.ts index c702064dea1..f764fc11df9 100644 --- a/src/operator/concatMapTo.ts +++ b/src/operator/concatMapTo.ts @@ -1,5 +1,6 @@ -import {Observable} from '../Observable'; +import {Observable, ObservableInput} from '../Observable'; import {MergeMapToOperator} from './mergeMapTo'; +import {_mergeMapResultSelector} from '../util/input-types'; /** * Maps values from the source to a specific observable, and merges them together in a serialized fashion. @@ -14,11 +15,13 @@ import {MergeMapToOperator} from './mergeMapTo'; * @returns {Observable} an observable of values merged together by joining the passed observable * with itself, one after the other, for each value emitted from the source. */ -export function concatMapTo(observable: Observable, - resultSelector?: ( - outerValue: T, - innerValue: R, - outerIndex: number, - innerIndex: number) => R2): Observable { +export function concatMapTo(observable: Observable, + resultSelector?: _mergeMapResultSelector): Observable { return this.lift(new MergeMapToOperator(observable, resultSelector, 1)); } + +export interface ConcatMapToSignature { + (observable: ObservableInput): Observable; + (observable: ObservableInput, + resultSelector: _mergeMapResultSelector): Observable; +} diff --git a/src/operator/exhaust.ts b/src/operator/exhaust.ts index 070a135decb..a534bbb89b5 100644 --- a/src/operator/exhaust.ts +++ b/src/operator/exhaust.ts @@ -13,7 +13,11 @@ import {subscribeToResult} from '../util/subscribeToResult'; * @returns {Observable} an Observable which contains all of the items of the first Observable and following Observables in the source. */ export function exhaust(): Observable { - return this.lift(new SwitchFirstOperator()); + return this.lift(new SwitchFirstOperator()); +} + +export interface SwitchFirstSignature { + (): T; } class SwitchFirstOperator implements Operator { diff --git a/src/operator/exhaustMap.ts b/src/operator/exhaustMap.ts index b6dbc09ebd5..2dfd78cd770 100644 --- a/src/operator/exhaustMap.ts +++ b/src/operator/exhaustMap.ts @@ -4,6 +4,7 @@ import {Subscriber} from '../Subscriber'; import {OuterSubscriber} from '../OuterSubscriber'; import {InnerSubscriber} from '../InnerSubscriber'; import {subscribeToResult} from '../util/subscribeToResult'; +import {_mergeMapProject, _mergeMapResultSelector} from '../util/input-types'; /** * Returns an Observable that applies the given function to each item of the source Observable @@ -12,33 +13,35 @@ import {subscribeToResult} from '../util/subscribeToResult'; * @param {function} [resultSelector] optional function for then selecting on each inner Observable. * @returns {Observable} an Observable containing all the projected Observables of each item of the source concatenated together. */ -export function exhaustMap(project: (value: T, index: number) => Observable, - resultSelector?: ( - outerValue: T, - innerValue: R, - outerIndex: number, - innerIndex: number) => R2): Observable { +export function exhaustMap(project: _mergeMapProject, + resultSelector?: _mergeMapResultSelector): Observable { return this.lift(new SwitchFirstMapOperator(project, resultSelector)); } -class SwitchFirstMapOperator implements Operator { - constructor(private project: (value: T, index: number) => Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { +export interface SwitchFirstMapSignature { + (project: _mergeMapProject): Observable; + (project: _mergeMapProject, + resultSelector: _mergeMapResultSelector): Observable; +} + +class SwitchFirstMapOperator implements Operator { + constructor(private project: _mergeMapProject, + private resultSelector?: _mergeMapResultSelector) { } - call(subscriber: Subscriber): Subscriber { + call(subscriber: Subscriber): Subscriber { return new SwitchFirstMapSubscriber(subscriber, this.project, this.resultSelector); } } -class SwitchFirstMapSubscriber extends OuterSubscriber { +class SwitchFirstMapSubscriber extends OuterSubscriber { private hasSubscription: boolean = false; private hasCompleted: boolean = false; private index: number = 0; - constructor(destination: Subscriber, - private project: (value: T, index: number) => Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { + constructor(destination: Subscriber, + private project: _mergeMapProject, + private resultSelector?: _mergeMapResultSelector) { super(destination); } @@ -67,9 +70,9 @@ class SwitchFirstMapSubscriber extends OuterSubscriber { } } - notifyNext(outerValue: T, innerValue: R, + notifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number, - innerSub: InnerSubscriber): void { + innerSub: InnerSubscriber): void { const { resultSelector, destination } = this; if (resultSelector) { this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex); @@ -78,7 +81,7 @@ class SwitchFirstMapSubscriber extends OuterSubscriber { } } - private trySelectResult(outerValue: T, innerValue: R, + private trySelectResult(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): void { const { resultSelector, destination } = this; try { diff --git a/src/operator/map.ts b/src/operator/map.ts index 929fd5fd3a1..7f3897d0c1f 100644 --- a/src/operator/map.ts +++ b/src/operator/map.ts @@ -1,6 +1,7 @@ import {Operator} from '../Operator'; import {Subscriber} from '../Subscriber'; import {Observable} from '../Observable'; +import {_mapProject} from '../util/input-types'; /** * Similar to the well known `Array.prototype.map` function, this operator @@ -12,15 +13,19 @@ import {Observable} from '../Observable'; * @param {any} [thisArg] an optional argument to define what `this` is in the project function * @returns {Observable} a observable of projected values */ -export function map(project: (value: T, index: number) => R, thisArg?: any): Observable { +export function map(project: _mapProject, thisArg?: any): Observable { if (typeof project !== 'function') { throw new TypeError('argument is not a function. Are you looking for `mapTo()`?'); } return this.lift(new MapOperator(project, thisArg)); } +export interface MapSignature { + (project: _mapProject, thisArg?: any): Observable; +} + class MapOperator implements Operator { - constructor(private project: (value: T, index: number) => R, private thisArg: any) { + constructor(private project: _mapProject, private thisArg: any) { } call(subscriber: Subscriber): Subscriber { @@ -33,7 +38,7 @@ class MapSubscriber extends Subscriber { private thisArg: any; constructor(destination: Subscriber, - private project: (value: T, index: number) => R, + private project: _mapProject, thisArg: any) { super(destination); this.thisArg = thisArg || this; diff --git a/src/operator/merge.ts b/src/operator/merge.ts index 2c6984fcb7d..f47fdf8ec72 100644 --- a/src/operator/merge.ts +++ b/src/operator/merge.ts @@ -1,4 +1,4 @@ -import {Observable} from '../Observable'; +import {Observable, ObservableInput} from '../Observable'; import {Scheduler} from '../Scheduler'; import {ArrayObservable} from '../observable/ArrayObservable'; import {MergeAllOperator} from './mergeAll'; @@ -12,12 +12,47 @@ import {isScheduler} from '../util/isScheduler'; * @param {Observable} input Observables * @returns {Observable} an Observable that emits items that are the result of every input Observable. */ -export function merge(...observables: Array | Scheduler | number>): Observable { +export function merge(...observables: Array | Scheduler | number>): Observable { observables.unshift(this); return mergeStatic.apply(this, observables); } -export function mergeStatic(...observables: Array | Scheduler | number>): Observable { +/* tslint:disable:max-line-length */ +export interface MergeSignature { + (scheduler?: Scheduler): Observable; + (concurrent?: number, scheduler?: Scheduler): Observable; + (v2: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; + (v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; + (...observables: Array | Scheduler | number>): Observable; + (...observables: Array | Scheduler | number>): Observable; +} +/* tslint:enable:max-line-length */ + +/* tslint:disable:max-line-length */ +export function mergeStatic(v1: ObservableInput, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; +export function mergeStatic(v1: ObservableInput, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function mergeStatic(...observables: (ObservableInput | Scheduler | number)[]): Observable; +export function mergeStatic(...observables: (ObservableInput | Scheduler | number)[]): Observable; +/* tslint:enable:max-line-length */ +export function mergeStatic(...observables: Array | Scheduler | number>): Observable { let concurrent = Number.POSITIVE_INFINITY; let scheduler: Scheduler = null; let last: any = observables[observables.length - 1]; diff --git a/src/operator/mergeAll.ts b/src/operator/mergeAll.ts index 314f206e8ea..f2b79ed82b1 100644 --- a/src/operator/mergeAll.ts +++ b/src/operator/mergeAll.ts @@ -6,7 +6,11 @@ import {OuterSubscriber} from '../OuterSubscriber'; import {subscribeToResult} from '../util/subscribeToResult'; export function mergeAll(concurrent: number = Number.POSITIVE_INFINITY): T { - return this.lift(new MergeAllOperator(concurrent)); + return this.lift(new MergeAllOperator(concurrent)); +} + +export interface MergeAllSignature { + (): T; } export class MergeAllOperator implements Operator, T> { diff --git a/src/operator/mergeMap.ts b/src/operator/mergeMap.ts index 586be059800..72f01797adf 100644 --- a/src/operator/mergeMap.ts +++ b/src/operator/mergeMap.ts @@ -5,6 +5,7 @@ import {Subscription} from '../Subscription'; import {subscribeToResult} from '../util/subscribeToResult'; import {OuterSubscriber} from '../OuterSubscriber'; import {InnerSubscriber} from '../InnerSubscriber'; +import {_mergeMapProject, _mergeMapResultSelector} from '../util/input-types'; /** * Returns an Observable that emits items based on applying a function that you supply to each item emitted by the @@ -17,34 +18,41 @@ import {InnerSubscriber} from '../InnerSubscriber'; * @returns {Observable} an Observable that emits the result of applying the transformation function to each item * emitted by the source Observable and merging the results of the Observables obtained from this transformation */ -export function mergeMap(project: (value: T, index: number) => Observable, - resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2 | number, - concurrent: number = Number.POSITIVE_INFINITY): Observable { +export function mergeMap(project: _mergeMapProject, + resultSelector?: _mergeMapResultSelector | number, + concurrent: number = Number.POSITIVE_INFINITY): Observable { return this.lift(new MergeMapOperator(project, resultSelector, concurrent)); } -export class MergeMapOperator implements Operator { - constructor(private project: (value: T, index: number) => Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2, +export interface MergeMapSignature { + (project: _mergeMapProject, concurrent?: number): Observable; + (project: _mergeMapProject, + resultSelector: _mergeMapResultSelector, + concurrent?: number): Observable; +} + +export class MergeMapOperator implements Operator { + constructor(private project: _mergeMapProject, + private resultSelector?: _mergeMapResultSelector, private concurrent: number = Number.POSITIVE_INFINITY) { } - call(observer: Subscriber): Subscriber { + call(observer: Subscriber): Subscriber { return new MergeMapSubscriber( observer, this.project, this.resultSelector, this.concurrent ); } } -export class MergeMapSubscriber extends OuterSubscriber { +export class MergeMapSubscriber extends OuterSubscriber { private hasCompleted: boolean = false; private buffer: Observable[] = []; private active: number = 0; protected index: number = 0; - constructor(destination: Subscriber, - private project: (value: T, index: number) => Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2, + constructor(destination: Subscriber, + private project: _mergeMapProject, + private resultSelector?: _mergeMapResultSelector, private concurrent: number = Number.POSITIVE_INFINITY) { super(destination); } @@ -71,7 +79,7 @@ export class MergeMapSubscriber extends OuterSubscriber { } private _innerSub(ish: any, value: T, index: number): void { - this.add(subscribeToResult(this, ish, value, index)); + this.add(subscribeToResult(this, ish, value, index)); } protected _complete(): void { @@ -81,9 +89,9 @@ export class MergeMapSubscriber extends OuterSubscriber { } } - notifyNext(outerValue: T, innerValue: R, + notifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number, - innerSub: InnerSubscriber): void { + innerSub: InnerSubscriber): void { if (this.resultSelector) { this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex); } else { @@ -91,8 +99,8 @@ export class MergeMapSubscriber extends OuterSubscriber { } } - _notifyResultSelector(outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) { - let result: any; + _notifyResultSelector(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) { + let result: R; try { result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex); } catch (err) { diff --git a/src/operator/mergeMapTo.ts b/src/operator/mergeMapTo.ts index 0d08f352b3d..70914dea9d1 100644 --- a/src/operator/mergeMapTo.ts +++ b/src/operator/mergeMapTo.ts @@ -1,4 +1,4 @@ -import {Observable} from '../Observable'; +import {Observable, ObservableInput} from '../Observable'; import {Operator} from '../Operator'; import {PartialObserver} from '../Observer'; import {Subscriber} from '../Subscriber'; @@ -6,35 +6,43 @@ import {Subscription} from '../Subscription'; import {OuterSubscriber} from '../OuterSubscriber'; import {InnerSubscriber} from '../InnerSubscriber'; import {subscribeToResult} from '../util/subscribeToResult'; +import {_mergeMapResultSelector} from '../util/input-types'; -export function mergeMapTo(observable: Observable, - resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2 | number, - concurrent: number = Number.POSITIVE_INFINITY): Observable { +export function mergeMapTo(observable: Observable, + resultSelector?: _mergeMapResultSelector | number, + concurrent: number = Number.POSITIVE_INFINITY): Observable { return this.lift(new MergeMapToOperator(observable, resultSelector, concurrent)); } -// TODO: Figure out correct signature here: an Operator, R2> -// needs to implement call(observer: Subscriber): Subscriber> -export class MergeMapToOperator implements Operator, R2> { - constructor(private ish: Observable | Promise, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2, +export interface MergeMapToSignature { + (observable: ObservableInput, concurrent?: number): Observable; + (observable: ObservableInput, + resultSelector: _mergeMapResultSelector, + concurrent?: number): Observable; +} + +// TODO: Figure out correct signature here: an Operator, R> +// needs to implement call(observer: Subscriber): Subscriber> +export class MergeMapToOperator implements Operator, R> { + constructor(private ish: Observable | Promise, + private resultSelector?: _mergeMapResultSelector, private concurrent: number = Number.POSITIVE_INFINITY) { } - call(observer: Subscriber): Subscriber { + call(observer: Subscriber): Subscriber { return new MergeMapToSubscriber(observer, this.ish, this.resultSelector, this.concurrent); } } -export class MergeMapToSubscriber extends OuterSubscriber { +export class MergeMapToSubscriber extends OuterSubscriber { private hasCompleted: boolean = false; private buffer: Observable[] = []; private active: number = 0; protected index: number = 0; - constructor(destination: Subscriber, - private ish: Observable | Promise, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2, + constructor(destination: Subscriber, + private ish: Observable | Promise, + private resultSelector?: _mergeMapResultSelector, private concurrent: number = Number.POSITIVE_INFINITY) { super(destination); } @@ -54,11 +62,11 @@ export class MergeMapToSubscriber extends OuterSubscriber { } private _innerSub(ish: any, - destination: PartialObserver, - resultSelector: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2, + destination: PartialObserver, + resultSelector: _mergeMapResultSelector, value: T, index: number): void { - this.add(subscribeToResult(this, ish, value, index)); + this.add(subscribeToResult(this, ish, value, index)); } protected _complete(): void { @@ -68,9 +76,9 @@ export class MergeMapToSubscriber extends OuterSubscriber { } } - notifyNext(outerValue: T, innerValue: R, + notifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number, - innerSub: InnerSubscriber): void { + innerSub: InnerSubscriber): void { const { resultSelector, destination } = this; if (resultSelector) { this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex); @@ -79,10 +87,10 @@ export class MergeMapToSubscriber extends OuterSubscriber { } } - private trySelectResult(outerValue: T, innerValue: R, + private trySelectResult(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): void { const { resultSelector, destination } = this; - let result: R2; + let result: R; try { result = resultSelector(outerValue, innerValue, outerIndex, innerIndex); } catch (err) { diff --git a/src/operator/race.ts b/src/operator/race.ts index f50b5ce65cc..adf3e650ca7 100644 --- a/src/operator/race.ts +++ b/src/operator/race.ts @@ -41,7 +41,7 @@ export function raceStatic(...observables: Array | Array(observables).lift(new RaceOperator()); } export class RaceOperator implements Operator { diff --git a/src/operator/switch.ts b/src/operator/switch.ts index 184dfadbed2..f6d2161aefc 100644 --- a/src/operator/switch.ts +++ b/src/operator/switch.ts @@ -24,6 +24,10 @@ export function _switch(): T { return this.lift(new SwitchOperator()); } +export interface SwitchSignature { + (): T; +} + class SwitchOperator implements Operator { call(subscriber: Subscriber): Subscriber { return new SwitchSubscriber(subscriber); diff --git a/src/operator/switchMap.ts b/src/operator/switchMap.ts index 4b85ab05327..a3937ec4c26 100644 --- a/src/operator/switchMap.ts +++ b/src/operator/switchMap.ts @@ -5,6 +5,7 @@ import {Subscription} from '../Subscription'; import {OuterSubscriber} from '../OuterSubscriber'; import {InnerSubscriber} from '../InnerSubscriber'; import {subscribeToResult} from '../util/subscribeToResult'; +import {_mergeMapProject, _mergeMapResultSelector} from '../util/input-types'; /** * Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that @@ -16,32 +17,34 @@ import {subscribeToResult} from '../util/subscribeToResult'; * @returns {Observable} an Observable that emits the items emitted by the Observable returned from applying func to * the most recently emitted item emitted by the source Observable. */ -export function switchMap(project: (value: T, index: number) => Observable, - resultSelector?: ( - outerValue: T, - innerValue: R, - outerIndex: number, - innerIndex: number) => R2): Observable { +export function switchMap(project: _mergeMapProject, + resultSelector?: _mergeMapResultSelector): Observable { return this.lift(new SwitchMapOperator(project, resultSelector)); } -class SwitchMapOperator implements Operator { - constructor(private project: (value: T, index: number) => Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { +export interface SwitchMapSignature { + (project: _mergeMapProject): Observable; + (project: _mergeMapProject, + resultSelector: _mergeMapResultSelector): Observable; +} + +class SwitchMapOperator implements Operator { + constructor(private project: _mergeMapProject, + private resultSelector?: _mergeMapResultSelector) { } - call(subscriber: Subscriber): Subscriber { + call(subscriber: Subscriber): Subscriber { return new SwitchMapSubscriber(subscriber, this.project, this.resultSelector); } } -class SwitchMapSubscriber extends OuterSubscriber { +class SwitchMapSubscriber extends OuterSubscriber { private index: number = 0; private innerSubscription: Subscription; - constructor(destination: Subscriber, - private project: (value: T, index: number) => Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { + constructor(destination: Subscriber, + private project: _mergeMapProject, + private resultSelector?: _mergeMapResultSelector) { super(destination); } @@ -84,9 +87,9 @@ class SwitchMapSubscriber extends OuterSubscriber { } } - notifyNext(outerValue: T, innerValue: R, + notifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number, - innerSub: InnerSubscriber): void { + innerSub: InnerSubscriber): void { if (this.resultSelector) { this._tryNotifyNext(outerValue, innerValue, outerIndex, innerIndex); } else { @@ -94,7 +97,7 @@ class SwitchMapSubscriber extends OuterSubscriber { } } - _tryNotifyNext(outerValue: T, innerValue: R, outerIndex: number, innerIndex: number): void { + _tryNotifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): void { let result: any; try { result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex); diff --git a/src/operator/switchMapTo.ts b/src/operator/switchMapTo.ts index ea712ff0f82..616f2a8007d 100644 --- a/src/operator/switchMapTo.ts +++ b/src/operator/switchMapTo.ts @@ -1,37 +1,40 @@ import {Operator} from '../Operator'; -import {Observable} from '../Observable'; +import {Observable, ObservableInput} from '../Observable'; import {Subscriber} from '../Subscriber'; import {Subscription} from '../Subscription'; import {OuterSubscriber} from '../OuterSubscriber'; import {InnerSubscriber} from '../InnerSubscriber'; import {subscribeToResult} from '../util/subscribeToResult'; +import {_mergeMapResultSelector} from '../util/input-types'; -export function switchMapTo(observable: Observable, - resultSelector?: ( - outerValue: T, - innerValue: R, - outerIndex: number, - innerIndex: number) => R2): Observable { +export function switchMapTo(observable: Observable, + resultSelector?: _mergeMapResultSelector): Observable { return this.lift(new SwitchMapToOperator(observable, resultSelector)); } -class SwitchMapToOperator implements Operator { - constructor(private observable: Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { +export interface SwitchMapToSignature { + (observable: ObservableInput): Observable; + (observable: ObservableInput, + resultSelector: _mergeMapResultSelector): Observable; +} + +class SwitchMapToOperator implements Operator { + constructor(private observable: Observable, + private resultSelector?: _mergeMapResultSelector) { } - call(subscriber: Subscriber): Subscriber { + call(subscriber: Subscriber): Subscriber { return new SwitchMapToSubscriber(subscriber, this.observable, this.resultSelector); } } -class SwitchMapToSubscriber extends OuterSubscriber { +class SwitchMapToSubscriber extends OuterSubscriber { private index: number = 0; private innerSubscription: Subscription; - constructor(destination: Subscriber, - private inner: Observable, - private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) { + constructor(destination: Subscriber, + private inner: Observable, + private resultSelector?: _mergeMapResultSelector) { super(destination); } @@ -62,9 +65,9 @@ class SwitchMapToSubscriber extends OuterSubscriber { } } - notifyNext(outerValue: T, innerValue: R, + notifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number, - innerSub: InnerSubscriber): void { + innerSub: InnerSubscriber): void { const { resultSelector, destination } = this; if (resultSelector) { this.tryResultSelector(outerValue, innerValue, outerIndex, innerIndex); @@ -73,10 +76,10 @@ class SwitchMapToSubscriber extends OuterSubscriber { } } - private tryResultSelector(outerValue: T, innerValue: R, + private tryResultSelector(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): void { const { resultSelector, destination } = this; - let result: R2; + let result: R; try { result = resultSelector(outerValue, innerValue, outerIndex, innerIndex); } catch (err) { diff --git a/src/operator/zipAll.ts b/src/operator/zipAll.ts index 3f33b3d88fa..aefe3afba07 100644 --- a/src/operator/zipAll.ts +++ b/src/operator/zipAll.ts @@ -4,3 +4,8 @@ import {Observable} from '../Observable'; export function zipAll(project?: (...values: Array) => R): Observable { return this.lift(new ZipOperator(project)); } + +export interface ZipAllSignature { + (): Observable; + (project?: (...values: Array) => R): Observable; +} diff --git a/src/util/input-types.ts b/src/util/input-types.ts new file mode 100644 index 00000000000..bf9ab0093ab --- /dev/null +++ b/src/util/input-types.ts @@ -0,0 +1,5 @@ +import {ObservableInput} from '../Observable'; + +export type _mapProject = (value: T, index: number) => R; +export type _mergeMapProject = _mapProject>; +export type _mergeMapResultSelector = (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R;