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
ReactiveX · Nov 14, 2016 · 60c0198 · 60c0198
1 parent 32e82cc
commit 60c0198
Show file tree

Hide file tree

Showing 34 changed files with 236 additions and 201 deletions.
diff --git a/src/observable/ForkJoinObservable.ts b/src/observable/ForkJoinObservable.ts
@@ -37,6 +37,7 @@ export class ForkJoinObservable<T> extends Observable<T> {
  static create<T>(...sources: SubscribableOrPromise<T>[]): Observable<T[]>;
  static create<R>(...sources: SubscribableOrPromise<any>[]): Observable<R>;
  /* tslint:enable:max-line-length */
+
  /**
  * @param sources
  * @return {any}

diff --git 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<T>(this: Observable<T>, bufferTimeSpan: number, scheduler?: Scheduler): Observable<T[]>;
+export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, bufferCreationInterval: number, scheduler?: Scheduler): Observable<T[]>;
+export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler?: Scheduler): Observable<T[]>;
+/* 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<T>(this: Observable<T>, bufferTimeSpan: number, scheduler?: Scheduler): Observable<T[]>;
-export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, bufferCreationInterval: number, scheduler?: Scheduler): Observable<T[]>;
-export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler?: Scheduler): Observable<T[]>;
-/* tslint:disable:max-line-length */
 export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number): Observable<T[]> {
  let length: number = arguments.length;
 

diff --git 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<T, R>(this: Observable<T>, selector: (err: any, caught: Observable<T>) => ObservableInput<R>): Observable<R> {

diff --git 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<T, R>(this: Observable<T>, project: (v1: T) => R): Observable<R>;
+export function combineLatest<T, T2, R>(this: Observable<T>, v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R): Observable<R>;
+export function combineLatest<T, T2, T3, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R): Observable<R>;
+export function combineLatest<T, T2, T3, T4, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable<R>;
+export function combineLatest<T, T2, T3, T4, T5, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable<R>;
+export function combineLatest<T, T2, T3, T4, T5, T6, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable<R> ;
+export function combineLatest<T, T2>(this: Observable<T>, v2: ObservableInput<T2>): Observable<[T, T2]>;
+export function combineLatest<T, T2, T3>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<[T, T2, T3]>;
+export function combineLatest<T, T2, T3, T4>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<[T, T2, T3, T4]>;
+export function combineLatest<T, T2, T3, T4, T5>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<[T, T2, T3, T4, T5]>;
+export function combineLatest<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<[T, T2, T3, T4, T5, T6]> ;
+export function combineLatest<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): Observable<R>;
+export function combineLatest<T, R>(this: Observable<T>, array: ObservableInput<T>[]): Observable<Array<T>>;
+export function combineLatest<T, TOther, R>(this: Observable<T>, array: ObservableInput<TOther>[], project: (v1: T, ...values: Array<TOther>) => R): Observable<R>;
+/* 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<T, R>(this: Observable<T>, project: (v1: T) => R): Observable<R>;
-export function combineLatest<T, T2, R>(this: Observable<T>, v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R): Observable<R>;
-export function combineLatest<T, T2, T3, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R): Observable<R>;
-export function combineLatest<T, T2, T3, T4, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R): Observable<R>;
-export function combineLatest<T, T2, T3, T4, T5, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R): Observable<R>;
-export function combineLatest<T, T2, T3, T4, T5, T6, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R): Observable<R> ;
-export function combineLatest<T, T2>(this: Observable<T>, v2: ObservableInput<T2>): Observable<[T, T2]>;
-export function combineLatest<T, T2, T3>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<[T, T2, T3]>;
-export function combineLatest<T, T2, T3, T4>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<[T, T2, T3, T4]>;
-export function combineLatest<T, T2, T3, T4, T5>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<[T, T2, T3, T4, T5]>;
-export function combineLatest<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<[T, T2, T3, T4, T5, T6]> ;
-export function combineLatest<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): Observable<R>;
-export function combineLatest<T, R>(this: Observable<T>, array: ObservableInput<T>[]): Observable<Array<T>>;
-export function combineLatest<T, TOther, R>(this: Observable<T>, array: ObservableInput<TOther>[], project: (v1: T, ...values: Array<TOther>) => R): Observable<R>;
-/* tslint:disable:max-line-length */
 export function combineLatest<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> |
  Array<ObservableInput<any>> |
  ((...values: Array<any>) => R)>): Observable<R> {

diff --git 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<T>(this: Observable<T>, scheduler?: Scheduler): Observable<T>;
+export function concat<T, T2>(this: Observable<T>, v2: ObservableInput<T2>, scheduler?: Scheduler): Observable<T | T2>;
+export function concat<T, T2, T3>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: Scheduler): Observable<T | T2 | T3>;
+export function concat<T, T2, T3, T4>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+export function concat<T, T2, T3, T4, T5>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+export function concat<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+export function concat<T>(this: Observable<T>, ...observables: Array<ObservableInput<T> | Scheduler>): Observable<T>;
+export function concat<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | Scheduler>): Observable<R>;
+/* 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<T>(this: Observable<T>, scheduler?: Scheduler): Observable<T>;
-export function concat<T, T2>(this: Observable<T>, v2: ObservableInput<T2>, scheduler?: Scheduler): Observable<T | T2>;
-export function concat<T, T2, T3>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: Scheduler): Observable<T | T2 | T3>;
-export function concat<T, T2, T3, T4>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
-export function concat<T, T2, T3, T4, T5>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
-export function concat<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
-export function concat<T>(this: Observable<T>, ...observables: Array<ObservableInput<T> | Scheduler>): Observable<T>;
-export function concat<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | Scheduler>): Observable<R>;
-/* tslint:disable:max-line-length */
 export function concat<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | Scheduler>): Observable<R> {
  return this.lift.call(concatStatic<T, R>(this, ...observables));
 }

diff --git 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<T>(this: Observable<T>): T;
+export function concatAll<T, R>(this: Observable<T>): Subscribable<R>;
+/* 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<T>(this: Observable<T>): T;
-export function concatAll<T, R>(this: Observable<T>): Subscribable<R>;
-/* tslint:disable:max-line-length */
 export function concatAll<T>(this: Observable<T>): T {
  return <any>this.lift<any>(new MergeAllOperator<T>(1));
 }
diff --git 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<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>): Observable<R>;
+export function concatMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+/* 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<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>): Observable<R>;
-export function concatMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
 export function concatMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<I>,
  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
@@ -1,6 +1,11 @@
 import { Observable, ObservableInput } from '../Observable';
 import { MergeMapToOperator } from './mergeMapTo';
 
+/* tslint:disable:max-line-length */
+export function concatMapTo<T, R>(this: Observable<T>, observable: ObservableInput<R>): Observable<R>;
+export function concatMapTo<T, I, R>(this: Observable<T>, observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+/* 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<T, R>(this: Observable<T>, observable: ObservableInput<R>): Observable<R>;
-export function concatMapTo<T, I, R>(this: Observable<T>, observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
 export function concatMapTo<T, I, R>(this: Observable<T>, innerObservable: Observable<I>,
  resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R> {
  return this.lift(new MergeMapToOperator(innerObservable, resultSelector, 1));

diff --git 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<T>(this: Observable<T>, defaultValue?: T): Observable<T>;
+export function defaultIfEmpty<T, R>(this: Observable<T>, defaultValue?: R): Observable<T | R>;
+/* 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<T>(this: Observable<T>, defaultValue?: T): Observable<T>;
-export function defaultIfEmpty<T, R>(this: Observable<T>, defaultValue?: R): Observable<T | R>;
-/* tslint:disable:max-line-length */
 export function defaultIfEmpty<T, R>(this: Observable<T>, defaultValue: R = null): Observable<T | R> {
  return this.lift(new DefaultIfEmptyOperator(defaultValue));
 }

diff --git 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<T>(this: Observable<T>, compare?: (x: T, y: T) => boolean): Observable<T>;
+export function distinctUntilChanged<T, K>(this: Observable<T>, compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): Observable<T>;
+/* 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<T>(this: Observable<T>, compare?: (x: T, y: T) => boolean): Observable<T>;
-export function distinctUntilChanged<T, K>(this: Observable<T>, compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): Observable<T>;
-/* tslint:disable:max-line-length */
 export function distinctUntilChanged<T, K>(this: Observable<T>, compare?: (x: K, y: K) => boolean, keySelector?: (x: T) => K): Observable<T> {
  return this.lift(new DistinctUntilChangedOperator<T, K>(compare, keySelector));
 }

diff --git 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<T>(this: Observable<T>, key: string): Observable<T>;
+export function distinctUntilKeyChanged<T, K>(this: Observable<T>, key: string, compare: (x: K, y: K) => boolean): Observable<T>;
+/* 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<T>(this: Observable<T>, key: string): Observable<T>;
-export function distinctUntilKeyChanged<T, K>(this: Observable<T>, key: string, compare: (x: K, y: K) => boolean): Observable<T>;
-/* tslint:disable:max-line-length */
 export function distinctUntilKeyChanged<T>(this: Observable<T>, key: string, compare?: (x: T, y: T) => boolean): Observable<T> {
  return distinctUntilChanged.call(this, function(x: T, y: T) {
  if (compare) {

diff --git 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<T>(this: Observable<T>, next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable<T>;
+export function _do<T>(this: Observable<T>, observer: PartialObserver<T>): Observable<T>;
+/* 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<T>(this: Observable<T>, next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable<T>;
-export function _do<T>(this: Observable<T>, observer: PartialObserver<T>): Observable<T>;
-/* tslint:disable:max-line-length */
 export function _do<T>(this: Observable<T>, nextOrObserver?: PartialObserver<T> | ((x: T) => void),
  error?: (e: any) => void,
  complete?: () => void): Observable<T> {