WAITING FOR TSC 1.8: refactor(patches): move operator stubs from Observable.ts to patch files

package.json

@@ -126,7 +126,7 @@
     "systemjs": "^0.19.6",
     "systemjs-builder": "^0.10.6",
     "tslint": "3.3.0-dev.2",
-    "typescript": "1.9.0-dev.20160128",
+    "typescript": "1.9.0-dev.20160202",
     "validate-commit-msg": "1.1.1",
     "watch": "0.16.0",
     "watchify": "3.7.0",

src/Observable.ts

@@ -1,15 +1,10 @@
 import {Observer} from './Observer';
 import {Operator} from './Operator';
-import {Scheduler} from './Scheduler';
 import {Subscriber} from './Subscriber';
 import {Subscription} from './Subscription';
 import {root} from './util/root';
 import {CoreOperators} from './CoreOperators';
 import {SymbolShim} from './util/SymbolShim';
-import {GroupedObservable} from './operator/groupBy';
-import {ConnectableObservable} from './observable/ConnectableObservable';
-import {Subject} from './Subject';
-import {Notification} from './Notification';
 import {toSubscriber} from './util/toSubscriber';
 import {tryCatch} from './util/tryCatch';
 import {errorObject} from './util/errorObject';
@@ -183,103 +178,6 @@ export class Observable<T> implements CoreOperators<T>  {
   static webSocket: typeof WebSocketSubject.create;
   static zip: typeof zipStatic;
 
-  // core operators
-  buffer: (closingNotifier: Observable<any>) => Observable<T[]>;
-  bufferCount: (bufferSize: number, startBufferEvery: number) => Observable<T[]>;
-  bufferTime: (bufferTimeSpan: number, bufferCreationInterval?: number, scheduler?: Scheduler) => Observable<T[]>;
-  bufferToggle: <O>(openings: Observable<O>, closingSelector?: (openValue: O) => Observable<any>) => Observable<T[]>;
-  bufferWhen: (closingSelector: () => Observable<any>) => Observable<T[]>;
-  catch: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
-  combineAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
-  combineLatest: <R>(...observables: Array<Observable<any> |
-                                     Array<Observable<any>> |
-                                     ((...values: Array<any>) => R)>) => Observable<R>;
-  concat: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
-  concatAll: () => Observable<any>;
-  concatMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  concatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  count: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
-  dematerialize: () => Observable<any>;
-  debounce: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  debounceTime: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
-  defaultIfEmpty: <R>(defaultValue?: T | R) => Observable<T> | Observable<R>;
-  delay: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  delayWhen: (delayDurationSelector: (value: T) => Observable<any>, subscriptionDelay?: Observable<any>) => Observable<T>;
-  distinctUntilChanged: (compare?: (x: T, y: T) => boolean) => Observable<T>;
-  do: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
-  expand: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
-  filter: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;
-  finally: (finallySelector: () => void) => Observable<T>;
-  first: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-             resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
-  flatMap: <R>(project: ((x: T, ix: number) => Observable<any>),
-               projectResult?: (x: T, y: any, ix: number, iy: number) => R,
-               concurrent?: number) => Observable<R>;
-  flatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  groupBy: <K, R>(keySelector: (value: T) => K,
-               elementSelector?: (value: T) => R,
-               durationSelector?: (group: GroupedObservable<K, R>) => Observable<any>) => Observable<GroupedObservable<K, R>>;
-  ignoreElements: () => Observable<T>;
-  last: <R>(predicate?: (value: T, index: number) => boolean,
-            resultSelector?: (value: T, index: number) => R,
-            defaultValue?: any) => Observable<T> | Observable<R>;
-  let: <T, R>(func: (selector: Observable<T>) => Observable<R>) => Observable<R>;
-  letBind: <T, R>(func: (selector: Observable<T>) => Observable<R>) => Observable<R>;
-  every: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
-  map: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
-  mapTo: <R>(value: R) => Observable<R>;
-  materialize: () => Observable<Notification<T>>;
-  merge: (...observables: any[]) => Observable<any>;
-  mergeAll: (concurrent?: any) => Observable<any>;
-  mergeMap: <R>(project: ((x: T, ix: number) => Observable<any>),
-                projectResult?: (x: T, y: any, ix: number, iy: number) => R,
-                concurrent?: number) => Observable<R>;
-  mergeMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  multicast: (subjectOrSubjectFactory: Subject<T>|(() => Subject<T>)) => ConnectableObservable<T>;
-  observeOn: (scheduler: Scheduler, delay?: number) => Observable<T>;
-  partition: (predicate: (x: T) => boolean) => Observable<T>[];
-  pluck: (...properties: string[]) => Observable<any>;
-  publish: () => ConnectableObservable<T>;
-  publishBehavior: (value: any) => ConnectableObservable<T>;
-  publishReplay: (bufferSize?: number, windowTime?: number, scheduler?: Scheduler) => ConnectableObservable<T>;
-  publishLast: () => ConnectableObservable<T>;
-  race: (...observables: Array<Observable<T>>) => Observable<T>;
-  reduce: <R>(project: (acc: R, x: T) => R, seed?: R) => Observable<R>;
-  repeat: (count?: number) => Observable<T>;
-  retry: (count?: number) => Observable<T>;
-  retryWhen: (notifier: (errors: Observable<any>) => Observable<any>) => Observable<T>;
-  sample: (notifier: Observable<any>) => Observable<T>;
-  sampleTime: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  scan: <R>(accumulator: (acc: R, x: T) => R, seed?: T | R) => Observable<R>;
-  share: () => Observable<T>;
-  single: (predicate?: (value: T, index: number) => boolean) => Observable<T>;
-  skip: (count: number) => Observable<T>;
-  skipUntil: (notifier: Observable<any>) => Observable<T>;
-  skipWhile: (predicate: (x: T, index: number) => boolean) => Observable<T>;
-  startWith: (x: T) => Observable<T>;
-  subscribeOn: (scheduler: Scheduler, delay?: number) => Observable<T>;
-  switch: <R>() => Observable<R>;
-  switchMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  switchMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  take: (count: number) => Observable<T>;
-  takeLast: (count: number) => Observable<T>;
-  takeUntil: (notifier: Observable<any>) => Observable<T>;
-  takeWhile: (predicate: (value: T, index: number) => boolean) => Observable<T>;
-  throttle: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  throttleTime: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  timeout: (due: number | Date, errorToSend?: any, scheduler?: Scheduler) => Observable<T>;
-  timeoutWith: <R>(due: number | Date, withObservable: Observable<R>, scheduler?: Scheduler) => Observable<T> | Observable<R>;
-  toArray: () => Observable<T[]>;
-  toPromise: (PromiseCtor?: typeof Promise) => Promise<T>;
-  window: (closingNotifier: Observable<any>) => Observable<Observable<T>>;
-  windowCount: (windowSize: number, startWindowEvery: number) => Observable<Observable<T>>;
-  windowTime: (windowTimeSpan: number, windowCreationInterval?: number, scheduler?: Scheduler) => Observable<Observable<T>>;
-  windowToggle: <O>(openings: Observable<O>, closingSelector?: (openValue: O) => Observable<any>) => Observable<Observable<T>>;
-  windowWhen: (closingSelector: () => Observable<any>) => Observable<Observable<T>>;
-  withLatestFrom: <R>(...observables: Array<Observable<any> | ((...values: Array<any>) => R)>) => Observable<R>;
-  zip: <R>(...observables: Array<Observable<any> | ((...values: Array<any>) => R)>) => Observable<R>;
-  zipAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
-
   /**
    * @method Symbol.observable
    * @returns {Observable} this instance of the observable

src/Rx.ts

@@ -8,109 +8,109 @@ import {Observable} from './Observable';
 
 // statics
 /* tslint:disable:no-use-before-declare */
-import './add/observable/combineLatest';
-import './add/observable/concat';
-import './add/observable/merge';
-import './add/observable/race';
-import './add/observable/bindCallback';
-import './add/observable/bindNodeCallback';
-import './add/observable/defer';
-import './add/observable/empty';
-import './add/observable/forkJoin';
-import './add/observable/from';
-import './add/observable/fromArray';
-import './add/observable/fromEvent';
-import './add/observable/fromEventPattern';
-import './add/observable/fromPromise';
-import './add/observable/interval';
-import './add/observable/never';
-import './add/observable/range';
-import './add/observable/throw';
-import './add/observable/timer';
-import './add/observable/zip';
+export * from './add/observable/combineLatest';
+export * from './add/observable/concat';
+export * from './add/observable/merge';
+export * from './add/observable/race';
+export * from './add/observable/bindCallback';
+export * from './add/observable/bindNodeCallback';
+export * from './add/observable/defer';
+export * from './add/observable/empty';
+export * from './add/observable/forkJoin';
+export * from './add/observable/from';
+export * from './add/observable/fromArray';
+export * from './add/observable/fromEvent';
+export * from './add/observable/fromEventPattern';
+export * from './add/observable/fromPromise';
+export * from './add/observable/interval';
+export * from './add/observable/never';
+export * from './add/observable/range';
+export * from './add/observable/throw';
+export * from './add/observable/timer';
+export * from './add/observable/zip';
 
 //operators
-import './add/operator/buffer';
-import './add/operator/bufferCount';
-import './add/operator/bufferTime';
-import './add/operator/bufferToggle';
-import './add/operator/bufferWhen';
-import './add/operator/catch';
-import './add/operator/combineAll';
-import './add/operator/combineLatest';
-import './add/operator/concat';
-import './add/operator/concatAll';
-import './add/operator/concatMap';
-import './add/operator/concatMapTo';
-import './add/operator/count';
-import './add/operator/dematerialize';
-import './add/operator/debounce';
-import './add/operator/debounceTime';
-import './add/operator/defaultIfEmpty';
-import './add/operator/delay';
-import './add/operator/delayWhen';
-import './add/operator/distinctUntilChanged';
-import './add/operator/do';
-import './add/operator/expand';
-import './add/operator/filter';
-import './add/operator/finally';
-import './add/operator/first';
-import './add/operator/groupBy';
-import './add/operator/ignoreElements';
-import './add/operator/every';
-import './add/operator/last';
-import './add/operator/let';
-import './add/operator/map';
-import './add/operator/mapTo';
-import './add/operator/materialize';
-import './add/operator/merge';
-import './add/operator/mergeAll';
-import './add/operator/mergeMap';
-import './add/operator/mergeMapTo';
-import './add/operator/multicast';
-import './add/operator/observeOn';
-import './add/operator/partition';
-import './add/operator/pluck';
-import './add/operator/publish';
-import './add/operator/publishBehavior';
-import './add/operator/publishReplay';
-import './add/operator/publishLast';
-import './add/operator/race';
-import './add/operator/reduce';
-import './add/operator/repeat';
-import './add/operator/retry';
-import './add/operator/retryWhen';
-import './add/operator/sample';
-import './add/operator/sampleTime';
-import './add/operator/scan';
-import './add/operator/share';
-import './add/operator/single';
-import './add/operator/skip';
-import './add/operator/skipUntil';
-import './add/operator/skipWhile';
-import './add/operator/startWith';
-import './add/operator/subscribeOn';
-import './add/operator/switch';
-import './add/operator/switchMap';
-import './add/operator/switchMapTo';
-import './add/operator/take';
-import './add/operator/takeLast';
-import './add/operator/takeUntil';
-import './add/operator/takeWhile';
-import './add/operator/throttle';
-import './add/operator/throttleTime';
-import './add/operator/timeout';
-import './add/operator/timeoutWith';
-import './add/operator/toArray';
-import './add/operator/toPromise';
-import './add/operator/window';
-import './add/operator/windowCount';
-import './add/operator/windowTime';
-import './add/operator/windowToggle';
-import './add/operator/windowWhen';
-import './add/operator/withLatestFrom';
-import './add/operator/zip';
-import './add/operator/zipAll';
+export * from './add/operator/buffer';
+export * from './add/operator/bufferCount';
+export * from './add/operator/bufferTime';
+export * from './add/operator/bufferToggle';
+export * from './add/operator/bufferWhen';
+export * from './add/operator/catch';
+export * from './add/operator/combineAll';
+export * from './add/operator/combineLatest';
+export * from './add/operator/concat';
+export * from './add/operator/concatAll';
+export * from './add/operator/concatMap';
+export * from './add/operator/concatMapTo';
+export * from './add/operator/count';
+export * from './add/operator/dematerialize';
+export * from './add/operator/debounce';
+export * from './add/operator/debounceTime';
+export * from './add/operator/defaultIfEmpty';
+export * from './add/operator/delay';
+export * from './add/operator/delayWhen';
+export * from './add/operator/distinctUntilChanged';
+export * from './add/operator/do';
+export * from './add/operator/expand';
+export * from './add/operator/filter';
+export * from './add/operator/finally';
+export * from './add/operator/first';
+export * from './add/operator/groupBy';
+export * from './add/operator/ignoreElements';
+export * from './add/operator/every';
+export * from './add/operator/last';
+export * from './add/operator/let';
+export * from './add/operator/map';
+export * from './add/operator/mapTo';
+export * from './add/operator/materialize';
+export * from './add/operator/merge';
+export * from './add/operator/mergeAll';
+export * from './add/operator/mergeMap';
+export * from './add/operator/mergeMapTo';
+export * from './add/operator/multicast';
+export * from './add/operator/observeOn';
+export * from './add/operator/partition';
+export * from './add/operator/pluck';
+export * from './add/operator/publish';
+export * from './add/operator/publishBehavior';
+export * from './add/operator/publishReplay';
+export * from './add/operator/publishLast';
+export * from './add/operator/race';
+export * from './add/operator/reduce';
+export * from './add/operator/repeat';
+export * from './add/operator/retry';
+export * from './add/operator/retryWhen';
+export * from './add/operator/sample';
+export * from './add/operator/sampleTime';
+export * from './add/operator/scan';
+export * from './add/operator/share';
+export * from './add/operator/single';
+export * from './add/operator/skip';
+export * from './add/operator/skipUntil';
+export * from './add/operator/skipWhile';
+export * from './add/operator/startWith';
+export * from './add/operator/subscribeOn';
+export * from './add/operator/switch';
+export * from './add/operator/switchMap';
+export * from './add/operator/switchMapTo';
+export * from './add/operator/take';
+export * from './add/operator/takeLast';
+export * from './add/operator/takeUntil';
+export * from './add/operator/takeWhile';
+export * from './add/operator/throttle';
+export * from './add/operator/throttleTime';
+export * from './add/operator/timeout';
+export * from './add/operator/timeoutWith';
+export * from './add/operator/toArray';
+export * from './add/operator/toPromise';
+export * from './add/operator/window';
+export * from './add/operator/windowCount';
+export * from './add/operator/windowTime';
+export * from './add/operator/windowToggle';
+export * from './add/operator/windowWhen';
+export * from './add/operator/withLatestFrom';
+export * from './add/operator/zip';
+export * from './add/operator/zipAll';
 
 /* tslint:disable:no-unused-variable */
 import {Operator} from './Operator';

src/add/observable/bindCallback.ts

@@ -1,6 +1,4 @@
 import {Observable} from '../../Observable';
 import {BoundCallbackObservable} from '../../observable/BoundCallbackObservable';
 
-Observable.bindCallback = BoundCallbackObservable.create;
-
-export var _void: void;
+Observable.bindCallback = BoundCallbackObservable.create;

src/add/observable/bindNodeCallback.ts

@@ -1,6 +1,4 @@
 import {Observable} from '../../Observable';
 import {BoundNodeCallbackObservable} from '../../observable/BoundNodeCallbackObservable';
 
-Observable.bindNodeCallback = BoundNodeCallbackObservable.create;
-
-export var _void: void;
+Observable.bindNodeCallback = BoundNodeCallbackObservable.create;

src/add/observable/combineLatest.ts

@@ -1,6 +1,4 @@
 import {Observable} from '../../Observable';
 import {combineLatestStatic} from '../../operator/combineLatest';
 
-Observable.combineLatest = combineLatestStatic;
-
-export var _void: void;
+Observable.combineLatest = combineLatestStatic;

src/add/observable/concat.ts

@@ -2,6 +2,4 @@
 import {Observable} from '../../Observable';
 import {concatStatic} from '../../operator/concat';
 
-Observable.concat = concatStatic;
-
-export var _void: void;
+Observable.concat = concatStatic;

src/add/observable/defer.ts

@@ -1,6 +1,4 @@
 import {Observable} from '../../Observable';
 import {DeferObservable} from '../../observable/DeferObservable';
 
-Observable.defer = DeferObservable.create;
-
-export var _void: void;
+Observable.defer = DeferObservable.create;

src/add/observable/dom/ajax.ts

@@ -2,6 +2,4 @@
 import {Observable} from '../../../Observable';
 import {AjaxObservable} from '../../../observable/dom/AjaxObservable';
 
-Observable.ajax = AjaxObservable.create;
-
-export var _void: void;
+Observable.ajax = AjaxObservable.create;