wassname/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/wassname/DefinitelyTyped.git synced 2026-09-09 11:13:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/Igorbek/rx.d.ts into RxJS

Browse Source
This commit is contained in:
Igor Oleinikov
2014-11-22 08:44:55 -08:00
parent c3589139f6 8915e117c3
commit b51c8625bc
8 changed files with 92 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rx/rx-lite.d.ts
Vendored
+28 -14
View File
@@ -60,6 +60,7 @@ declare module Rx {
function isPromise(p: any): boolean;
function asArray<T>(...args: T[]): T[];
function not(value: any): boolean;
function isFunction(value: any): boolean;
}
export interface IDisposable {
@@ -76,8 +77,6 @@ declare module Rx {
dispose(): void;
add(item: IDisposable): void;
remove(item: IDisposable): boolean;
clear(): void;
contains(item: IDisposable): boolean;
toArray(): IDisposable[];
}
@@ -102,15 +101,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 {
@@ -188,7 +181,7 @@ declare module Rx {
interface ObserverStatic {
create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
fromNotifier<T>(handler: (notification: Notification<T>, thisArg?: any) => void): Observer<T>;
}
export var Observer: ObserverStatic;
@@ -196,6 +189,10 @@ declare module Rx {
export interface IObservable<T> {
subscribe(observer: Observer<T>): 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<T> extends IObservable<T> {
@@ -271,8 +268,18 @@ declare module Rx {
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
tap(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
tap(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>; // alias for do
doOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
doOnError(onError: (exception: any) => void, thisArg?: any): Observable<T>;
doOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
tapOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
tapOnError(onError: (exception: any) => void, thisArg?: any): Observable<T>;
tapOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
finally(action: () => void): Observable<T>;
finallyAction(action: () => void): Observable<T>; // alias for finally
ignoreElements(): Observable<T>;
@@ -284,11 +291,12 @@ declare module Rx {
skipLast(count: number): Observable<T>;
startWith(...values: T[]): Observable<T>;
startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
takeLast(count: number, scheduler?: IScheduler): Observable<T>;
takeLast(count: number): Observable<T>;
takeLastBuffer(count: number): Observable<T[]>;
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
pluck<TResult>(prop: string): Observable<TResult>;
selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
@@ -316,7 +324,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<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
selectSwitch<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>;
/**
* 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 +333,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<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>; // alias for selectSwitch
flatMapLatest<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>; // 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.
@@ -501,15 +509,21 @@ declare module Rx {
throw<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
throwError<T>(error: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
throwError<T>(error: any, scheduler?: IScheduler): Observable<T>; // alias for throw
catch<T>(sources: Observable<T>[]): Observable<T>;
catch<T>(sources: IPromise<T>[]): Observable<T>;
catchException<T>(sources: Observable<T>[]): Observable<T>; // alias for catch
catchException<T>(sources: IPromise<T>[]): Observable<T>; // alias for catch
catchError<T>(sources: Observable<T>[]): Observable<T>; // alias for catch
catchError<T>(sources: IPromise<T>[]): Observable<T>; // alias for catch
catch<T>(...sources: Observable<T>[]): Observable<T>;
catch<T>(...sources: IPromise<T>[]): Observable<T>;
catchException<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
catchException<T>(...sources: IPromise<T>[]): Observable<T>; // alias for catch
catchError<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
catchError<T>(...sources: IPromise<T>[]): Observable<T>; // alias for catch
combineLatest<T, T2, TResult>(first: Observable<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
combineLatest<T, T2, TResult>(first: IPromise<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
rx/rx.async-lite.d.ts
Vendored
+7
View File
@@ -6,6 +6,13 @@
///<reference path="rx-lite.d.ts"/>
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.
rx/rx.backpressure-lite.d.ts
Vendored
+2 -3
View File
@@ -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<boolean>): Observable<T>;
pausable(pauser?: ISubject<boolean>): PausableObservable<T>;
pausable(pauser?: Observable<boolean>): PausableObservable<T>;
/**
* 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<boolean>): PausableObservable<T>;
pausableBuffered(pauser?: Observable<boolean>): PausableObservable<T>;
/**
* Attaches a controller to the observable sequence with the ability to queue.
rx/rx.backpressure.d.ts
Vendored
+1 -1
View File
@@ -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 <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
rx/rx.d.ts
Vendored
+17 -14
View File
@@ -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<TState>(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<T> {
checked(): Observer<any>;
}
rx/rx.joinpatterns.d.ts
Vendored
+10 -10
View File
@@ -9,45 +9,45 @@ declare module Rx {
interface Pattern1<T1> {
and<T2>(other: Observable<T2>): Pattern2<T1, T2>;
then<TR>(selector: (item1: T1) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1) => TR): Plan<TR>;
}
interface Pattern2<T1, T2> {
and<T3>(other: Observable<T3>): Pattern3<T1, T2, T3>;
then<TR>(selector: (item1: T1, item2: T2) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2) => TR): Plan<TR>;
}
interface Pattern3<T1, T2, T3> {
and<T4>(other: Observable<T4>): Pattern4<T1, T2, T3, T4>;
then<TR>(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan<TR>;
}
interface Pattern4<T1, T2, T3, T4> {
and<T5>(other: Observable<T5>): Pattern5<T1, T2, T3, T4, T5>;
then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan<TR>;
}
interface Pattern5<T1, T2, T3, T4, T5> {
and<T6>(other: Observable<T6>): Pattern6<T1, T2, T3, T4, T5, T6>;
then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan<TR>;
}
interface Pattern6<T1, T2, T3, T4, T5, T6> {
and<T7>(other: Observable<T7>): Pattern7<T1, T2, T3, T4, T5, T6, T7>;
then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan<TR>;
}
interface Pattern7<T1, T2, T3, T4, T5, T6, T7> {
and<T8>(other: Observable<T8>): Pattern8<T1, T2, T3, T4, T5, T6, T7, T8>;
then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan<TR>;
}
interface Pattern8<T1, T2, T3, T4, T5, T6, T7, T8> {
and<T9>(other: Observable<T9>): Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan<TR>;
}
interface Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan<TR>;
}
interface Plan<T> { }
interface Observable<T> {
and<T2>(other: Observable<T2>): Pattern2<T, T2>;
then<TR>(selector: (item1: T) => TR): Plan<TR>;
thenDo<TR>(selector: (item1: T) => TR): Plan<TR>;
}
interface ObservableStatic {
rx/rx.time-lite.d.ts
Vendored
+1 -26
View File
@@ -17,6 +17,7 @@ declare module Rx {
}
export interface Observable<T> {
delay(dueTime: Date, scheduler?: IScheduler): Observable<T>;
delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
@@ -25,25 +26,6 @@ declare module Rx {
sample<TSample>(sampler: Observable<TSample>, scheduler?: IScheduler): Observable<T>;
timeout(dueTime: Date, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
timeout(dueTime: number, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
delaySubscription(dueTime: number, scheduler?: IScheduler): Observable<T>;
delayWithSelector(delayDurationSelector: (item: T) => number): Observable<T>;
delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable<T>;
timeoutWithSelector<TTimeout>(firstTimeout: Observable<TTimeout>, timeoutdurationSelector?: (item: T) => Observable<TTimeout>, other?: Observable<T>): Observable<T>;
throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable<T[]>;
takeWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
skipWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
skipUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
takeUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
}
interface ObservableStatic {
@@ -51,12 +33,5 @@ declare module Rx {
interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
timer(dueTime: number, period: number, scheduler?: IScheduler): Observable<number>;
timer(dueTime: number, scheduler?: IScheduler): Observable<number>;
generateWithRelativeTime<TState, TResult>(
initialState: TState,
condition: (state: TState) => boolean,
iterate: (state: TState) => TState,
resultSelector: (state: TState) => TResult,
timeSelector: (state: TState) => number,
scheduler?: IScheduler): Observable<TResult>;
}
}
rx/rx.time.d.ts
Vendored
+26
View File
@@ -8,6 +8,25 @@
declare module Rx {
export interface Observable<T> {
delaySubscription(dueTime: number, scheduler?: IScheduler): Observable<T>;
delayWithSelector(delayDurationSelector: (item: T) => number): Observable<T>;
delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable<T>;
timeoutWithSelector<TTimeout>(firstTimeout: Observable<TTimeout>, timeoutdurationSelector?: (item: T) => Observable<TTimeout>, other?: Observable<T>): Observable<T>;
throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable<T[]>;
takeWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
skipWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
skipUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
takeUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<Observable<T>>;
windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable<Observable<T>>;
windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<Observable<T>>;
@@ -20,6 +39,13 @@ declare module Rx {
timer(dueTime: Date, period: number, scheduler?: IScheduler): Observable<number>;
timer(dueTime: Date, scheduler?: IScheduler): Observable<number>;
generateWithRelativeTime<TState, TResult>(
initialState: TState,
condition: (state: TState) => boolean,
iterate: (state: TState) => TState,
resultSelector: (state: TState) => TResult,
timeSelector: (state: TState) => number,
scheduler?: IScheduler): Observable<TResult>;
generateWithAbsoluteTime<TState, TResult>(
initialState: TState,
condition: (state: TState) => boolean,