From 60c01984bc683fddf5ff83f03e0ba58e40faaa8d Mon Sep 17 00:00:00 2001 From: Andre Staltz Date: Mon, 7 Nov 2016 19:20:19 +0200 Subject: [PATCH] docs(operators): ensure JSDoc comment is adjacent to implementation The JSDoc comment must be immediately adjacent to the implementation function, in order for it to remain after TypeScript compilation. This fixes the bug where some operators were absent from the documentation site. #2111 --- src/observable/ForkJoinObservable.ts | 1 + src/operator/bufferTime.ts | 11 +++++---- src/operator/catch.ts | 1 + src/operator/combineLatest.ts | 33 +++++++++++++------------ src/operator/concat.ts | 21 ++++++++-------- src/operator/concatAll.ts | 9 ++++--- src/operator/concatMap.ts | 9 ++++--- src/operator/concatMapTo.ts | 9 ++++--- src/operator/defaultIfEmpty.ts | 9 ++++--- src/operator/distinctUntilChanged.ts | 9 ++++--- src/operator/distinctUntilKeyChanged.ts | 9 ++++--- src/operator/do.ts | 9 ++++--- src/operator/exhaustMap.ts | 9 ++++--- src/operator/expand.ts | 9 ++++--- src/operator/filter.ts | 12 +++++---- src/operator/find.ts | 13 +++++----- src/operator/first.ts | 25 ++++++++++--------- src/operator/groupBy.ts | 13 +++++----- src/operator/last.ts | 25 ++++++++++--------- src/operator/merge.ts | 33 +++++++++++++------------ src/operator/mergeMap.ts | 9 ++++--- src/operator/mergeMapTo.ts | 9 ++++--- src/operator/multicast.ts | 9 ++++--- src/operator/publish.ts | 9 ++++--- src/operator/race.ts | 9 ++++--- src/operator/reduce.ts | 11 +++++---- src/operator/scan.ts | 11 +++++---- src/operator/startWith.ts | 19 +++++++------- src/operator/switchMap.ts | 9 ++++--- src/operator/switchMapTo.ts | 9 ++++--- src/operator/timeoutWith.ts | 9 ++++--- src/operator/toPromise.ts | 9 ++++--- src/operator/withLatestFrom.ts | 33 +++++++++++++------------ src/operator/zip.ts | 13 +++++----- 34 files changed, 236 insertions(+), 201 deletions(-) diff --git a/src/observable/ForkJoinObservable.ts b/src/observable/ForkJoinObservable.ts index 86c06f2464..062dc6e6d1 100644 --- a/src/observable/ForkJoinObservable.ts +++ b/src/observable/ForkJoinObservable.ts @@ -37,6 +37,7 @@ export class ForkJoinObservable extends Observable { static create(...sources: SubscribableOrPromise[]): Observable; static create(...sources: SubscribableOrPromise[]): Observable; /* tslint:enable:max-line-length */ + /** * @param sources * @return {any} diff --git a/src/operator/bufferTime.ts b/src/operator/bufferTime.ts index 36d678b03f..8bbd29cb1f 100644 --- a/src/operator/bufferTime.ts +++ b/src/operator/bufferTime.ts @@ -7,6 +7,12 @@ import { Subscriber } from '../Subscriber'; import { Subscription } from '../Subscription'; import { isScheduler } from '../util/isScheduler'; +/* tslint:disable:max-line-length */ +export function bufferTime(this: Observable, bufferTimeSpan: number, scheduler?: Scheduler): Observable; +export function bufferTime(this: Observable, bufferTimeSpan: number, bufferCreationInterval: number, scheduler?: Scheduler): Observable; +export function bufferTime(this: Observable, bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler?: Scheduler): Observable; +/* tslint:disable:max-line-length */ + /** * Buffers the source Observable values for a specific time period. * @@ -50,11 +56,6 @@ import { isScheduler } from '../util/isScheduler'; * @method bufferTime * @owner Observable */ -/* tslint:disable:max-line-length */ -export function bufferTime(this: Observable, bufferTimeSpan: number, scheduler?: Scheduler): Observable; -export function bufferTime(this: Observable, bufferTimeSpan: number, bufferCreationInterval: number, scheduler?: Scheduler): Observable; -export function bufferTime(this: Observable, bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler?: Scheduler): Observable; -/* tslint:disable:max-line-length */ export function bufferTime(this: Observable, bufferTimeSpan: number): Observable { let length: number = arguments.length; diff --git a/src/operator/catch.ts b/src/operator/catch.ts index 11fdfdabd0..78027c2f3e 100644 --- a/src/operator/catch.ts +++ b/src/operator/catch.ts @@ -13,6 +13,7 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @return {Observable} an observable that originates from either the source or the observable returned by the * catch `selector` function. * @method catch + * @name catch * @owner Observable */ export function _catch(this: Observable, selector: (err: any, caught: Observable) => ObservableInput): Observable { diff --git a/src/operator/combineLatest.ts b/src/operator/combineLatest.ts index 3e6470bad7..6b488466f8 100644 --- a/src/operator/combineLatest.ts +++ b/src/operator/combineLatest.ts @@ -8,6 +8,23 @@ import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; const none = {}; +/* tslint:disable:max-line-length */ +export function combineLatest(this: Observable, project: (v1: T) => R): Observable; +export function combineLatest(this: Observable, v2: ObservableInput, project: (v1: T, v2: T2) => R): Observable; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, project: (v1: T, v2: T2, v3: T3) => R): Observable; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable ; +export function combineLatest(this: Observable, v2: ObservableInput): Observable<[T, T2]>; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput): Observable<[T, T2, T3]>; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput): Observable<[T, T2, T3, T4]>; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput): Observable<[T, T2, T3, T4, T5]>; +export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput): Observable<[T, T2, T3, T4, T5, T6]> ; +export function combineLatest(this: Observable, ...observables: Array | ((...values: Array) => R)>): Observable; +export function combineLatest(this: Observable, array: ObservableInput[]): Observable>; +export function combineLatest(this: Observable, array: ObservableInput[], project: (v1: T, ...values: Array) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Combines multiple Observables to create an Observable whose values are * calculated from the latest values of each of its input Observables. @@ -46,22 +63,6 @@ const none = {}; * @method combineLatest * @owner Observable */ -/* tslint:disable:max-line-length */ -export function combineLatest(this: Observable, project: (v1: T) => R): Observable; -export function combineLatest(this: Observable, v2: ObservableInput, project: (v1: T, v2: T2) => R): Observable; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, project: (v1: T, v2: T2, v3: T3) => R): Observable; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable ; -export function combineLatest(this: Observable, v2: ObservableInput): Observable<[T, T2]>; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput): Observable<[T, T2, T3]>; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput): Observable<[T, T2, T3, T4]>; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput): Observable<[T, T2, T3, T4, T5]>; -export function combineLatest(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput): Observable<[T, T2, T3, T4, T5, T6]> ; -export function combineLatest(this: Observable, ...observables: Array | ((...values: Array) => R)>): Observable; -export function combineLatest(this: Observable, array: ObservableInput[]): Observable>; -export function combineLatest(this: Observable, array: ObservableInput[], project: (v1: T, ...values: Array) => R): Observable; -/* tslint:disable:max-line-length */ export function combineLatest(this: Observable, ...observables: Array | Array> | ((...values: Array) => R)>): Observable { diff --git a/src/operator/concat.ts b/src/operator/concat.ts index 8302991823..9f5563bdbd 100644 --- a/src/operator/concat.ts +++ b/src/operator/concat.ts @@ -4,6 +4,17 @@ import { isScheduler } from '../util/isScheduler'; import { ArrayObservable } from '../observable/ArrayObservable'; import { MergeAllOperator } from './mergeAll'; +/* tslint:disable:max-line-length */ +export function concat(this: Observable, scheduler?: Scheduler): Observable; +export function concat(this: Observable, v2: ObservableInput, scheduler?: Scheduler): Observable; +export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; +export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; +export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; +export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; +export function concat(this: Observable, ...observables: Array | Scheduler>): Observable; +export function concat(this: Observable, ...observables: Array | Scheduler>): Observable; +/* tslint:disable:max-line-length */ + /** * Creates an output Observable which sequentially emits all values from every * given input Observable after the current Observable. @@ -44,16 +55,6 @@ import { MergeAllOperator } from './mergeAll'; * @method concat * @owner Observable */ -/* tslint:disable:max-line-length */ -export function concat(this: Observable, scheduler?: Scheduler): Observable; -export function concat(this: Observable, v2: ObservableInput, scheduler?: Scheduler): Observable; -export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; -export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; -export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; -export function concat(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; -export function concat(this: Observable, ...observables: Array | Scheduler>): Observable; -export function concat(this: Observable, ...observables: Array | Scheduler>): Observable; -/* tslint:disable:max-line-length */ export function concat(this: Observable, ...observables: Array | Scheduler>): Observable { return this.lift.call(concatStatic(this, ...observables)); } diff --git a/src/operator/concatAll.ts b/src/operator/concatAll.ts index 4c89afc2af..e253bc7cea 100644 --- a/src/operator/concatAll.ts +++ b/src/operator/concatAll.ts @@ -2,6 +2,11 @@ import { Observable } from '../Observable'; import { Subscribable } from '../Observable'; import { MergeAllOperator } from './mergeAll'; +/* tslint:disable:max-line-length */ +export function concatAll(this: Observable): T; +export function concatAll(this: Observable): Subscribable; +/* tslint:disable:max-line-length */ + /** * Converts a higher-order Observable into a first-order Observable by * concatenating the inner Observables in order. @@ -44,10 +49,6 @@ import { MergeAllOperator } from './mergeAll'; * @method concatAll * @owner Observable */ -/* tslint:disable:max-line-length */ -export function concatAll(this: Observable): T; -export function concatAll(this: Observable): Subscribable; -/* tslint:disable:max-line-length */ export function concatAll(this: Observable): T { return this.lift(new MergeAllOperator(1)); } diff --git a/src/operator/concatMap.ts b/src/operator/concatMap.ts index d69a248f86..d65871c232 100644 --- a/src/operator/concatMap.ts +++ b/src/operator/concatMap.ts @@ -1,6 +1,11 @@ import { MergeMapOperator } from './mergeMap'; import { Observable, ObservableInput } from '../Observable'; +/* tslint:disable:max-line-length */ +export function concatMap(this: Observable, project: (value: T, index: number) => ObservableInput): Observable; +export function concatMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to an Observable which is merged in the output * Observable, in a serialized fashion waiting for each one to complete before @@ -57,10 +62,6 @@ import { Observable, ObservableInput } from '../Observable'; * @method concatMap * @owner Observable */ -/* tslint:disable:max-line-length */ -export function concatMap(this: Observable, project: (value: T, index: number) => ObservableInput): Observable; -export function concatMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; -/* tslint:disable:max-line-length */ export function concatMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) { return this.lift(new MergeMapOperator(project, resultSelector, 1)); diff --git a/src/operator/concatMapTo.ts b/src/operator/concatMapTo.ts index 2306335049..99b90f2cab 100644 --- a/src/operator/concatMapTo.ts +++ b/src/operator/concatMapTo.ts @@ -1,6 +1,11 @@ import { Observable, ObservableInput } from '../Observable'; import { MergeMapToOperator } from './mergeMapTo'; +/* tslint:disable:max-line-length */ +export function concatMapTo(this: Observable, observable: ObservableInput): Observable; +export function concatMapTo(this: Observable, observable: ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to the same Observable which is merged multiple * times in a serialized fashion on the output Observable. @@ -51,10 +56,6 @@ import { MergeMapToOperator } from './mergeMapTo'; * @method concatMapTo * @owner Observable */ -/* tslint:disable:max-line-length */ -export function concatMapTo(this: Observable, observable: ObservableInput): Observable; -export function concatMapTo(this: Observable, observable: ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; -/* tslint:disable:max-line-length */ export function concatMapTo(this: Observable, innerObservable: Observable, resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable { return this.lift(new MergeMapToOperator(innerObservable, resultSelector, 1)); diff --git a/src/operator/defaultIfEmpty.ts b/src/operator/defaultIfEmpty.ts index 081b8341a4..f580e8eeb0 100644 --- a/src/operator/defaultIfEmpty.ts +++ b/src/operator/defaultIfEmpty.ts @@ -2,6 +2,11 @@ import { Operator } from '../Operator'; import { Observable } from '../Observable'; import { Subscriber } from '../Subscriber'; +/* tslint:disable:max-line-length */ +export function defaultIfEmpty(this: Observable, defaultValue?: T): Observable; +export function defaultIfEmpty(this: Observable, defaultValue?: R): Observable; +/* tslint:disable:max-line-length */ + /** * Emits a given value if the source Observable completes without emitting any * `next` value, otherwise mirrors the source Observable. @@ -32,10 +37,6 @@ import { Subscriber } from '../Subscriber'; * @method defaultIfEmpty * @owner Observable */ -/* tslint:disable:max-line-length */ -export function defaultIfEmpty(this: Observable, defaultValue?: T): Observable; -export function defaultIfEmpty(this: Observable, defaultValue?: R): Observable; -/* tslint:disable:max-line-length */ export function defaultIfEmpty(this: Observable, defaultValue: R = null): Observable { return this.lift(new DefaultIfEmptyOperator(defaultValue)); } diff --git a/src/operator/distinctUntilChanged.ts b/src/operator/distinctUntilChanged.ts index 9722dbca9c..79d5b58dd7 100644 --- a/src/operator/distinctUntilChanged.ts +++ b/src/operator/distinctUntilChanged.ts @@ -5,6 +5,11 @@ import { errorObject } from '../util/errorObject'; import { Observable } from '../Observable'; import { TeardownLogic } from '../Subscription'; +/* tslint:disable:max-line-length */ +export function distinctUntilChanged(this: Observable, compare?: (x: T, y: T) => boolean): Observable; +export function distinctUntilChanged(this: Observable, compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): Observable; +/* tslint:disable:max-line-length */ + /** * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item. * If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted. @@ -14,10 +19,6 @@ import { TeardownLogic } from '../Subscription'; * @method distinctUntilChanged * @owner Observable */ -/* tslint:disable:max-line-length */ -export function distinctUntilChanged(this: Observable, compare?: (x: T, y: T) => boolean): Observable; -export function distinctUntilChanged(this: Observable, compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): Observable; -/* tslint:disable:max-line-length */ export function distinctUntilChanged(this: Observable, compare?: (x: K, y: K) => boolean, keySelector?: (x: T) => K): Observable { return this.lift(new DistinctUntilChangedOperator(compare, keySelector)); } diff --git a/src/operator/distinctUntilKeyChanged.ts b/src/operator/distinctUntilKeyChanged.ts index 1067a5b5e8..5f942aa355 100644 --- a/src/operator/distinctUntilKeyChanged.ts +++ b/src/operator/distinctUntilKeyChanged.ts @@ -1,6 +1,11 @@ import { distinctUntilChanged } from './distinctUntilChanged'; import { Observable } from '../Observable'; +/* tslint:disable:max-line-length */ +export function distinctUntilKeyChanged(this: Observable, key: string): Observable; +export function distinctUntilKeyChanged(this: Observable, key: string, compare: (x: K, y: K) => boolean): Observable; +/* tslint:disable:max-line-length */ + /** * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item, * using a property accessed by using the key provided to check if the two items are distinct. @@ -12,10 +17,6 @@ import { Observable } from '../Observable'; * @method distinctUntilKeyChanged * @owner Observable */ -/* tslint:disable:max-line-length */ -export function distinctUntilKeyChanged(this: Observable, key: string): Observable; -export function distinctUntilKeyChanged(this: Observable, key: string, compare: (x: K, y: K) => boolean): Observable; -/* tslint:disable:max-line-length */ export function distinctUntilKeyChanged(this: Observable, key: string, compare?: (x: T, y: T) => boolean): Observable { return distinctUntilChanged.call(this, function(x: T, y: T) { if (compare) { diff --git a/src/operator/do.ts b/src/operator/do.ts index afdc40fa04..226f6bc0be 100644 --- a/src/operator/do.ts +++ b/src/operator/do.ts @@ -4,6 +4,11 @@ import { Observable } from '../Observable'; import { PartialObserver } from '../Observer'; import { TeardownLogic } from '../Subscription'; +/* tslint:disable:max-line-length */ +export function _do(this: Observable, next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable; +export function _do(this: Observable, observer: PartialObserver): Observable; +/* tslint:disable:max-line-length */ + /** * Perform a side effect for every emission on the source Observable, but return * an Observable that is identical to the source. @@ -47,10 +52,6 @@ import { TeardownLogic } from '../Subscription'; * @name do * @owner Observable */ -/* tslint:disable:max-line-length */ -export function _do(this: Observable, next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable; -export function _do(this: Observable, observer: PartialObserver): Observable; -/* tslint:disable:max-line-length */ export function _do(this: Observable, nextOrObserver?: PartialObserver | ((x: T) => void), error?: (e: any) => void, complete?: () => void): Observable { diff --git a/src/operator/exhaustMap.ts b/src/operator/exhaustMap.ts index 7296ecbec3..1eba8f11e8 100644 --- a/src/operator/exhaustMap.ts +++ b/src/operator/exhaustMap.ts @@ -6,6 +6,11 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function exhaustMap(this: Observable, project: (value: T, index: number) => ObservableInput): Observable; +export function exhaustMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to an Observable which is merged in the output * Observable only if the previous projected Observable has completed. @@ -51,10 +56,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method exhaustMap * @owner Observable */ -/* tslint:disable:max-line-length */ -export function exhaustMap(this: Observable, project: (value: T, index: number) => ObservableInput): Observable; -export function exhaustMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; -/* tslint:disable:max-line-length */ export function exhaustMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable { return this.lift(new SwitchFirstMapOperator(project, resultSelector)); diff --git a/src/operator/expand.ts b/src/operator/expand.ts index 60f3b5f567..3cb381c2bd 100644 --- a/src/operator/expand.ts +++ b/src/operator/expand.ts @@ -9,6 +9,11 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function expand(this: Observable, project: (value: T, index: number) => Observable, concurrent?: number, scheduler?: Scheduler): Observable; +export function expand(this: Observable, project: (value: T, index: number) => Observable, concurrent?: number, scheduler?: Scheduler): Observable; +/* tslint:disable:max-line-length */ + /** * Recursively projects each source value to an Observable which is merged in * the output Observable. @@ -54,10 +59,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method expand * @owner Observable */ -/* tslint:disable:max-line-length */ -export function expand(this: Observable, project: (value: T, index: number) => Observable, concurrent?: number, scheduler?: Scheduler): Observable; -export function expand(this: Observable, project: (value: T, index: number) => Observable, concurrent?: number, scheduler?: Scheduler): Observable; -/* tslint:disable:max-line-length */ export function expand(this: Observable, project: (value: T, index: number) => Observable, concurrent: number = Number.POSITIVE_INFINITY, scheduler: Scheduler = undefined): Observable { diff --git a/src/operator/filter.ts b/src/operator/filter.ts index 50700ccf98..a227a9e19c 100644 --- a/src/operator/filter.ts +++ b/src/operator/filter.ts @@ -3,6 +3,13 @@ import { Subscriber } from '../Subscriber'; import { Observable } from '../Observable'; import { TeardownLogic } from '../Subscription'; +/* tslint:disable:max-line-length */ +export function filter(this: Observable, + predicate: ((value: T, index: number) => boolean) | + ((value: T, index: number) => value is S), + thisArg?: any): Observable; +/* tslint:disable:max-line-length */ + /** * Filter items emitted by the source Observable by only emitting those that * satisfy a specified predicate. @@ -43,11 +50,6 @@ import { TeardownLogic } from '../Subscription'; * @method filter * @owner Observable */ -/* tslint:disable:max-line-length */ -export function filter(this: Observable, - predicate: ((value: T, index: number) => boolean) | - ((value: T, index: number) => value is S), - thisArg?: any): Observable; export function filter(this: Observable, predicate: (value: T, index: number) => boolean, thisArg?: any): Observable { return this.lift(new FilterOperator(predicate, thisArg)); diff --git a/src/operator/find.ts b/src/operator/find.ts index 3ef646d946..911f144d0b 100644 --- a/src/operator/find.ts +++ b/src/operator/find.ts @@ -2,6 +2,13 @@ import { Observable } from '../Observable'; import { Operator } from '../Operator'; import { Subscriber } from '../Subscriber'; +/* tslint:disable:max-line-length */ +export function find(this: Observable, + predicate: ((value: T, index: number, source: Observable) => boolean) | + ((value: T, index: number, source: Observable) => value is S), + thisArg?: any): Observable; +/* tslint:disable:max-line-length */ + /** * Emits only the first value emitted by the source Observable that meets some * condition. @@ -35,12 +42,6 @@ import { Subscriber } from '../Subscriber'; * @method find * @owner Observable */ -/* tslint:disable:max-line-length */ -export function find(this: Observable, - predicate: ((value: T, index: number, source: Observable) => boolean) | - ((value: T, index: number, source: Observable) => value is S), - thisArg?: any): Observable; -/* tslint:disable:max-line-length */ export function find(this: Observable, predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable { if (typeof predicate !== 'function') { diff --git a/src/operator/first.ts b/src/operator/first.ts index 9fb8314ef1..4a54a32e72 100644 --- a/src/operator/first.ts +++ b/src/operator/first.ts @@ -3,6 +3,19 @@ import { Operator } from '../Operator'; import { Subscriber } from '../Subscriber'; import { EmptyError } from '../util/EmptyError'; +/* tslint:disable:max-line-length */ +export function first(this: Observable, + predicate?: ((value: T, index: number, source: Observable) => boolean) | + ((value: T, index: number, source: Observable) => value is S)): Observable; +export function first(this: Observable, predicate: (value: T, index: number, source: Observable) => boolean, resultSelector: void, defaultValue?: T): Observable; +export function first(this: Observable, + predicate: ((value: T, index: number, source: Observable) => boolean) | + ((value: T, index: number, source: Observable) => value is S), + resultSelector?: ((value: S, index: number) => R) | void, + defaultValue?: S): Observable; +export function first(this: Observable, predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: R): Observable; +/* tslint:disable:max-line-length */ + /** * Emits only the first value (or the first value that meets some condition) * emitted by the source Observable. @@ -52,18 +65,6 @@ import { EmptyError } from '../util/EmptyError'; * @method first * @owner Observable */ -/* tslint:disable:max-line-length */ -export function first(this: Observable, - predicate?: ((value: T, index: number, source: Observable) => boolean) | - ((value: T, index: number, source: Observable) => value is S)): Observable; -export function first(this: Observable, predicate: (value: T, index: number, source: Observable) => boolean, resultSelector: void, defaultValue?: T): Observable; -export function first(this: Observable, - predicate: ((value: T, index: number, source: Observable) => boolean) | - ((value: T, index: number, source: Observable) => value is S), - resultSelector?: ((value: S, index: number) => R) | void, - defaultValue?: S): Observable; -export function first(this: Observable, predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: R): Observable; -/* tslint:disable:max-line-length */ export function first(this: Observable, predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: ((value: T, index: number) => R) | void, defaultValue?: R): Observable { diff --git a/src/operator/groupBy.ts b/src/operator/groupBy.ts index a23d462cc4..e80d42f87e 100644 --- a/src/operator/groupBy.ts +++ b/src/operator/groupBy.ts @@ -6,6 +6,13 @@ import { Subject } from '../Subject'; import { Map } from '../util/Map'; import { FastMap } from '../util/FastMap'; +/* tslint:disable:max-line-length */ +export function groupBy(this: Observable, keySelector: (value: T) => K): Observable>; +export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector: void, durationSelector: (grouped: GroupedObservable) => Observable): Observable>; +export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable) => Observable): Observable>; +export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable) => Observable, subjectSelector?: () => Subject): Observable>; +/* tslint:disable:max-line-length */ + /** * Groups the items emitted by an Observable according to a specified criterion, * and emits these grouped items as `GroupedObservables`, one @@ -27,12 +34,6 @@ import { FastMap } from '../util/FastMap'; * @method groupBy * @owner Observable */ -/* tslint:disable:max-line-length */ -export function groupBy(this: Observable, keySelector: (value: T) => K): Observable>; -export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector: void, durationSelector: (grouped: GroupedObservable) => Observable): Observable>; -export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable) => Observable): Observable>; -export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable) => Observable, subjectSelector?: () => Subject): Observable>; -/* tslint:disable:max-line-length */ export function groupBy(this: Observable, keySelector: (value: T) => K, elementSelector?: ((value: T) => R) | void, durationSelector?: (grouped: GroupedObservable) => Observable, diff --git a/src/operator/last.ts b/src/operator/last.ts index 3a1ea2269f..9b9d898ce6 100644 --- a/src/operator/last.ts +++ b/src/operator/last.ts @@ -3,6 +3,19 @@ import { Operator } from '../Operator'; import { Subscriber } from '../Subscriber'; import { EmptyError } from '../util/EmptyError'; +/* tslint:disable:max-line-length */ +export function last(this: Observable, + predicate?: ((value: T, index: number, source: Observable) => boolean) | + ((value: T, index: number, source: Observable) => value is S)): Observable; +export function last(this: Observable, predicate: (value: T, index: number, source: Observable) => boolean, resultSelector: void, defaultValue?: T): Observable; +export function last(this: Observable, + predicate: ((value: T, index: number, source: Observable) => boolean) | + ((value: T, index: number, source: Observable) => value is S), + resultSelector?: ((value: S, index: number) => R) | void, + defaultValue?: S): Observable; +export function last(this: Observable, predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: R): Observable; +/* tslint:disable:max-line-length */ + /** * Returns an Observable that emits only the last item emitted by the source Observable. * It optionally takes a predicate function as a parameter, in which case, rather than emitting @@ -20,18 +33,6 @@ import { EmptyError } from '../util/EmptyError'; * @method last * @owner Observable */ -/* tslint:disable:max-line-length */ -export function last(this: Observable, - predicate?: ((value: T, index: number, source: Observable) => boolean) | - ((value: T, index: number, source: Observable) => value is S)): Observable; -export function last(this: Observable, predicate: (value: T, index: number, source: Observable) => boolean, resultSelector: void, defaultValue?: T): Observable; -export function last(this: Observable, - predicate: ((value: T, index: number, source: Observable) => boolean) | - ((value: T, index: number, source: Observable) => value is S), - resultSelector?: ((value: S, index: number) => R) | void, - defaultValue?: S): Observable; -export function last(this: Observable, predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: R): Observable; -/* tslint:disable:max-line-length */ export function last(this: Observable, predicate?: (value: T, index: number, source: Observable) => boolean, resultSelector?: ((value: T, index: number) => R) | void, defaultValue?: R): Observable { diff --git a/src/operator/merge.ts b/src/operator/merge.ts index b39ba238ca..ebb9c898f7 100644 --- a/src/operator/merge.ts +++ b/src/operator/merge.ts @@ -4,6 +4,23 @@ import { ArrayObservable } from '../observable/ArrayObservable'; import { MergeAllOperator } from './mergeAll'; import { isScheduler } from '../util/isScheduler'; +/* tslint:disable:max-line-length */ +export function merge(this: Observable, scheduler?: Scheduler): Observable; +export function merge(this: Observable, concurrent?: number, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; +export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; +export function merge(this: Observable, ...observables: Array | Scheduler | number>): Observable; +export function merge(this: Observable, ...observables: Array | Scheduler | number>): Observable; +/* tslint:disable:max-line-length */ + /** * Creates an output Observable which concurrently emits all values from every * given input Observable. @@ -50,22 +67,6 @@ import { isScheduler } from '../util/isScheduler'; * @method merge * @owner Observable */ -/* tslint:disable:max-line-length */ -export function merge(this: Observable, scheduler?: Scheduler): Observable; -export function merge(this: Observable, concurrent?: number, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, scheduler?: Scheduler): Observable; -export function merge(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, concurrent?: number, scheduler?: Scheduler): Observable; -export function merge(this: Observable, ...observables: Array | Scheduler | number>): Observable; -export function merge(this: Observable, ...observables: Array | Scheduler | number>): Observable; -/* tslint:disable:max-line-length */ export function merge(this: Observable, ...observables: Array | Scheduler | number>): Observable { return this.lift.call(mergeStatic(this, ...observables)); } diff --git a/src/operator/mergeMap.ts b/src/operator/mergeMap.ts index d713efe123..c48a54614d 100644 --- a/src/operator/mergeMap.ts +++ b/src/operator/mergeMap.ts @@ -6,6 +6,11 @@ import { subscribeToResult } from '../util/subscribeToResult'; import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; +/* tslint:disable:max-line-length */ +export function mergeMap(this: Observable, project: (value: T, index: number) => ObservableInput, concurrent?: number): Observable; +export function mergeMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R, concurrent?: number): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to an Observable which is merged in the output * Observable. @@ -55,10 +60,6 @@ import { InnerSubscriber } from '../InnerSubscriber'; * @method mergeMap * @owner Observable */ -/* tslint:disable:max-line-length */ -export function mergeMap(this: Observable, project: (value: T, index: number) => ObservableInput, concurrent?: number): Observable; -export function mergeMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R, concurrent?: number): Observable; -/* tslint:disable:max-line-length */ export function mergeMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector?: ((outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) | number, concurrent: number = Number.POSITIVE_INFINITY): Observable { diff --git a/src/operator/mergeMapTo.ts b/src/operator/mergeMapTo.ts index eeba884589..32fcd851ad 100644 --- a/src/operator/mergeMapTo.ts +++ b/src/operator/mergeMapTo.ts @@ -7,6 +7,11 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function mergeMapTo(this: Observable, observable: ObservableInput, concurrent?: number): Observable; +export function mergeMapTo(this: Observable, observable: ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R, concurrent?: number): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to the same Observable which is merged multiple * times in the output Observable. @@ -50,10 +55,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method mergeMapTo * @owner Observable */ -/* tslint:disable:max-line-length */ -export function mergeMapTo(this: Observable, observable: ObservableInput, concurrent?: number): Observable; -export function mergeMapTo(this: Observable, observable: ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R, concurrent?: number): Observable; -/* tslint:disable:max-line-length */ export function mergeMapTo(this: Observable, innerObservable: Observable, resultSelector?: ((outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) | number, concurrent: number = Number.POSITIVE_INFINITY): Observable { diff --git a/src/operator/multicast.ts b/src/operator/multicast.ts index de06574900..4487bbf93e 100644 --- a/src/operator/multicast.ts +++ b/src/operator/multicast.ts @@ -4,6 +4,11 @@ import { Subscriber } from '../Subscriber'; import { Observable } from '../Observable'; import { ConnectableObservable, connectableObservableDescriptor } from '../observable/ConnectableObservable'; +/* tslint:disable:max-line-length */ +export function multicast(this: Observable, subjectOrSubjectFactory: factoryOrValue>): ConnectableObservable; +export function multicast(SubjectFactory: (this: Observable) => Subject, selector?: selector): Observable; +/* tslint:disable:max-line-length */ + /** * Returns an Observable that emits the results of invoking a specified selector on items * emitted by a ConnectableObservable that shares a single subscription to the underlying stream. @@ -23,10 +28,6 @@ import { ConnectableObservable, connectableObservableDescriptor } from '../obser * @method multicast * @owner Observable */ -/* tslint:disable:max-line-length */ -export function multicast(this: Observable, subjectOrSubjectFactory: factoryOrValue>): ConnectableObservable; -export function multicast(SubjectFactory: (this: Observable) => Subject, selector?: selector): Observable; -/* tslint:disable:max-line-length */ export function multicast(this: Observable, subjectOrSubjectFactory: Subject | (() => Subject), selector?: (source: Observable) => Observable): Observable | ConnectableObservable { let subjectFactory: () => Subject; diff --git a/src/operator/publish.ts b/src/operator/publish.ts index fa1c67d16e..17d2b3f52e 100644 --- a/src/operator/publish.ts +++ b/src/operator/publish.ts @@ -3,6 +3,11 @@ import { Observable } from '../Observable'; import { multicast } from './multicast'; import { ConnectableObservable } from '../observable/ConnectableObservable'; +/* tslint:disable:max-line-length */ +export function publish(this: Observable): ConnectableObservable; +export function publish(this: Observable, selector: selector): Observable; +/* tslint:disable:max-line-length */ + /** * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called * before it begins emitting items to those Observers that have subscribed to it. @@ -16,10 +21,6 @@ import { ConnectableObservable } from '../observable/ConnectableObservable'; * @method publish * @owner Observable */ -/* tslint:disable:max-line-length */ -export function publish(this: Observable): ConnectableObservable; -export function publish(this: Observable, selector: selector): Observable; -/* tslint:disable:max-line-length */ export function publish(this: Observable, selector?: (source: Observable) => Observable): Observable | ConnectableObservable { return selector ? multicast.call(this, () => new Subject(), selector) : multicast.call(this, new Subject()); diff --git a/src/operator/race.ts b/src/operator/race.ts index 7c60053e91..453c934604 100644 --- a/src/operator/race.ts +++ b/src/operator/race.ts @@ -8,6 +8,11 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function race(this: Observable, ...observables: Array | Array>>): Observable; +export function race(this: Observable, ...observables: Array | Array>>): Observable; +/* tslint:disable:max-line-length */ + /** * Returns an Observable that mirrors the first source Observable to emit an item * from the combination of this Observable and supplied Observables @@ -16,10 +21,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method race * @owner Observable */ -/* tslint:disable:max-line-length */ -export function race(this: Observable, ...observables: Array | Array>>): Observable; -export function race(this: Observable, ...observables: Array | Array>>): Observable; -/* tslint:disable:max-line-length */ export function race(this: Observable, ...observables: Array | Array>>): Observable { // if the only argument is an array, it was most likely called with // `pair([obs1, obs2, ...])` diff --git a/src/operator/reduce.ts b/src/operator/reduce.ts index a3a1f38ae5..4945cbdc53 100644 --- a/src/operator/reduce.ts +++ b/src/operator/reduce.ts @@ -2,6 +2,12 @@ import { Observable } from '../Observable'; import { Operator } from '../Operator'; import { Subscriber } from '../Subscriber'; +/* tslint:disable:max-line-length */ +export function reduce(this: Observable, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable; +export function reduce(this: Observable, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable; +export function reduce(this: Observable, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable; +/* tslint:disable:max-line-length */ + /** * Applies an accumulator function over the source Observable, and returns the * accumulated result when the source completes, given an optional seed value. @@ -47,11 +53,6 @@ import { Subscriber } from '../Subscriber'; * @method reduce * @owner Observable */ -/* tslint:disable:max-line-length */ -export function reduce(this: Observable, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable; -export function reduce(this: Observable, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable; -export function reduce(this: Observable, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable; -/* tslint:disable:max-line-length */ export function reduce(this: Observable, accumulator: (acc: R, value: T) => R, seed?: R): Observable { let hasSeed = false; // providing a seed of `undefined` *should* be valid and trigger diff --git a/src/operator/scan.ts b/src/operator/scan.ts index 99e771a77c..e7fa9e4b23 100644 --- a/src/operator/scan.ts +++ b/src/operator/scan.ts @@ -2,6 +2,12 @@ import { Operator } from '../Operator'; import { Observable } from '../Observable'; import { Subscriber } from '../Subscriber'; +/* tslint:disable:max-line-length */ +export function scan(this: Observable, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable; +export function scan(this: Observable, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable; +export function scan(this: Observable, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable; +/* tslint:disable:max-line-length */ + /** * Applies an accumulator function over the source Observable, and returns each * intermediate result, with an optional seed value. @@ -39,11 +45,6 @@ import { Subscriber } from '../Subscriber'; * @method scan * @owner Observable */ -/* tslint:disable:max-line-length */ -export function scan(this: Observable, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable; -export function scan(this: Observable, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable; -export function scan(this: Observable, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable; -/* tslint:disable:max-line-length */ export function scan(this: Observable, accumulator: (acc: R, value: T, index: number) => R, seed?: T | R): Observable { let hasSeed = false; // providing a seed of `undefined` *should* be valid and trigger diff --git a/src/operator/startWith.ts b/src/operator/startWith.ts index 96864b6520..5678be24cc 100644 --- a/src/operator/startWith.ts +++ b/src/operator/startWith.ts @@ -6,6 +6,16 @@ import { EmptyObservable } from '../observable/EmptyObservable'; import { concatStatic } from './concat'; import { isScheduler } from '../util/isScheduler'; +/* tslint:disable:max-line-length */ +export function startWith(this: Observable, v1: T, scheduler?: Scheduler): Observable; +export function startWith(this: Observable, v1: T, v2: T, scheduler?: Scheduler): Observable; +export function startWith(this: Observable, v1: T, v2: T, v3: T, scheduler?: Scheduler): Observable; +export function startWith(this: Observable, v1: T, v2: T, v3: T, v4: T, scheduler?: Scheduler): Observable; +export function startWith(this: Observable, v1: T, v2: T, v3: T, v4: T, v5: T, scheduler?: Scheduler): Observable; +export function startWith(this: Observable, v1: T, v2: T, v3: T, v4: T, v5: T, v6: T, scheduler?: Scheduler): Observable; +export function startWith(this: Observable, ...array: Array): Observable; +/* tslint:disable:max-line-length */ + /** * Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the * source Observable. @@ -18,15 +28,6 @@ import { isScheduler } from '../util/isScheduler'; * @method startWith * @owner Observable */ -/* tslint:disable:max-line-length */ -export function startWith(this: Observable, v1: T, scheduler?: Scheduler): Observable; -export function startWith(this: Observable, v1: T, v2: T, scheduler?: Scheduler): Observable; -export function startWith(this: Observable, v1: T, v2: T, v3: T, scheduler?: Scheduler): Observable; -export function startWith(this: Observable, v1: T, v2: T, v3: T, v4: T, scheduler?: Scheduler): Observable; -export function startWith(this: Observable, v1: T, v2: T, v3: T, v4: T, v5: T, scheduler?: Scheduler): Observable; -export function startWith(this: Observable, v1: T, v2: T, v3: T, v4: T, v5: T, v6: T, scheduler?: Scheduler): Observable; -export function startWith(this: Observable, ...array: Array): Observable; -/* tslint:disable:max-line-length */ export function startWith(this: Observable, ...array: Array): Observable { let scheduler = array[array.length - 1]; if (isScheduler(scheduler)) { diff --git a/src/operator/switchMap.ts b/src/operator/switchMap.ts index 81e5061575..fbd9a85f1b 100644 --- a/src/operator/switchMap.ts +++ b/src/operator/switchMap.ts @@ -6,6 +6,11 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function switchMap(this: Observable, project: (value: T, index: number) => ObservableInput): Observable; +export function switchMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to an Observable which is merged in the output * Observable, emitting values only from the most recently projected Observable. @@ -53,10 +58,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method switchMap * @owner Observable */ -/* tslint:disable:max-line-length */ -export function switchMap(this: Observable, project: (value: T, index: number) => ObservableInput): Observable; -export function switchMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; -/* tslint:disable:max-line-length */ export function switchMap(this: Observable, project: (value: T, index: number) => ObservableInput, resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable { return this.lift(new SwitchMapOperator(project, resultSelector)); diff --git a/src/operator/switchMapTo.ts b/src/operator/switchMapTo.ts index 61e79cfe6b..dba88a633e 100644 --- a/src/operator/switchMapTo.ts +++ b/src/operator/switchMapTo.ts @@ -6,6 +6,11 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function switchMapTo(this: Observable, observable: ObservableInput): Observable; +export function switchMapTo(this: Observable, observable: ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Projects each source value to the same Observable which is flattened multiple * times with {@link switch} in the output Observable. @@ -50,10 +55,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method switchMapTo * @owner Observable */ -/* tslint:disable:max-line-length */ -export function switchMapTo(this: Observable, observable: ObservableInput): Observable; -export function switchMapTo(this: Observable, observable: ObservableInput, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable; -/* tslint:disable:max-line-length */ export function switchMapTo(this: Observable, innerObservable: Observable, resultSelector?: (outerValue: T, innerValue: I, diff --git a/src/operator/timeoutWith.ts b/src/operator/timeoutWith.ts index 79a562cd75..0ab488059a 100644 --- a/src/operator/timeoutWith.ts +++ b/src/operator/timeoutWith.ts @@ -8,6 +8,11 @@ import { isDate } from '../util/isDate'; import { OuterSubscriber } from '../OuterSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function timeoutWith(this: Observable, due: number | Date, withObservable: ObservableInput, scheduler?: Scheduler): Observable; +export function timeoutWith(this: Observable, due: number | Date, withObservable: ObservableInput, scheduler?: Scheduler): Observable; +/* tslint:disable:max-line-length */ + /** * @param due * @param withObservable @@ -16,10 +21,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method timeoutWith * @owner Observable */ -/* tslint:disable:max-line-length */ -export function timeoutWith(this: Observable, due: number | Date, withObservable: ObservableInput, scheduler?: Scheduler): Observable; -export function timeoutWith(this: Observable, due: number | Date, withObservable: ObservableInput, scheduler?: Scheduler): Observable; -/* tslint:disable:max-line-length */ export function timeoutWith(this: Observable, due: number | Date, withObservable: ObservableInput, scheduler: Scheduler = async): Observable { diff --git a/src/operator/toPromise.ts b/src/operator/toPromise.ts index 4330e0633c..e28547f9ef 100644 --- a/src/operator/toPromise.ts +++ b/src/operator/toPromise.ts @@ -1,16 +1,17 @@ import { Observable } from '../Observable'; import { root } from '../util/root'; +/* tslint:disable:max-line-length */ +export function toPromise(this: Observable): Promise; +export function toPromise(this: Observable, PromiseCtor: typeof Promise): Promise; +/* tslint:disable:max-line-length */ + /** * @param PromiseCtor * @return {Promise} * @method toPromise * @owner Observable */ -/* tslint:disable:max-line-length */ -export function toPromise(this: Observable): Promise; -export function toPromise(this: Observable, PromiseCtor: typeof Promise): Promise; -/* tslint:disable:max-line-length */ export function toPromise(this: Observable, PromiseCtor?: typeof Promise): Promise { if (!PromiseCtor) { if (root.Rx && root.Rx.config && root.Rx.config.Promise) { diff --git a/src/operator/withLatestFrom.ts b/src/operator/withLatestFrom.ts index 0b48330058..631d3f890b 100644 --- a/src/operator/withLatestFrom.ts +++ b/src/operator/withLatestFrom.ts @@ -5,6 +5,23 @@ import { OuterSubscriber } from '../OuterSubscriber'; import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; +/* tslint:disable:max-line-length */ +export function withLatestFrom(this: Observable, project: (v1: T) => R): Observable; +export function withLatestFrom(this: Observable, v2: ObservableInput, project: (v1: T, v2: T2) => R): Observable; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, project: (v1: T, v2: T2, v3: T3) => R): Observable; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable ; +export function withLatestFrom(this: Observable, v2: ObservableInput): Observable<[T, T2]>; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput): Observable<[T, T2, T3]>; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput): Observable<[T, T2, T3, T4]>; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput): Observable<[T, T2, T3, T4, T5]>; +export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput): Observable<[T, T2, T3, T4, T5, T6]> ; +export function withLatestFrom(this: Observable, ...observables: Array | ((...values: Array) => R)>): Observable; +export function withLatestFrom(this: Observable, array: ObservableInput[]): Observable; +export function withLatestFrom(this: Observable, array: ObservableInput[], project: (...values: Array) => R): Observable; +/* tslint:disable:max-line-length */ + /** * Combines the source Observable with other Observables to create an Observable * whose values are calculated from the latest values of each, only when the @@ -43,22 +60,6 @@ import { subscribeToResult } from '../util/subscribeToResult'; * @method withLatestFrom * @owner Observable */ -/* tslint:disable:max-line-length */ -export function withLatestFrom(this: Observable, project: (v1: T) => R): Observable; -export function withLatestFrom(this: Observable, v2: ObservableInput, project: (v1: T, v2: T2) => R): Observable; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, project: (v1: T, v2: T2, v3: T3) => R): Observable; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable ; -export function withLatestFrom(this: Observable, v2: ObservableInput): Observable<[T, T2]>; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput): Observable<[T, T2, T3]>; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput): Observable<[T, T2, T3, T4]>; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput): Observable<[T, T2, T3, T4, T5]>; -export function withLatestFrom(this: Observable, v2: ObservableInput, v3: ObservableInput, v4: ObservableInput, v5: ObservableInput, v6: ObservableInput): Observable<[T, T2, T3, T4, T5, T6]> ; -export function withLatestFrom(this: Observable, ...observables: Array | ((...values: Array) => R)>): Observable; -export function withLatestFrom(this: Observable, array: ObservableInput[]): Observable; -export function withLatestFrom(this: Observable, array: ObservableInput[], project: (...values: Array) => R): Observable; -/* tslint:disable:max-line-length */ export function withLatestFrom(this: Observable, ...args: Array | ((...values: Array) => R)>): Observable { let project: any; if (typeof args[args.length - 1] === 'function') { diff --git a/src/operator/zip.ts b/src/operator/zip.ts index 6c7b6a02df..e7502d0670 100644 --- a/src/operator/zip.ts +++ b/src/operator/zip.ts @@ -9,12 +9,6 @@ import { InnerSubscriber } from '../InnerSubscriber'; import { subscribeToResult } from '../util/subscribeToResult'; import { $$iterator } from '../symbol/iterator'; -/** - * @param observables - * @return {Observable} - * @method zip - * @owner Observable - */ /* tslint:disable:max-line-length */ export function zipProto(this: Observable, project: (v1: T) => R): Observable; export function zipProto(this: Observable, v2: ObservableInput, project: (v1: T, v2: T2) => R): Observable; @@ -31,6 +25,13 @@ export function zipProto(this: Observable, ...observables: Array(this: Observable, array: Array>): Observable; export function zipProto(this: Observable, array: Array>, project: (v1: T, ...values: Array) => R): Observable; /* tslint:disable:max-line-length */ + +/** + * @param observables + * @return {Observable} + * @method zip + * @owner Observable + */ export function zipProto(this: Observable, ...observables: Array | ((...values: Array) => R)>): Observable { return this.lift.call(zipStatic(this, ...observables)); }