mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-09-08 16:40:30 +08:00
rx.js.d.ts: updated many of Observable methods
added tests for Observable instance methods
This commit is contained in:
Igor Oleinikov
+154
-8
@@ -108,28 +108,174 @@ bs = Rx.Observable.throwException<boolean>(new Error("error"), Rx.Scheduler.time
|
||||
bs = Rx.Observable.using(() => d, d => Rx.Observable.return(true));
|
||||
|
||||
ss = Rx.Observable.amb(ss, ss);
|
||||
//ss = Rx.Observable.amb([ss, ss]);
|
||||
//ss = Rx.Observable.amb([ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
|
||||
ss = Rx.Observable.catch(ss, ss, ss);
|
||||
ss = Rx.Observable.catchException(ss, ss, ss);
|
||||
//ss = Rx.Observable.catch([ss, ss, ss]);
|
||||
//ss = Rx.Observable.catchException([ss, ss, ss]);
|
||||
//ss = Rx.Observable.catch([ss, ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
//ss = Rx.Observable.catchException([ss, ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
|
||||
ss = Rx.Observable.concat(ss, ss, ss);
|
||||
//ss = Rx.Observable.concat([ss, ss, ss]);
|
||||
//ss = Rx.Observable.concat([ss, ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
|
||||
ss = Rx.Observable.merge(ss, ss, ss);
|
||||
//ss = Rx.Observable.merge([ss, ss, ss]);
|
||||
//ss = Rx.Observable.merge([ss, ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
ss = Rx.Observable.merge(s, ss, ss, ss);
|
||||
//ss = Rx.Observable.merge(s, [ss, ss, ss]);
|
||||
//ss = Rx.Observable.merge(s, [ss, ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
|
||||
ss = Rx.Observable.onErrorResumeNext(ss, ss, ss);
|
||||
//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]);
|
||||
//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]); // TypeScript bug https://typescript.codeplex.com/workitem/2011
|
||||
|
||||
ns = Rx.Observable.zip(ss, [ss, ss, ss], (s, ss2) => { ss = ss2; return s.charCodeAt(0); });
|
||||
ns = Rx.Observable.zip(ss, bs, (s, b) => s.length + (b ? 1 : 0));
|
||||
ns = Rx.Observable.zip(ss, bs, ns, (s, b, n) => s.length + (b ? 1 : 0) + n);
|
||||
ns = Rx.Observable.zip(ss, bs, ns, ns, (s, b, n, n2) => s.length + (b ? 1 : 0) + n + n2);
|
||||
ns = Rx.Observable.zip(ss, bs, ns, ns, ss, (s, b, n, n2, s2) => s.length + (b ? 1 : 0) + n + n2 + s2.charCodeAt(0));
|
||||
|
||||
var sas: Rx.Observable<string[]> = Rx.Observable.zipArray(ss, ss);
|
||||
|
||||
|
||||
// Observable instance methods
|
||||
|
||||
d = ns.subscribe(o);
|
||||
d = ns.subscribe(n => n + 1, err => { }, () => { });
|
||||
d = ns.subscribe(n => n + 1, err => { });
|
||||
d = ns.subscribe();
|
||||
|
||||
sas = ss.toArray();
|
||||
|
||||
ss.observeOn(s);
|
||||
ns.subscribeOn(s);
|
||||
|
||||
ss = ss.amb(ss);
|
||||
|
||||
ss = ss.catch(err => ss);
|
||||
ss = ss.catchException(err => ss);
|
||||
ss = ss.catch(ss);
|
||||
ss = ss.catchException(ss);
|
||||
|
||||
ns = ss.combineLatest([ns, ns, ns], (s, ...ns) => s.charCodeAt(0) + ns[0]);
|
||||
ns = ss.combineLatest(ns, (s, n) => s.charCodeAt(0) + n);
|
||||
ns = ss.combineLatest(ns, ns, (s, n, n2) => s.charCodeAt(0) + n + n2);
|
||||
ns = ss.combineLatest(ns, ns, bs, (s, n, n2, b) => s.charCodeAt(0) + n + n2 + (b ? 1 : 0));
|
||||
ns = ss.combineLatest(ns, ns, bs, ss, (s, n, n2, b, s2) => s.charCodeAt(0) + n + n2 + (b ? 1 : 0) + s2.charCodeAt(0));
|
||||
|
||||
ss = ss.concat(ss, ss);
|
||||
ss = ss.concat([ss, ss]);
|
||||
|
||||
var sss: Rx.Observable<Rx.Observable<string>>;
|
||||
ss = sss.concatAll();
|
||||
ss = sss.concatAll();
|
||||
ss = sss.concatObservable();
|
||||
|
||||
ss = ss.merge(2);
|
||||
ss = ss.merge(ss);
|
||||
|
||||
ss = sss.mergeAll();
|
||||
ss = sss.mergeObservable();
|
||||
|
||||
ss = ss.onErrorResumeNext(ss);
|
||||
|
||||
ss = ss.skipUntil(ns);
|
||||
|
||||
ss = ss.takeUntil(ns);
|
||||
|
||||
ss = sss.switchLatest();
|
||||
|
||||
ns = ss.zip([ns, ns], (s, ns2) => { ns = ns2; return s.charCodeAt(0); });
|
||||
|
||||
ns = ss.zip(ns, (s, n) => s.charCodeAt(0) + n);
|
||||
ns = ss.zip(ns, bs, (s, n, b) => s.charCodeAt(0) + n + (b?1:0));
|
||||
ns = ss.zip(ns, bs, ss, (s, n, b, s2) => s.charCodeAt(0) + n + (b?1:0) + s2.charCodeAt(0));
|
||||
ns = ss.zip(ns, bs, ss, ns, (s, n, b, s2, n2) => s.charCodeAt(0) + n + (b?1:0) + s2.charCodeAt(0) + n2);
|
||||
|
||||
ss = ss.asObservable();
|
||||
|
||||
sas = ss.bufferWithCount(2);
|
||||
sas = ss.bufferWithCount(2, 1);
|
||||
|
||||
var notifications: Rx.Observable<Rx.Notification<number>>;
|
||||
|
||||
ns = notifications.dematerialize<number>();
|
||||
|
||||
ns = ns.distinctUntilChanged();
|
||||
ns = ns.distinctUntilChanged(n => (n + 1).toString());
|
||||
ns = ns.distinctUntilChanged(n => (n + 1).toString(), (s1, s2) => s1.charCodeAt(0) === s2.charCodeAt(0));
|
||||
ns = ns.distinctUntilChanged(undefined, (n1, n2) => (n1 + 1) === (n2 + 1));
|
||||
|
||||
ns = ns.do(o);
|
||||
ns = ns.doAction(o);
|
||||
ns = ns.do(n => n + 1, err => { }, () => { });
|
||||
ns = ns.doAction(n => n + 1, err => { }, () => { });
|
||||
ns = ns.do(n => n + 1, err => { });
|
||||
ns = ns.doAction(n => n + 1, err => { });
|
||||
ns = ns.do();
|
||||
ns = ns.doAction();
|
||||
|
||||
ns = ns.finally(() => { });
|
||||
ns = ns.finallyAction(() => { });
|
||||
|
||||
ss = ss.ignoreElements();
|
||||
|
||||
notifications = ns.materialize();
|
||||
|
||||
ss = ss.repeat();
|
||||
ss = ss.repeat(10);
|
||||
|
||||
ss = ss.retry();
|
||||
ss = ss.retry(10);
|
||||
|
||||
ns = ss.scan(0, (sum, s) => sum + s.charCodeAt(0));
|
||||
ns = ns.scan((sum, n) => sum + n);
|
||||
|
||||
ns = ns.skipLast(10);
|
||||
|
||||
ns = ns.startWith(10, 20);
|
||||
ns = ns.startWith(s, 10, 20);
|
||||
|
||||
ns = ns.takeLast(2);
|
||||
ns = ns.takeLast(2, s);
|
||||
|
||||
sas = ss.takeLastBuffer(5);
|
||||
|
||||
sss = ss.windowWithCount(2);
|
||||
sss = ss.windowWithCount(2, 3);
|
||||
|
||||
ns = ns.defaultIfEmpty();
|
||||
ns = ns.defaultIfEmpty(0);
|
||||
|
||||
ns = ns.distinct(n => (n + 1), n => (n + 1).toString());
|
||||
ns = ns.distinct(undefined, n => (n + 1).toString());
|
||||
ns = ns.distinct(n => (n + 1).toString());
|
||||
ns = ns.distinct();
|
||||
|
||||
var gnss: Observable<GroupedObservable<number, string>>;
|
||||
var group: GroupedObservable<number, string>;
|
||||
ss = group;
|
||||
n = group.key;
|
||||
|
||||
gnss = ss.groupBy(s => s.charCodeAt(0));
|
||||
gnss = ss.groupBy(s => s.charCodeAt(0), s => s + "!");
|
||||
gnss = ss.groupBy(s => s.charCodeAt(0), s => s + "!", k => (k + 1).toString());
|
||||
gnss = ss.groupBy(s => s.charCodeAt(0), undefined, k => (k + 1).toString());
|
||||
|
||||
gnss = ss.groupByUntil(s => s.charCodeAt(0), s => s + "!", g => ns, k => (k + 1).toString());
|
||||
gnss = ss.groupByUntil(s => s.charCodeAt(0), undefined, g => ns, k => (k + 1).toString());
|
||||
|
||||
ns = ss.select(s => s.charCodeAt(0), ns);
|
||||
ns = ss.map(s => s.charCodeAt(0), ns);
|
||||
ns = ss.select(s => s.charCodeAt(0));
|
||||
ns = ss.map(s => s.charCodeAt(0));
|
||||
ns = ss.select((s, index) => s.charCodeAt(0) + index);
|
||||
ns = ss.map((s, index) => s.charCodeAt(0) + index);
|
||||
ns = ss.select((s, index) => s.charCodeAt(0) + index, ns);
|
||||
ns = ss.map((s, index) => s.charCodeAt(0) + index, ns);
|
||||
ns = ss.select((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; });
|
||||
ns = ss.map((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; });
|
||||
ns = ss.select((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; }, ns);
|
||||
ns = ss.map((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; }, ns);
|
||||
|
||||
ss = ss.selectMany(s => ns, (s, n) => s + n.toString());
|
||||
ns = ss.selectMany(s => ns);
|
||||
ns = ss.selectMany(ns);
|
||||
|
||||
ns = ns.skip(10);
|
||||
|
||||
Vendored
+48
-37
@@ -203,74 +203,85 @@ declare module Rx {
|
||||
}
|
||||
|
||||
export interface Observable<T> {
|
||||
_subscribe: (observer: Observer<T>) => IDisposable;
|
||||
|
||||
subscribe(observer: Observer<T>): IDisposable;
|
||||
|
||||
finalValue(): Observable<T>;
|
||||
subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
|
||||
toArray(): Observable<T>;
|
||||
|
||||
toArray(): Observable<T[]>;
|
||||
|
||||
observeOn(scheduler: IScheduler): Observable<T>;
|
||||
subscribeOn(scheduler: IScheduler): Observable<T>;
|
||||
|
||||
amb(rightSource: Observable<T>): Observable<T>;
|
||||
catchException(handler: (exception: any) => Observable<T>): Observable<T>;
|
||||
catchException(second: Observable<T>): Observable<T>;
|
||||
catch(handler: (exception: any) => Observable<T>): Observable<T>;
|
||||
catchException(handler: (exception: any) => Observable<T>): Observable<T>; // alias for catch
|
||||
catch(second: Observable<T>): Observable<T>;
|
||||
catchException(second: Observable<T>): Observable<T>; // alias for catch
|
||||
combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
||||
combineLatest<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
||||
combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
||||
combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
||||
combineLatest<TResult>(...soucesAndResultSelector: any[]): Observable<TResult>;
|
||||
combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
|
||||
concat(...sources: Observable<T>[]): Observable<T>;
|
||||
concat(sources: Observable<T>[]): Observable<T>;
|
||||
concatObservable(): T;
|
||||
concatAll(): T;
|
||||
concatObservable(): T; // alias for concatAll
|
||||
merge(maxConcurrent: number): Observable<T>;
|
||||
merge(other: Observable<T>): Observable<T>;
|
||||
mergeObservable(): T;
|
||||
mergeAll(): T;
|
||||
mergeObservable(): T; // alias for mergeAll
|
||||
onErrorResumeNext(second: Observable<T>): Observable<T>;
|
||||
skipUntil<T2>(other: Observable<T2>): Observable<T>;
|
||||
switchLatest(): Observable<T>;
|
||||
switchLatest(): T;
|
||||
takeUntil<T2>(other: Observable<T2>): Observable<T>;
|
||||
zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
||||
zip<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
||||
zip<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
||||
zip<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
||||
zip<TResult>(...soucesAndResultSelector: any[]): Observable<TResult>;
|
||||
zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): Observable<TResult>;
|
||||
asIObservable(): Observable<any>;
|
||||
bufferWithCount(count: number, skip?: number): Observable<T>;
|
||||
zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, right: Observable<TOther>) => TResult): Observable<TResult>;
|
||||
asObservable(): Observable<T>;
|
||||
bufferWithCount(count: number, skip?: number): Observable<T[]>;
|
||||
dematerialize<TOrigin>(): Observable<TOrigin>;
|
||||
distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<any>;
|
||||
doAction(observer: Observer<T>): Observable<T>;
|
||||
doAction(onNext: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
|
||||
finallyAction(action: () => void): Observable<T>;
|
||||
distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
|
||||
distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
|
||||
do(observer: Observer<T>): Observable<T>;
|
||||
doAction(observer: Observer<T>): Observable<T>; // alias for do
|
||||
do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
|
||||
doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>; // alias for do
|
||||
finally(action: () => void): Observable<T>;
|
||||
finallyAction(action: () => void): Observable<T>; // alias for finally
|
||||
ignoreElements(): Observable<T>;
|
||||
materialize(): Observable<Notification<T>>;
|
||||
repeat(repeatCount?: number): Observable<T>;
|
||||
retry(retryCount?: number): Observable<T>;
|
||||
scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
|
||||
scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
|
||||
scan(accumulator: (acc: T, value: T) => T): Observable<T>;
|
||||
skipLast(count: number): Observable<T>;
|
||||
startWith(...values: T[]): Observable<T>;
|
||||
startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
|
||||
takeLast(count: number, scheduler?: IScheduler): Observable<T>;
|
||||
takeLastBuffer(count: number): Observable<T>;
|
||||
windowWithCount(count: number, skip?: number): Observable<T>;
|
||||
takeLastBuffer(count: number): Observable<T[]>;
|
||||
windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
|
||||
defaultIfEmpty(defaultValue?: T): Observable<T>;
|
||||
distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
|
||||
distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
|
||||
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): GroupedObservable<TKey, TElement>;
|
||||
groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<number>, keySerializer?: (key: TKey) => string): GroupedObservable<TKey, TElement>;
|
||||
select<T2>(selector: (value: T, index: number) => T2): Observable<T2>;
|
||||
selectMany<T2>(selector: (value: T) => Observable<T2>, resultSelector?: (x: any, y: any) => any): Observable<T2>;
|
||||
selectMany<T2>(other: Observable<T2>): Observable<T2>;
|
||||
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
|
||||
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
|
||||
groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
|
||||
groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
|
||||
select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
|
||||
map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>; // alias for select
|
||||
selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
|
||||
selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
|
||||
selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
|
||||
flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>; // alias for selectMany
|
||||
flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>; // alias for selectMany
|
||||
flatMap<TResult>(other: Observable<TResult>): Observable<TResult>; // alias for selectMany
|
||||
skip(count: number): Observable<T>;
|
||||
skipWhile(predicate: (value: T, index?: number) => boolean): Observable<T>;
|
||||
skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
|
||||
take(count: number, scheduler?: IScheduler): Observable<T>;
|
||||
takeWhile(predicate: (value: T, index?: number) => boolean): Observable<T>;
|
||||
where(predicate: (value: T, index?: number) => boolean): Observable<T>;
|
||||
takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
|
||||
where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
|
||||
filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
|
||||
}
|
||||
|
||||
interface ObservableStatic {
|
||||
@@ -286,18 +297,18 @@ declare module Rx {
|
||||
range(start: number, count: number, scheduler?: IScheduler): Observable<number>;
|
||||
repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): Observable<T>;
|
||||
return<T>(value: T, scheduler?: IScheduler): Observable<T>;
|
||||
returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;
|
||||
returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>; // alias for return
|
||||
throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
|
||||
throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
|
||||
throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
|
||||
throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;
|
||||
throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
|
||||
throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>; // alias for throw
|
||||
using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
|
||||
amb<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
amb<T>(sources: Observable<T>[]): Observable<T>;
|
||||
catch<T>(sources: Observable<T>[]): Observable<T>;
|
||||
catchException<T>(sources: Observable<T>[]): Observable<T>;
|
||||
catchException<T>(sources: Observable<T>[]): Observable<T>; // alias for catch
|
||||
catch<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
catchException<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
catchException<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
|
||||
concat<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
concat<T>(sources: Observable<T>[]): Observable<T>;
|
||||
merge<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
@@ -306,13 +317,13 @@ declare module Rx {
|
||||
merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
|
||||
onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
|
||||
zip<T, TResult>(sources: Observable<T>[], resultSelector: (...items: T[]) => TResult): Observable<TResult>;
|
||||
zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<T2>) => TResult): Observable<TResult>;
|
||||
zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
|
||||
zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
|
||||
zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
|
||||
zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, source5: Observable<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
|
||||
zipArray<T>(...sources: Observable<T>[]): Observable<T[]>;
|
||||
zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
|
||||
//zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
|
||||
}
|
||||
|
||||
export var Observable: ObservableStatic;
|
||||
|
||||
Reference in New Issue
Block a user