Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 4 commits into from
Closed

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
7350287
refactor(patches): move operator stubs from Observable.ts to patch files
masaeedu Jan 30, 2016
61841f6
refactor(patches): update Rx.ts to re-export all patch files
masaeedu Feb 2, 2016
142ebdb
refactor(patches): move stub to patch file for delayWhen
masaeedu Feb 2, 2016
5abaac1
fix(Rx.ts): import to prevent erasure in JS files
masaeedu Feb 2, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion package.json
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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",
Expand Down
102 changes: 0 additions & 102 deletions src/Observable.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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';
Expand Down Expand Up @@ -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
Expand Down
208 changes: 97 additions & 111 deletions src/Rx.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,9 +2,9 @@
// Subject imported before Observable to bypass circular dependency issue since
// Subject extends Observable and Observable references Subject in it's
// definition
import {Subject} from './Subject';
export {Subject} from './Subject';
/* tslint:enable:no-unused-variable */
import {Observable} from './Observable';
export {Observable} from './Observable';

// statics
/* tslint:disable:no-use-before-declare */
Expand All @@ -30,101 +30,102 @@ import './add/observable/timer';
import './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';
import './add/operator/buffer'; export * from './add/operator/buffer';
import './add/operator/bufferCount'; export * from './add/operator/bufferCount';
import './add/operator/bufferTime'; export * from './add/operator/bufferTime';
import './add/operator/bufferToggle'; export * from './add/operator/bufferToggle';
import './add/operator/bufferWhen'; export * from './add/operator/bufferWhen';
import './add/operator/catch'; export * from './add/operator/catch';
import './add/operator/combineAll'; export * from './add/operator/combineAll';
import './add/operator/combineLatest'; export * from './add/operator/combineLatest';
import './add/operator/concat'; export * from './add/operator/concat';
import './add/operator/concatAll'; export * from './add/operator/concatAll';
import './add/operator/concatMap'; export * from './add/operator/concatMap';
import './add/operator/concatMapTo'; export * from './add/operator/concatMapTo';
import './add/operator/count'; export * from './add/operator/count';
import './add/operator/dematerialize'; export * from './add/operator/dematerialize';
import './add/operator/debounce'; export * from './add/operator/debounce';
import './add/operator/debounceTime'; export * from './add/operator/debounceTime';
import './add/operator/defaultIfEmpty'; export * from './add/operator/defaultIfEmpty';
import './add/operator/delay'; export * from './add/operator/delay';
import './add/operator/delayWhen'; export * from './add/operator/delayWhen';
import './add/operator/distinctUntilChanged'; export * from './add/operator/distinctUntilChanged';
import './add/operator/do'; export * from './add/operator/do';
import './add/operator/expand'; export * from './add/operator/expand';
import './add/operator/filter'; export * from './add/operator/filter';
import './add/operator/finally'; export * from './add/operator/finally';
import './add/operator/first'; export * from './add/operator/first';
import './add/operator/groupBy'; export * from './add/operator/groupBy';
import './add/operator/ignoreElements'; export * from './add/operator/ignoreElements';
import './add/operator/every'; export * from './add/operator/every';
import './add/operator/last'; export * from './add/operator/last';
import './add/operator/let'; export * from './add/operator/let';
import './add/operator/map'; export * from './add/operator/map';
import './add/operator/mapTo'; export * from './add/operator/mapTo';
import './add/operator/materialize'; export * from './add/operator/materialize';
import './add/operator/merge'; export * from './add/operator/merge';
import './add/operator/mergeAll'; export * from './add/operator/mergeAll';
import './add/operator/mergeMap'; export * from './add/operator/mergeMap';
import './add/operator/mergeMapTo'; export * from './add/operator/mergeMapTo';
import './add/operator/multicast'; export * from './add/operator/multicast';
import './add/operator/observeOn'; export * from './add/operator/observeOn';
import './add/operator/partition'; export * from './add/operator/partition';
import './add/operator/pluck'; export * from './add/operator/pluck';
import './add/operator/publish'; export * from './add/operator/publish';
import './add/operator/publishBehavior'; export * from './add/operator/publishBehavior';
import './add/operator/publishReplay'; export * from './add/operator/publishReplay';
import './add/operator/publishLast'; export * from './add/operator/publishLast';
import './add/operator/race'; export * from './add/operator/race';
import './add/operator/reduce'; export * from './add/operator/reduce';
import './add/operator/repeat'; export * from './add/operator/repeat';
import './add/operator/retry'; export * from './add/operator/retry';
import './add/operator/retryWhen'; export * from './add/operator/retryWhen';
import './add/operator/sample'; export * from './add/operator/sample';
import './add/operator/sampleTime'; export * from './add/operator/sampleTime';
import './add/operator/scan'; export * from './add/operator/scan';
import './add/operator/share'; export * from './add/operator/share';
import './add/operator/single'; export * from './add/operator/single';
import './add/operator/skip'; export * from './add/operator/skip';
import './add/operator/skipUntil'; export * from './add/operator/skipUntil';
import './add/operator/skipWhile'; export * from './add/operator/skipWhile';
import './add/operator/startWith'; export * from './add/operator/startWith';
import './add/operator/subscribeOn'; export * from './add/operator/subscribeOn';
import './add/operator/switch'; export * from './add/operator/switch';
import './add/operator/switchMap'; export * from './add/operator/switchMap';
import './add/operator/switchMapTo'; export * from './add/operator/switchMapTo';
import './add/operator/take'; export * from './add/operator/take';
import './add/operator/takeLast'; export * from './add/operator/takeLast';
import './add/operator/takeUntil'; export * from './add/operator/takeUntil';
import './add/operator/takeWhile'; export * from './add/operator/takeWhile';
import './add/operator/throttle'; export * from './add/operator/throttle';
import './add/operator/throttleTime'; export * from './add/operator/throttleTime';
import './add/operator/timeout'; export * from './add/operator/timeout';
import './add/operator/timeoutWith'; export * from './add/operator/timeoutWith';
import './add/operator/toArray'; export * from './add/operator/toArray';
import './add/operator/toPromise'; export * from './add/operator/toPromise';
import './add/operator/window'; export * from './add/operator/window';
import './add/operator/windowCount'; export * from './add/operator/windowCount';
import './add/operator/windowTime'; export * from './add/operator/windowTime';
import './add/operator/windowToggle'; export * from './add/operator/windowToggle';
import './add/operator/windowWhen'; export * from './add/operator/windowWhen';
import './add/operator/withLatestFrom'; export * from './add/operator/withLatestFrom';
import './add/operator/zip'; export * from './add/operator/zip';
import './add/operator/zipAll'; export * from './add/operator/zipAll';

/* tslint:disable:no-unused-variable */
import {Operator} from './Operator';
import {Observer} from './Observer';
import {Subscription, UnsubscriptionError} from './Subscription';
import {Subscriber} from './Subscriber';
import {AsyncSubject} from './subject/AsyncSubject';
import {ReplaySubject} from './subject/ReplaySubject';
import {BehaviorSubject} from './subject/BehaviorSubject';
import {ConnectableObservable} from './observable/ConnectableObservable';
import {Notification} from './Notification';
import {EmptyError} from './util/EmptyError';
import {ArgumentOutOfRangeError} from './util/ArgumentOutOfRangeError';
import {ObjectUnsubscribedError} from './util/ObjectUnsubscribedError';
export {Operator} from './Operator';
export {Observer} from './Observer';
export {Subscription, UnsubscriptionError} from './Subscription';
export {Subscriber} from './Subscriber';
export {AsyncSubject} from './subject/AsyncSubject';
export {ReplaySubject} from './subject/ReplaySubject';
export {BehaviorSubject} from './subject/BehaviorSubject';
export {ConnectableObservable} from './observable/ConnectableObservable';
export {Notification} from './Notification';
export {EmptyError} from './util/EmptyError';
export {ArgumentOutOfRangeError} from './util/ArgumentOutOfRangeError';
export {ObjectUnsubscribedError} from './util/ObjectUnsubscribedError';

import {asap} from './scheduler/asap';
import {queue} from './scheduler/queue';
import {AsapScheduler} from './scheduler/AsapScheduler';
Expand All @@ -144,21 +145,6 @@ var Symbol = {
/* tslint:enable:no-var-keyword */

export {
Subject,
Scheduler,
Observable,
Observer,
Operator,
Subscriber,
Subscription,
Symbol,
AsyncSubject,
ReplaySubject,
BehaviorSubject,
ConnectableObservable,
Notification,
EmptyError,
ArgumentOutOfRangeError,
ObjectUnsubscribedError,
UnsubscriptionError
Symbol
};
Loading