Skip to content

Commit df98bc3

Browse files
robwormaldrobwormald
committed
refactor(all): modularize imports
Change from monolithic entry points to individual operators patching the protype.
1 parent a643efa commit df98bc3

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

94 files changed

+446
-542
lines changed

‎src/Observable.ts

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -228,10 +228,13 @@ export class Observable<T> implements CoreOperators<T> {
228228
single: (predicate?: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
229229
skip: (count: number) => Observable<T>;
230230
skipUntil: (notifier: Observable<any>) => Observable<T>;
231+
skipWhile: (predicate: (x: T, index: number) => boolean, thisArg?: any) => Observable<T>;
231232
startWith: (x: T) => Observable<T>;
232233
subscribeOn: (scheduler: Scheduler, delay?: number) => Observable<T>;
233234
switch: <R>() => Observable<R>;
235+
switchFirst: <T>() => Observable<T>;
234236
switchMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
237+
switchMapFirst: <T, R, R2>(project: (x: T, ix: number) => Observable<R>, rSelector?: (x: T, y: R, ix: number, iy: number) => R2) => Observable<R>;
235238
switchMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
236239
take: (count: number) => Observable<T>;
237240
takeUntil: (notifier: Observable<any>) => Observable<T>;

‎src/Rx.KitchenSink.ts

Lines changed: 85 additions & 262 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ import {Observable} from './Observable';
22
import {CoreOperators} from './CoreOperators';
33
import {Scheduler as IScheduler} from './Scheduler';
44

5-
interface KitchenSinkOperators<T> extends CoreOperators<T> {
5+
export interface KitchenSinkOperators<T> extends CoreOperators<T> {
66
isEmpty?: () => Observable<boolean>;
77
elementAt?: (index: number, defaultValue?: any) => Observable<T>;
88
distinctUntilKeyChanged?: (key: string, compare?: (x: any, y: any) => boolean, thisArg?: any) => Observable<T>;
@@ -77,267 +77,90 @@ import {zip as zipStatic} from './operators/zip-static';
7777
Observable.zip = zipStatic;
7878

7979
// Operators
80-
const observableProto = (<KitchenSinkOperators<any>>Observable.prototype);
81-
82-
import {buffer} from './operators/buffer';
83-
observableProto.buffer = buffer;
84-
85-
import {bufferCount} from './operators/bufferCount';
86-
observableProto.bufferCount = bufferCount;
87-
88-
import {bufferTime} from './operators/bufferTime';
89-
observableProto.bufferTime = bufferTime;
90-
91-
import {bufferToggle} from './operators/bufferToggle';
92-
observableProto.bufferToggle = bufferToggle;
93-
94-
import {bufferWhen} from './operators/bufferWhen';
95-
observableProto.bufferWhen = bufferWhen;
96-
97-
import {_catch} from './operators/catch';
98-
observableProto.catch = _catch;
99-
100-
import {combineAll} from './operators/combineAll';
101-
observableProto.combineAll = combineAll;
102-
103-
import {combineLatest} from './operators/combineLatest';
104-
observableProto.combineLatest = combineLatest;
105-
106-
import {concat} from './operators/concat';
107-
observableProto.concat = concat;
108-
109-
import {concatAll} from './operators/concatAll';
110-
observableProto.concatAll = concatAll;
111-
112-
import {concatMap} from './operators/concatMap';
113-
observableProto.concatMap = concatMap;
114-
115-
import {concatMapTo} from './operators/concatMapTo';
116-
observableProto.concatMapTo = concatMapTo;
117-
118-
import {count} from './operators/count';
119-
observableProto.count = count;
120-
121-
import {dematerialize} from './operators/dematerialize';
122-
observableProto.dematerialize = dematerialize;
123-
124-
import {debounce} from './operators/debounce';
125-
observableProto.debounce = debounce;
126-
127-
import {debounceTime} from './operators/debounceTime';
128-
observableProto.debounceTime = debounceTime;
129-
130-
import {defaultIfEmpty} from './operators/defaultIfEmpty';
131-
observableProto.defaultIfEmpty = defaultIfEmpty;
132-
133-
import {delay} from './operators/delay';
134-
observableProto.delay = delay;
135-
136-
import {distinctUntilChanged} from './operators/distinctUntilChanged';
137-
observableProto.distinctUntilChanged = distinctUntilChanged;
138-
139-
import {distinctUntilKeyChanged} from './operators/extended/distinctUntilKeyChanged';
140-
observableProto.distinctUntilKeyChanged = distinctUntilKeyChanged;
141-
142-
import {_do} from './operators/do';
143-
observableProto.do = _do;
144-
145-
import {elementAt} from './operators/extended/elementAt';
146-
observableProto.elementAt = elementAt;
147-
148-
import {expand} from './operators/expand';
149-
observableProto.expand = expand;
150-
151-
import {filter} from './operators/filter';
152-
observableProto.filter = filter;
153-
154-
import {find} from './operators/extended/find';
155-
observableProto.find = find;
156-
157-
import {findIndex} from './operators/extended/findIndex';
158-
observableProto.findIndex = findIndex;
159-
160-
import {_finally} from './operators/finally';
161-
observableProto.finally = _finally;
162-
163-
import {first} from './operators/first';
164-
observableProto.first = first;
165-
166-
import {groupBy} from './operators/groupBy';
167-
observableProto.groupBy = groupBy;
168-
169-
import {ignoreElements} from './operators/ignoreElements';
170-
observableProto.ignoreElements = ignoreElements;
171-
172-
import {isEmpty} from './operators/extended/isEmpty';
173-
observableProto.isEmpty = isEmpty;
174-
175-
import {every} from './operators/every';
176-
observableProto.every = every;
177-
178-
import {last} from './operators/last';
179-
observableProto.last = last;
180-
181-
import {map} from './operators/map';
182-
observableProto.map = map;
183-
184-
import {mapTo} from './operators/mapTo';
185-
observableProto.mapTo = mapTo;
186-
187-
import {materialize} from './operators/materialize';
188-
observableProto.materialize = materialize;
189-
190-
import {max} from './operators/extended/max';
191-
observableProto.max = max;
192-
193-
import {merge} from './operators/merge';
194-
observableProto.merge = merge;
195-
196-
import {mergeAll} from './operators/mergeAll';
197-
observableProto.mergeAll = mergeAll;
198-
199-
import {mergeMap} from './operators/mergeMap';
200-
observableProto.mergeMap = mergeMap;
201-
observableProto.flatMap = mergeMap;
202-
203-
import {mergeMapTo} from './operators/mergeMapTo';
204-
observableProto.mergeMapTo = mergeMapTo;
205-
observableProto.flatMapTo = mergeMapTo;
206-
207-
import {mergeScan} from './operators/extended/mergeScan';
208-
observableProto.mergeScan = mergeScan;
209-
210-
import {min} from './operators/extended/min';
211-
observableProto.min = min;
212-
213-
import {multicast} from './operators/multicast';
214-
observableProto.multicast = multicast;
215-
216-
import {observeOn} from './operators/observeOn';
217-
observableProto.observeOn = observeOn;
218-
219-
import {partition} from './operators/partition';
220-
observableProto.partition = partition;
221-
222-
import {publish} from './operators/publish';
223-
observableProto.publish = publish;
224-
225-
import {publishBehavior} from './operators/publishBehavior';
226-
observableProto.publishBehavior = publishBehavior;
227-
228-
import {publishReplay} from './operators/publishReplay';
229-
observableProto.publishReplay = publishReplay;
230-
231-
import {reduce} from './operators/reduce';
232-
observableProto.reduce = reduce;
233-
234-
import {repeat} from './operators/repeat';
235-
observableProto.repeat = repeat;
236-
237-
import {retry} from './operators/retry';
238-
observableProto.retry = retry;
239-
240-
import {retryWhen} from './operators/retryWhen';
241-
observableProto.retryWhen = retryWhen;
242-
243-
import {sample} from './operators/sample';
244-
observableProto.sample = sample;
245-
246-
import {sampleTime} from './operators/sampleTime';
247-
observableProto.sampleTime = sampleTime;
248-
249-
import {scan} from './operators/scan';
250-
observableProto.scan = scan;
251-
252-
import {share} from './operators/share';
253-
observableProto.share = share;
254-
255-
import {single} from './operators/single';
256-
observableProto.single = single;
257-
258-
import {skip} from './operators/skip';
259-
observableProto.skip = skip;
260-
261-
import {skipUntil} from './operators/skipUntil';
262-
observableProto.skipUntil = skipUntil;
263-
264-
import {skipWhile} from './operators/skipWhile';
265-
observableProto.skipWhile = skipWhile;
266-
267-
import {startWith} from './operators/startWith';
268-
observableProto.startWith = startWith;
269-
270-
import {subscribeOn} from './operators/subscribeOn';
271-
observableProto.subscribeOn = subscribeOn;
272-
273-
import {_switch} from './operators/switch';
274-
observableProto.switch = _switch;
275-
276-
import {switchMap} from './operators/switchMap';
277-
observableProto.switchMap = switchMap;
278-
279-
import {switchMapTo} from './operators/switchMapTo';
280-
observableProto.switchMapTo = switchMapTo;
281-
282-
import {switchFirst} from './operators/switchFirst';
283-
observableProto.switchFirst = switchFirst;
284-
285-
import {switchMapFirst} from './operators/switchMapFirst';
286-
observableProto.switchMapFirst = switchMapFirst;
287-
288-
import {take} from './operators/take';
289-
observableProto.take = take;
290-
291-
import {takeUntil} from './operators/takeUntil';
292-
observableProto.takeUntil = takeUntil;
293-
294-
import {takeWhile} from './operators/takeWhile';
295-
observableProto.takeWhile = takeWhile;
296-
297-
import {throttle} from './operators/throttle';
298-
observableProto.throttle = throttle;
299-
300-
import {throttleTime} from './operators/throttleTime';
301-
observableProto.throttleTime = throttleTime;
302-
303-
import {timeInterval} from './operators/extended/timeInterval';
304-
observableProto.timeInterval = timeInterval;
305-
306-
import {timeout} from './operators/timeout';
307-
observableProto.timeout = timeout;
308-
309-
import {timeoutWith} from './operators/timeoutWith';
310-
observableProto.timeoutWith = timeoutWith;
311-
312-
import {toArray} from './operators/toArray';
313-
observableProto.toArray = toArray;
314-
315-
import {toPromise} from './operators/toPromise';
316-
observableProto.toPromise = toPromise;
317-
318-
import {window} from './operators/window';
319-
observableProto.window = window;
320-
321-
import {windowCount} from './operators/windowCount';
322-
observableProto.windowCount = windowCount;
323-
324-
import {windowTime} from './operators/windowTime';
325-
observableProto.windowTime = windowTime;
326-
327-
import {windowToggle} from './operators/windowToggle';
328-
observableProto.windowToggle = windowToggle;
329-
330-
import {windowWhen} from './operators/windowWhen';
331-
observableProto.windowWhen = windowWhen;
332-
333-
import {withLatestFrom} from './operators/withLatestFrom';
334-
observableProto.withLatestFrom = withLatestFrom;
335-
336-
import {zipProto} from './operators/zip';
337-
observableProto.zip = zipProto;
338-
339-
import {zipAll} from './operators/zipAll';
340-
observableProto.zipAll = zipAll;
80+
import './operators/buffer';
81+
import './operators/bufferCount';
82+
import './operators/bufferTime';
83+
import './operators/bufferToggle';
84+
import './operators/bufferWhen';
85+
import './operators/catch';
86+
import './operators/combineAll';
87+
import './operators/combineLatest';
88+
import './operators/concat';
89+
import './operators/concatAll';
90+
import './operators/concatMap';
91+
import './operators/concatMapTo';
92+
import './operators/count';
93+
import './operators/dematerialize';
94+
import './operators/debounce';
95+
import './operators/debounceTime';
96+
import './operators/defaultIfEmpty';
97+
import './operators/delay';
98+
import './operators/distinctUntilChanged';
99+
import './operators/extended/distinctUntilKeyChanged';
100+
import './operators/do';
101+
import './operators/extended/elementAt';
102+
import './operators/expand';
103+
import './operators/filter';
104+
import './operators/extended/find';
105+
import './operators/extended/findIndex';
106+
import './operators/finally';
107+
import './operators/first';
108+
import './operators/groupBy';
109+
import './operators/ignoreElements';
110+
import './operators/extended/isEmpty';
111+
import './operators/every';
112+
import './operators/last';
113+
import './operators/map';
114+
import './operators/mapTo';
115+
import './operators/materialize';
116+
import './operators/extended/max';
117+
import './operators/merge';
118+
import './operators/mergeAll';
119+
import './operators/mergeMap';
120+
import './operators/mergeMapTo';
121+
import './operators/extended/mergeScan';
122+
import './operators/extended/min';
123+
import './operators/multicast';
124+
import './operators/observeOn';
125+
import './operators/partition';
126+
import './operators/publish';
127+
import './operators/publishBehavior';
128+
import './operators/publishReplay';
129+
import './operators/reduce';
130+
import './operators/repeat';
131+
import './operators/retry';
132+
import './operators/retryWhen';
133+
import './operators/sample';
134+
import './operators/sampleTime';
135+
import './operators/scan';
136+
import './operators/share';
137+
import './operators/single';
138+
import './operators/skip';
139+
import './operators/skipUntil';
140+
import './operators/skipWhile';
141+
import './operators/startWith';
142+
import './operators/subscribeOn';
143+
import './operators/switch';
144+
import './operators/switchMap';
145+
import './operators/switchMapTo';
146+
import './operators/take';
147+
import './operators/takeUntil';
148+
import './operators/takeWhile';
149+
import './operators/throttle';
150+
import './operators/throttleTime';
151+
import './operators/extended/timeInterval';
152+
import './operators/timeout';
153+
import './operators/timeoutWith';
154+
import './operators/toArray';
155+
import './operators/toPromise';
156+
import './operators/window';
157+
import './operators/windowCount';
158+
import './operators/windowTime';
159+
import './operators/windowToggle';
160+
import './operators/windowWhen';
161+
import './operators/withLatestFrom';
162+
import './operators/zip';
163+
import './operators/zipAll';
341164

342165
/* tslint:disable:no-unused-variable */
343166
import {Subject} from './Subject';

0 commit comments

Comments
 (0)