refactor(operator): remove Observable-patching side effect from opera…

…tors

src/operator/buffer.ts

@@ -74,5 +74,3 @@ class BufferClosingNotifierSubscriber<T> extends Subscriber<T> {
     this.parent.complete();
   }
 }
-
-Observable.prototype.buffer = buffer;

src/operator/bufferCount.ts

@@ -76,5 +76,3 @@ class BufferCountSubscriber<T> extends Subscriber<T> {
     destination.complete();
   }
 }
-
-Observable.prototype.bufferCount = bufferCount;

src/operator/bufferTime.ts

@@ -114,5 +114,3 @@ function dispatchBufferCreation(state) {
 function dispatchBufferClose({ subscriber, buffer }) {
   subscriber.closeBuffer(buffer);
 }
-
-Observable.prototype.bufferTime = bufferTime;

src/operator/bufferToggle.ts

@@ -145,5 +145,3 @@ class BufferToggleClosingsSubscriber<T> extends Subscriber<T> {
     this.parent.closeBuffer(this.context);
   }
 }
-
-Observable.prototype.bufferToggle = bufferToggle;

src/operator/bufferWhen.ts

@@ -91,5 +91,3 @@ class BufferClosingNotifierSubscriber<T> extends Subscriber<T> {
     this.parent.openBuffer();
   }
 }
-
-Observable.prototype.bufferWhen = bufferWhen;

src/operator/catch.ts

@@ -64,5 +64,3 @@ class CatchSubscriber<T> extends Subscriber<T> {
     this.lastSubscription.unsubscribe();
   }
 }
-
-Observable.prototype.catch = _catch;

src/operator/combineAll.ts

@@ -1,5 +1,4 @@
 import {CombineLatestOperator} from './combineLatest-support';
-import {Observable} from '../Observable';
 
 /**
  * Takes an Observable of Observables, and collects all observables from it. Once the outer observable
@@ -16,5 +15,3 @@ import {Observable} from '../Observable';
 export function combineAll<T, R>(project?: (...values: Array<any>) => R) {
   return this.lift(new CombineLatestOperator(project));
 }
-
-Observable.prototype.combineAll = combineAll;

src/operator/combineLatest-static.ts

@@ -38,5 +38,3 @@ export function combineLatest<R>(...observables: Array<Observable<any> |
 
   return new ArrayObservable(observables, scheduler).lift(new CombineLatestOperator(project));
 }
-
-Observable.combineLatest = combineLatest;

src/operator/combineLatest.ts

@@ -31,5 +31,3 @@ export function combineLatest<R>(...observables: Array<Observable<any> |
 
   return new ArrayObservable(observables).lift(new CombineLatestOperator(project));
 }
-
-Observable.prototype.combineLatest = combineLatest;

src/operator/concat-static.ts

@@ -21,5 +21,3 @@ export function concat<R>(...observables: Array<Observable<any> | Scheduler>): O
 
   return new ArrayObservable(observables, scheduler).lift(new MergeAllOperator(1));
 }
-
-Observable.concat = concat;

src/operator/concat.ts

@@ -23,5 +23,3 @@ export function concat<R>(...observables: (Observable<any> | Scheduler)[]): Obse
 
    return new ArrayObservable(args, scheduler).lift(new MergeAllOperator(1));
 }
-
-Observable.prototype.concat = concat;

src/operator/concatAll.ts

@@ -15,5 +15,3 @@ import {MergeAllOperator} from './mergeAll-support';
 export function concatAll<T>(): Observable<T> {
   return this.lift(new MergeAllOperator(1));
 }
-
-Observable.prototype.concatAll = concatAll;

src/operator/concatMap.ts

@@ -24,5 +24,3 @@ export function concatMap<T, R>(project: (value: T, index: number) => Observable
                                 projectResult?: (outerValue: T, innerValue: any, outerIndex: number, innerIndex: number) => R) {
   return this.lift(new MergeMapOperator(project, projectResult, 1));
 }
-
-Observable.prototype.concatMap = concatMap;

src/operator/concatMapTo.ts

@@ -21,5 +21,3 @@ export function concatMapTo<T, R, R2>(observable: Observable<R>,
                                                        innerIndex: number) => R2): Observable<R2> {
   return this.lift(new MergeMapToOperator(observable, projectResult, 1));
 }
-
-Observable.prototype.concatMapTo = concatMapTo;

src/operator/count.ts

@@ -76,5 +76,3 @@ class CountSubscriber<T, R> extends Subscriber<T> {
     this.destination.complete();
   }
 }
-
-Observable.prototype.count = count;

src/operator/debounce.ts

@@ -105,5 +105,3 @@ class DurationSelectorSubscriber<T> extends Subscriber<T> {
     this.debounceNext();
   }
 }
-
-Observable.prototype.debounce = debounce;

src/operator/debounceTime.ts

@@ -61,5 +61,3 @@ class DebounceTimeSubscriber<T> extends Subscriber<T> {
 function dispatchNext(subscriber) {
   subscriber.debouncedNext();
 }
-
-Observable.prototype.debounceTime = debounceTime;

src/operator/defaultIfEmpty.ts

@@ -36,5 +36,3 @@ class DefaultIfEmptySubscriber<T, R> extends Subscriber<T> {
     this.destination.complete();
   }
 }
-
-Observable.prototype.defaultIfEmpty = defaultIfEmpty;

src/operator/delay.ts

@@ -1,5 +1,4 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
 import {Scheduler} from '../Scheduler';
 import {Subscriber} from '../Subscriber';
 import {Notification} from '../Notification';
@@ -93,5 +92,3 @@ class DelayMessage<T> {
               private notification: any) {
   }
 }
-
-Observable.prototype.delay = delay;

src/operator/dematerialize.ts

@@ -22,5 +22,3 @@ class DeMaterializeSubscriber<T extends Notification<any>> extends Subscriber<T>
     value.observe(this.destination);
   }
 }
-
-Observable.prototype.dematerialize = dematerialize;

src/operator/distinctUntilChanged.ts

@@ -1,5 +1,4 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {tryCatch} from '../util/tryCatch';
 import {errorObject} from '../util/errorObject';
@@ -60,5 +59,3 @@ class DistinctUntilChangedSubscriber<T> extends Subscriber<T> {
     }
   }
 }
-
-Observable.prototype.distinctUntilChanged = distinctUntilChanged;

src/operator/do.ts

@@ -1,5 +1,4 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
 import {Observer} from '../Observer';
 import {Subscriber} from '../Subscriber';
 
@@ -76,5 +75,3 @@ class DoSubscriber<T> extends Subscriber<T> {
     }
   }
 }
-
-Observable.prototype.do = _do;

src/operator/every.ts

@@ -85,5 +85,3 @@ class EverySubscriber<T, R> extends Subscriber<T> {
     this.notifyComplete(true);
   }
 }
-
-Observable.prototype.every = every;

src/operator/expand.ts

@@ -5,5 +5,3 @@ export function expand<T, R>(project: (value: T, index: number) => Observable<R>
                              concurrent: number = Number.POSITIVE_INFINITY): Observable<R> {
   return this.lift(new ExpandOperator(project, concurrent));
 }
-
-Observable.prototype.expand = expand;

src/operator/extended/distinctUntilKeyChanged.ts

@@ -1,8 +1,4 @@
 import {distinctUntilChanged} from '../distinctUntilChanged';
-import {Observable} from '../../Observable';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function distinctUntilKeyChanged<T>(key: string, compare?: (x: any, y: any) => boolean, thisArg?: any) {
   return distinctUntilChanged.call(this, function(x, y) {
@@ -12,5 +8,3 @@ export function distinctUntilKeyChanged<T>(key: string, compare?: (x: any, y: an
     return x[key] === y[key];
   });
 }
-
-observableProto.distinctUntilKeyChanged = distinctUntilKeyChanged;

src/operator/extended/elementAt.ts

@@ -1,10 +1,6 @@
 import {Operator} from '../../Operator';
 import {Subscriber} from '../../Subscriber';
 import {ArgumentOutOfRangeError} from '../../util/ArgumentOutOfRangeError';
-import {Observable} from '../../Observable';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function elementAt(index: number, defaultValue?: any) {
   return this.lift(new ElementAtOperator(index, defaultValue));
@@ -48,5 +44,3 @@ class ElementAtSubscriber<T, R> extends Subscriber<T> {
     destination.complete();
   }
 }
-
-observableProto.elementAt = elementAt;

src/operator/extended/find.ts

@@ -1,11 +1,6 @@
 import {FindValueOperator} from './find-support';
 import {Observable} from '../../Observable';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function find<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T> {
   return this.lift(new FindValueOperator(predicate, this, false, thisArg));
 }
-
-observableProto.find = find;

src/operator/extended/findIndex.ts

@@ -1,11 +1,6 @@
 import {Observable} from '../../Observable';
 import {FindValueOperator} from './find-support';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function findIndex<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number> {
   return this.lift(new FindValueOperator(predicate, this, true, thisArg));
 }
-
-observableProto.findIndex = findIndex;

src/operator/extended/isEmpty.ts

@@ -1,9 +1,5 @@
 import {Operator} from '../../Operator';
 import {Subscriber} from '../../Subscriber';
-import {Observable} from '../../Observable';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function isEmpty() {
   return this.lift(new IsEmptyOperator());
@@ -36,5 +32,3 @@ class IsEmptySubscriber<T> extends Subscriber<T> {
     this.notifyComplete(true);
   }
 }
-
-observableProto.isEmpty = isEmpty;

src/operator/extended/max.ts

@@ -1,14 +1,9 @@
 import {Observable} from '../../Observable';
 import {ReduceOperator} from '../reduce-support';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function max<T, R>(comparer?: (x: R, y: T) => R): Observable<R> {
   const max = (typeof comparer === 'function')
     ? comparer
     : (x, y) => x > y ? x : y;
   return this.lift(new ReduceOperator(max));
 }
-
-observableProto.max = max;

src/operator/extended/mergeScan.ts

@@ -6,9 +6,6 @@ import {tryCatch} from '../../util/tryCatch';
 import {errorObject} from '../../util/errorObject';
 import {subscribeToResult} from '../../util/subscribeToResult';
 import {OuterSubscriber} from '../../OuterSubscriber';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function mergeScan<T, R>(project: (acc: R, x: T) => Observable<R>, seed: R) {
   return this.lift(new MergeScanOperator(project, seed));
@@ -92,5 +89,3 @@ export class MergeScanSubscriber<T, R> extends OuterSubscriber<T, R> {
     }
   }
 }
-
-observableProto.mergeScan = mergeScan;

src/operator/extended/min.ts

@@ -1,14 +1,9 @@
 import {Observable} from '../../Observable';
 import {ReduceOperator} from '../reduce-support';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function min<T, R>(comparer?: (x: R, y: T) => R): Observable<R> {
   const min = (typeof comparer === 'function')
     ? comparer
     : (x, y) => x < y ? x : y;
   return this.lift(new ReduceOperator(min));
 }
-
-observableProto.min = min;

src/operator/extended/timeInterval.ts

@@ -3,9 +3,6 @@ import {Observable} from '../../Observable';
 import {Subscriber} from '../../Subscriber';
 import {Scheduler} from '../../Scheduler';
 import {immediate} from '../../scheduler/immediate';
-import {KitchenSinkOperators} from '../../Rx.KitchenSink';
-
-const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
 
 export function timeInterval<T>(scheduler: Scheduler = immediate): Observable<TimeInterval> {
   return this.lift(new TimeIntervalOperator(scheduler));
@@ -44,5 +41,3 @@ class TimeIntervalSubscriber<TimeInterval> extends Subscriber<TimeInterval> {
     this.destination.next(new TimeInterval(value, span));
   }
 }
-
-observableProto.timeInterval = timeInterval;

src/operator/filter.ts

@@ -1,5 +1,4 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {tryCatch} from '../util/tryCatch';
 import {errorObject} from '../util/errorObject';
@@ -8,7 +7,7 @@ import {bindCallback} from '../util/bindCallback';
 /**
  * Similar to the well-known `Array.prototype.filter` method, this operator filters values down to a set
  * allowed by a `select` function
- * 
+ *
  * @param {Function} select a function that is used to select the resulting values
  *  if it returns `true`, the value is emitted, if `false` the value is not passed to the resulting observable
  * @param {any} [thisArg] an optional argument to determine the value of `this` in the `select` function
@@ -50,5 +49,3 @@ class FilterSubscriber<T> extends Subscriber<T> {
     }
   }
 }
-
-Observable.prototype.filter = filter;

src/operator/finally.ts

@@ -1,5 +1,4 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {Subscription} from '../Subscription';
 import {bindCallback} from '../util/bindCallback';
@@ -29,5 +28,3 @@ class FinallySubscriber<T> extends Subscriber<T> {
     this.add(new Subscription(finallySelector));
   }
 }
-
-Observable.prototype.finally = _finally;

src/operator/first.ts

@@ -72,5 +72,3 @@ class FirstSubscriber<T, R> extends Subscriber<T> {
     }
   }
 }
-
-Observable.prototype.first = first;

src/operator/groupBy.ts

@@ -138,5 +138,3 @@ class GroupDurationSubscriber<T> extends Subscriber<T> {
     this.parent.removeGroup(this.key);
   }
 }
-
-Observable.prototype.groupBy = groupBy;

src/operator/ignoreElements.ts

@@ -1,5 +1,4 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {noop} from '../util/noop';
 
@@ -18,5 +17,3 @@ class IgnoreElementsSubscriber<T> extends Subscriber<T> {
     noop();
   }
 }
-
-Observable.prototype.ignoreElements = ignoreElements;

src/operator/last.ts

@@ -80,5 +80,3 @@ class LastSubscriber<T, R> extends Subscriber<T> {
     }
   }
 }
-
-Observable.prototype.last = last;