From 36513cf85fbbabf7d0fdb53b230392720654dbc2 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Sat, 14 Dec 2013 17:18:44 +0400 Subject: [PATCH] rx.js.d.ts: updated many of Observable methods added tests for Observable instance methods --- rx.js/rx-tests.ts | 162 +++++++++++++++++++++++++++++++++++++++++++--- rx.js/rx.js.d.ts | 85 +++++++++++++----------- 2 files changed, 202 insertions(+), 45 deletions(-) diff --git a/rx.js/rx-tests.ts b/rx.js/rx-tests.ts index 14388c49f..d95988ce6 100644 --- a/rx.js/rx-tests.ts +++ b/rx.js/rx-tests.ts @@ -108,28 +108,174 @@ bs = Rx.Observable.throwException(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 = 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>; -ss = sss.concatAll(); \ No newline at end of file +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>; + +ns = notifications.dematerialize(); + +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>; +var group: GroupedObservable; +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); diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts index 7107afb1e..84ea91332 100644 --- a/rx.js/rx.js.d.ts +++ b/rx.js/rx.js.d.ts @@ -203,74 +203,85 @@ declare module Rx { } export interface Observable { - _subscribe: (observer: Observer) => IDisposable; - subscribe(observer: Observer): IDisposable; - - finalValue(): Observable; subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable; - toArray(): Observable; + + toArray(): Observable; observeOn(scheduler: IScheduler): Observable; subscribeOn(scheduler: IScheduler): Observable; amb(rightSource: Observable): Observable; - catchException(handler: (exception: any) => Observable): Observable; - catchException(second: Observable): Observable; + catch(handler: (exception: any) => Observable): Observable; + catchException(handler: (exception: any) => Observable): Observable; // alias for catch + catch(second: Observable): Observable; + catchException(second: Observable): Observable; // alias for catch combineLatest(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; combineLatest(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable; combineLatest(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable; combineLatest(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable; - combineLatest(...soucesAndResultSelector: any[]): Observable; + combineLatest(souces: Observable[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable; concat(...sources: Observable[]): Observable; concat(sources: Observable[]): Observable; - concatObservable(): T; concatAll(): T; + concatObservable(): T; // alias for concatAll merge(maxConcurrent: number): Observable; merge(other: Observable): Observable; - mergeObservable(): T; mergeAll(): T; + mergeObservable(): T; // alias for mergeAll onErrorResumeNext(second: Observable): Observable; skipUntil(other: Observable): Observable; - switchLatest(): Observable; + switchLatest(): T; takeUntil(other: Observable): Observable; zip(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; zip(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable; zip(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable; zip(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable; - zip(...soucesAndResultSelector: any[]): Observable; - zip(second: any[], resultSelector: (left: T, right: any) => TResult): Observable; - asIObservable(): Observable; - bufferWithCount(count: number, skip?: number): Observable; + zip(second: Observable[], resultSelector: (left: T, right: Observable) => TResult): Observable; + asObservable(): Observable; + bufferWithCount(count: number, skip?: number): Observable; dematerialize(): Observable; - distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable; - doAction(observer: Observer): Observable; - doAction(onNext: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; - finallyAction(action: () => void): Observable; + distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable; + distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable; + do(observer: Observer): Observable; + doAction(observer: Observer): Observable; // alias for do + do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; + doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; // alias for do + finally(action: () => void): Observable; + finallyAction(action: () => void): Observable; // alias for finally ignoreElements(): Observable; materialize(): Observable>; repeat(repeatCount?: number): Observable; retry(retryCount?: number): Observable; scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable; - scan(accumulator: (acc: TAcc, value: T) => TAcc): Observable; + scan(accumulator: (acc: T, value: T) => T): Observable; skipLast(count: number): Observable; startWith(...values: T[]): Observable; startWith(scheduler: IScheduler, ...values: T[]): Observable; takeLast(count: number, scheduler?: IScheduler): Observable; - takeLastBuffer(count: number): Observable; - windowWithCount(count: number, skip?: number): Observable; + takeLastBuffer(count: number): Observable; + windowWithCount(count: number, skip?: number): Observable>; defaultIfEmpty(defaultValue?: T): Observable; + distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable; distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable; - groupBy(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): GroupedObservable; - groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): GroupedObservable; - select(selector: (value: T, index: number) => T2): Observable; - selectMany(selector: (value: T) => Observable, resultSelector?: (x: any, y: any) => any): Observable; - selectMany(other: Observable): Observable; + groupBy(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable>; + groupBy(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable>; + groupByUntil(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): Observable>; + groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): Observable>; + select(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; + map(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; // alias for select + selectMany(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; + selectMany(selector: (value: T) => Observable): Observable; + selectMany(other: Observable): Observable; + flatMap(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; // alias for selectMany + flatMap(selector: (value: T) => Observable): Observable; // alias for selectMany + flatMap(other: Observable): Observable; // alias for selectMany skip(count: number): Observable; - skipWhile(predicate: (value: T, index?: number) => boolean): Observable; + skipWhile(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; take(count: number, scheduler?: IScheduler): Observable; - takeWhile(predicate: (value: T, index?: number) => boolean): Observable; - where(predicate: (value: T, index?: number) => boolean): Observable; + takeWhile(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + where(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + filter(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; // alias for where } interface ObservableStatic { @@ -286,18 +297,18 @@ declare module Rx { range(start: number, count: number, scheduler?: IScheduler): Observable; repeat(value: T, repeatCount?: number, scheduler?: IScheduler): Observable; return(value: T, scheduler?: IScheduler): Observable; - returnValue(value: T, scheduler?: IScheduler): Observable; + returnValue(value: T, scheduler?: IScheduler): Observable; // alias for return throw(exception: Error, scheduler?: IScheduler): Observable; throw(exception: any, scheduler?: IScheduler): Observable; - throwException(exception: Error, scheduler?: IScheduler): Observable; - throwException(exception: any, scheduler?: IScheduler): Observable; + throwException(exception: Error, scheduler?: IScheduler): Observable; // alias for throw + throwException(exception: any, scheduler?: IScheduler): Observable; // alias for throw using(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable): Observable; amb(...sources: Observable[]): Observable; amb(sources: Observable[]): Observable; catch(sources: Observable[]): Observable; - catchException(sources: Observable[]): Observable; + catchException(sources: Observable[]): Observable; // alias for catch catch(...sources: Observable[]): Observable; - catchException(...sources: Observable[]): Observable; + catchException(...sources: Observable[]): Observable; // alias for catch concat(...sources: Observable[]): Observable; concat(sources: Observable[]): Observable; merge(...sources: Observable[]): Observable; @@ -306,13 +317,13 @@ declare module Rx { merge(scheduler: IScheduler, sources: Observable[]): Observable; onErrorResumeNext(...sources: Observable[]): Observable; onErrorResumeNext(sources: Observable[]): Observable; - zip(sources: Observable[], resultSelector: (...items: T[]) => TResult): Observable; + zip(first: Observable, sources: Observable[], resultSelector: (item1: T1, right: Observable) => TResult): Observable; zip(source1: Observable, source2: Observable, resultSelector: (item1: T1, item2: T2) => TResult): Observable; zip(source1: Observable, source2: Observable, source3: Observable, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable; zip(source1: Observable, source2: Observable, source3: Observable, source4: Observable, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable; zip(source1: Observable, source2: Observable, source3: Observable, source4: Observable, source5: Observable, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable; zipArray(...sources: Observable[]): Observable; - zipArray(sources: Observable[]): Observable; + //zipArray(sources: Observable[]): Observable; } export var Observable: ObservableStatic;