From a800d58e7d50489a20597791931bdfe4640513d1 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Thu, 2 Oct 2014 11:38:26 -0700 Subject: [PATCH 01/10] Fixed selectSwitch/flatMapLatest definition (fixes Reactive-Extensions/RxJS#304). --- rx-lite.d.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rx-lite.d.ts b/rx-lite.d.ts index 4b5acb81d..a47233177 100644 --- a/rx-lite.d.ts +++ b/rx-lite.d.ts @@ -316,7 +316,7 @@ declare module Rx { * @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences * and that at any point in time produces the elements of the most recent inner observable sequence that has been received. */ - selectSwitch(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; + selectSwitch(selector: (value: T, index: number, source: Observable) => Observable, thisArg?: any): Observable; /** * Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then * transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence. @@ -325,7 +325,7 @@ declare module Rx { * @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences * and that at any point in time produces the elements of the most recent inner observable sequence that has been received. */ - flatMapLatest(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; // alias for selectSwitch + flatMapLatest(selector: (value: T, index: number, source: Observable) => Observable, thisArg?: any): Observable; // alias for selectSwitch /** * Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then * transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence. From 6dd4190932be89037c3f6676f5e09fb5f2742ae5 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Mon, 6 Oct 2014 13:20:17 -0700 Subject: [PATCH 02/10] Renamed `then` to `thenDo` (due RxJS 2.3.12 changes). --- rx.joinpatterns.d.ts | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/rx.joinpatterns.d.ts b/rx.joinpatterns.d.ts index 929c66a6f..ce251a2db 100644 --- a/rx.joinpatterns.d.ts +++ b/rx.joinpatterns.d.ts @@ -9,45 +9,45 @@ declare module Rx { interface Pattern1 { and(other: Observable): Pattern2; - then(selector: (item1: T1) => TR): Plan; + thenDo(selector: (item1: T1) => TR): Plan; } interface Pattern2 { and(other: Observable): Pattern3; - then(selector: (item1: T1, item2: T2) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2) => TR): Plan; } interface Pattern3 { and(other: Observable): Pattern4; - then(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan; } interface Pattern4 { and(other: Observable): Pattern5; - then(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan; } interface Pattern5 { and(other: Observable): Pattern6; - then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan; } interface Pattern6 { and(other: Observable): Pattern7; - then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan; } interface Pattern7 { and(other: Observable): Pattern8; - then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan; } interface Pattern8 { and(other: Observable): Pattern9; - then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan; } interface Pattern9 { - then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan; + thenDo(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan; } interface Plan { } interface Observable { and(other: Observable): Pattern2; - then(selector: (item1: T) => TR): Plan; + thenDo(selector: (item1: T) => TR): Plan; } interface ObservableStatic { From 0e70c031b052fbf944a1997331c5c82b81744608 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Tue, 7 Oct 2014 09:51:45 -0700 Subject: [PATCH 03/10] Aligned backpressure defintion to v2.3. --- rx.backpressure-lite.d.ts | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/rx.backpressure-lite.d.ts b/rx.backpressure-lite.d.ts index d1c244195..9d4027be6 100644 --- a/rx.backpressure-lite.d.ts +++ b/rx.backpressure-lite.d.ts @@ -15,8 +15,7 @@ declare module Rx { * @param pauser The observable sequence used to pause the underlying sequence. * @returns The observable sequence which is paused based upon the pauser. */ - pausable(pauser: Observable): Observable; - pausable(pauser?: ISubject): PausableObservable; + pausable(pauser?: Observable): PausableObservable; /** * Pauses the underlying observable sequence based upon the observable sequence which yields true/false, @@ -27,7 +26,7 @@ declare module Rx { * @param pauser The observable sequence used to pause the underlying sequence. * @returns The observable sequence which is paused based upon the pauser. */ - pausableBuffered(pauser?: ISubject): PausableObservable; + pausableBuffered(pauser?: Observable): PausableObservable; /** * Attaches a controller to the observable sequence with the ability to queue. From 0f296af96299baee7d428401dae1fbbbf6ec7d40 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Tue, 7 Oct 2014 09:52:47 -0700 Subject: [PATCH 04/10] Removed clear, contains from CompositeDisposable. --- rx-lite.d.ts | 2 -- rx.backpressure.d.ts | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/rx-lite.d.ts b/rx-lite.d.ts index a47233177..b7bd9fb71 100644 --- a/rx-lite.d.ts +++ b/rx-lite.d.ts @@ -76,8 +76,6 @@ declare module Rx { dispose(): void; add(item: IDisposable): void; remove(item: IDisposable): boolean; - clear(): void; - contains(item: IDisposable): boolean; toArray(): IDisposable[]; } diff --git a/rx.backpressure.d.ts b/rx.backpressure.d.ts index 9c5e8abd5..18ab4ddd9 100644 --- a/rx.backpressure.d.ts +++ b/rx.backpressure.d.ts @@ -1,4 +1,4 @@ -// Type definitions for RxJS-BackPressure v2.2.28 +// Type definitions for RxJS-BackPressure v2.3.12 // Project: http://rx.codeplex.com/ // Definitions by: Igor Oleinikov // Definitions: https://github.com/borisyankov/DefinitelyTyped From 7e358f4c507725a819ef2fee82f9fb398f7ffb97 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Tue, 7 Oct 2014 10:31:55 -0700 Subject: [PATCH 05/10] Made SerialDisposable be an alias of SingleAssigmentDisposable. --- rx-lite.d.ts | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/rx-lite.d.ts b/rx-lite.d.ts index b7bd9fb71..68273c2fb 100644 --- a/rx-lite.d.ts +++ b/rx-lite.d.ts @@ -100,15 +100,9 @@ declare module Rx { setDisposable(value: IDisposable): void ; } - // Multiple assignment disposable - export class SerialDisposable implements IDisposable { + // SerialDisposable it's an alias of SingleAssignmentDisposable + export class SerialDisposable extends SingleAssignmentDisposable { constructor(); - - isDisposed: boolean; - - dispose(): void; - getDisposable(): IDisposable; - setDisposable(value: IDisposable): void; } export class RefCountDisposable implements IDisposable { From e56c6d9aaa0daf4164216daa7dd413fe1ef89b33 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Tue, 7 Oct 2014 11:19:10 -0700 Subject: [PATCH 06/10] Added helpers.isFunction; added thisArg to Observer.fromNotifier; added Observable.subscribeOn*. --- rx-lite.d.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/rx-lite.d.ts b/rx-lite.d.ts index 68273c2fb..78b0c5a8c 100644 --- a/rx-lite.d.ts +++ b/rx-lite.d.ts @@ -60,6 +60,7 @@ declare module Rx { function isPromise(p: any): boolean; function asArray(...args: T[]): T[]; function not(value: any): boolean; + function isFunction(value: any): boolean; } export interface IDisposable { @@ -180,7 +181,7 @@ declare module Rx { interface ObserverStatic { create(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer; - fromNotifier(handler: (notification: Notification) => void): Observer; + fromNotifier(handler: (notification: Notification, thisArg?: any) => void): Observer; } export var Observer: ObserverStatic; @@ -188,6 +189,10 @@ declare module Rx { export interface IObservable { subscribe(observer: Observer): IDisposable; subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable; + + subscribeOnNext(onNext: (value: T) => void, thisArg?: any): IDisposable; + subscribeOnError(onError: (exception: any) => void, thisArg?: any): IDisposable; + subscribeOnCompleted(onCompleted: () => void, thisArg?: any): IDisposable; } export interface Observable extends IObservable { From 8d80d832dcb1fee7806c9201431e4fe6ee612a23 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Tue, 7 Oct 2014 17:44:17 -0700 Subject: [PATCH 07/10] Added tap, doOn*, tapOn*, throwError, catchError. --- rx-lite.d.ts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/rx-lite.d.ts b/rx-lite.d.ts index 78b0c5a8c..63ce074d2 100644 --- a/rx-lite.d.ts +++ b/rx-lite.d.ts @@ -268,8 +268,18 @@ declare module Rx { distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable; do(observer: Observer): Observable; doAction(observer: Observer): Observable; // alias for do + tap(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 + tap(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; // alias for do + + doOnNext(onNext: (value: T) => void, thisArg?: any): Observable; + doOnError(onError: (exception: any) => void, thisArg?: any): Observable; + doOnCompleted(onCompleted: () => void, thisArg?: any): Observable; + tapOnNext(onNext: (value: T) => void, thisArg?: any): Observable; + tapOnError(onError: (exception: any) => void, thisArg?: any): Observable; + tapOnCompleted(onCompleted: () => void, thisArg?: any): Observable; + finally(action: () => void): Observable; finallyAction(action: () => void): Observable; // alias for finally ignoreElements(): Observable; @@ -498,15 +508,21 @@ declare module Rx { throw(exception: any, scheduler?: IScheduler): Observable; throwException(exception: Error, scheduler?: IScheduler): Observable; // alias for throw throwException(exception: any, scheduler?: IScheduler): Observable; // alias for throw + throwError(error: Error, scheduler?: IScheduler): Observable; // alias for throw + throwError(error: any, scheduler?: IScheduler): Observable; // alias for throw catch(sources: Observable[]): Observable; catch(sources: IPromise[]): Observable; catchException(sources: Observable[]): Observable; // alias for catch catchException(sources: IPromise[]): Observable; // alias for catch + catchError(sources: Observable[]): Observable; // alias for catch + catchError(sources: IPromise[]): Observable; // alias for catch catch(...sources: Observable[]): Observable; catch(...sources: IPromise[]): Observable; catchException(...sources: Observable[]): Observable; // alias for catch catchException(...sources: IPromise[]): Observable; // alias for catch + catchError(...sources: Observable[]): Observable; // alias for catch + catchError(...sources: IPromise[]): Observable; // alias for catch combineLatest(first: Observable, second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; combineLatest(first: IPromise, second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; From 4838b8ac0d3cb16c521dffc7c9440158fa374fbd Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Wed, 8 Oct 2014 17:21:17 -0700 Subject: [PATCH 08/10] Fixed `takeLast`, added `pluck`, `config.useNativeEvents`. --- rx-lite.d.ts | 3 ++- rx.async-lite.d.ts | 7 +++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/rx-lite.d.ts b/rx-lite.d.ts index 63ce074d2..fc7583353 100644 --- a/rx-lite.d.ts +++ b/rx-lite.d.ts @@ -291,11 +291,12 @@ declare module Rx { skipLast(count: number): Observable; startWith(...values: T[]): Observable; startWith(scheduler: IScheduler, ...values: T[]): Observable; - takeLast(count: number, scheduler?: IScheduler): Observable; + takeLast(count: number): Observable; takeLastBuffer(count: number): 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 + pluck(prop: string): Observable; selectMany(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; selectMany(selector: (value: T) => IPromise, resultSelector: (item: T, other: TOther) => TResult): Observable; selectMany(selector: (value: T) => Observable): Observable; diff --git a/rx.async-lite.d.ts b/rx.async-lite.d.ts index 77dc23b57..f86dc326f 100644 --- a/rx.async-lite.d.ts +++ b/rx.async-lite.d.ts @@ -6,6 +6,13 @@ /// declare module Rx { + export module config { + /** + * Configuration option to determine whether to use native events only + */ + export var useNativeEvents: boolean; + } + interface ObservableStatic { /** * Invokes the asynchronous function, surfacing the result through an observable sequence. From c24dbf968045564ffd2681c145377e83167a4554 Mon Sep 17 00:00:00 2001 From: Igor Oleinikov Date: Wed, 8 Oct 2014 17:26:25 -0700 Subject: [PATCH 09/10] Moved removed `rx.time` operators from rx.time-lite to rx.time. --- rx.time-lite.d.ts | 27 +-------------------------- rx.time.d.ts | 26 ++++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 26 deletions(-) diff --git a/rx.time-lite.d.ts b/rx.time-lite.d.ts index 7a7d8f46f..3642377f8 100644 --- a/rx.time-lite.d.ts +++ b/rx.time-lite.d.ts @@ -17,6 +17,7 @@ declare module Rx { } export interface Observable { + delay(dueTime: Date, scheduler?: IScheduler): Observable; delay(dueTime: number, scheduler?: IScheduler): Observable; throttle(dueTime: number, scheduler?: IScheduler): Observable; timeInterval(scheduler?: IScheduler): Observable>; @@ -25,25 +26,6 @@ declare module Rx { sample(sampler: Observable, scheduler?: IScheduler): Observable; timeout(dueTime: Date, other?: Observable, scheduler?: IScheduler): Observable; timeout(dueTime: number, other?: Observable, scheduler?: IScheduler): Observable; - - delaySubscription(dueTime: number, scheduler?: IScheduler): Observable; - delayWithSelector(delayDurationSelector: (item: T) => number): Observable; - delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable; - - timeoutWithSelector(firstTimeout: Observable, timeoutdurationSelector?: (item: T) => Observable, other?: Observable): Observable; - throttleWithSelector(throttleDurationSelector: (item: T) => Observable): Observable; - - skipLastWithTime(duration: number, scheduler?: IScheduler): Observable; - takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable; - - takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable; - takeWithTime(duration: number, scheduler?: IScheduler): Observable; - skipWithTime(duration: number, scheduler?: IScheduler): Observable; - - skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable; - skipUntilWithTime(duration: number, scheduler?: IScheduler): Observable; - takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable; - takeUntilWithTime(duration: number, scheduler?: IScheduler): Observable; } interface ObservableStatic { @@ -51,12 +33,5 @@ declare module Rx { interval(dutTime: number, period: number, scheduler?: IScheduler): Observable; timer(dueTime: number, period: number, scheduler?: IScheduler): Observable; timer(dueTime: number, scheduler?: IScheduler): Observable; - generateWithRelativeTime( - initialState: TState, - condition: (state: TState) => boolean, - iterate: (state: TState) => TState, - resultSelector: (state: TState) => TResult, - timeSelector: (state: TState) => number, - scheduler?: IScheduler): Observable; } } diff --git a/rx.time.d.ts b/rx.time.d.ts index 2cdb1d56a..3da66b95c 100644 --- a/rx.time.d.ts +++ b/rx.time.d.ts @@ -8,6 +8,25 @@ declare module Rx { export interface Observable { + delaySubscription(dueTime: number, scheduler?: IScheduler): Observable; + delayWithSelector(delayDurationSelector: (item: T) => number): Observable; + delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable; + + timeoutWithSelector(firstTimeout: Observable, timeoutdurationSelector?: (item: T) => Observable, other?: Observable): Observable; + throttleWithSelector(throttleDurationSelector: (item: T) => Observable): Observable; + + skipLastWithTime(duration: number, scheduler?: IScheduler): Observable; + takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable; + + takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable; + takeWithTime(duration: number, scheduler?: IScheduler): Observable; + skipWithTime(duration: number, scheduler?: IScheduler): Observable; + + skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable; + skipUntilWithTime(duration: number, scheduler?: IScheduler): Observable; + takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable; + takeUntilWithTime(duration: number, scheduler?: IScheduler): Observable; + windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable>; windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable>; windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable>; @@ -20,6 +39,13 @@ declare module Rx { timer(dueTime: Date, period: number, scheduler?: IScheduler): Observable; timer(dueTime: Date, scheduler?: IScheduler): Observable; + generateWithRelativeTime( + initialState: TState, + condition: (state: TState) => boolean, + iterate: (state: TState) => TState, + resultSelector: (state: TState) => TResult, + timeSelector: (state: TState) => number, + scheduler?: IScheduler): Observable; generateWithAbsoluteTime( initialState: TState, condition: (state: TState) => boolean, From e2d0963430c542bfbda1a21fa7bdcab9a160b565 Mon Sep 17 00:00:00 2001 From: Bernd Paradies Date: Mon, 27 Oct 2014 11:50:09 -0700 Subject: [PATCH 10/10] Fix for issue 1 - SchedulerStatic --- rx.d.ts | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/rx.d.ts b/rx.d.ts index 1f26a94a9..73c97bbc9 100644 --- a/rx.d.ts +++ b/rx.d.ts @@ -11,19 +11,7 @@ declare module Rx { catchException(handler: (exception: any) => boolean): IScheduler; } - export class Scheduler implements IScheduler { - constructor( - now: () => number, - schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable, - scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable, - scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable); - - static normalize(timeSpan: number): number; - - static immediate: IScheduler; - static currentThread: ICurrentThreadScheduler; - static timeout: IScheduler; - + export interface Scheduler extends IScheduler { now(): number; catch(handler: (exception: any) => boolean): IScheduler; catchException(handler: (exception: any) => boolean): IScheduler; @@ -46,7 +34,22 @@ declare module Rx { schedulePeriodicWithState(state: TState, period: number, action: (state: TState) => TState): IDisposable; } - // Observer + interface SchedulerStatic { + new (now: () => number, + schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable, + scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable, + scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable): Scheduler; + + normalize(timeSpan: number): number; + + immediate: IScheduler; + currentThread: ICurrentThreadScheduler; + timeout: IScheduler; + } + + export var Scheduler: SchedulerStatic; + + // Observer export interface Observer { checked(): Observer; }