mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-08-25 11:11:46 +08:00
rx.js: renamed some interfaces to documentation consistent names (IObservable->Observable)
added test for rx.js.d.ts
This commit is contained in:
Igor Oleinikov
@@ -0,0 +1,135 @@
|
||||
///<reference path="rx.js.d.ts"/>
|
||||
|
||||
// Disposable
|
||||
var d: Rx.IDisposable = new Rx.Disposable(() => { });
|
||||
d = Rx.Disposable.create(() => { });
|
||||
d = Rx.Disposable.empty;
|
||||
d.dispose();
|
||||
|
||||
// CompositeDisposable
|
||||
var cd = new Rx.CompositeDisposable(d, d, d);
|
||||
d = cd;
|
||||
cd = new Rx.CompositeDisposable([d, d]);
|
||||
cd.add(d);
|
||||
cd.clear();
|
||||
var b: boolean = cd.contains(d);
|
||||
var da: Rx.IDisposable[] = cd.toArray();
|
||||
cd.remove(d);
|
||||
|
||||
// SingleAssignmentDisposable
|
||||
var sad = new Rx.SingleAssignmentDisposable();
|
||||
d = sad;
|
||||
sad.setDisposable(d);
|
||||
d = sad.getDisposable();
|
||||
b = sad.isDisposed;
|
||||
|
||||
// SerialDisposable
|
||||
var sd = new Rx.SerialDisposable();
|
||||
d = sd;
|
||||
sd.setDisposable(d);
|
||||
d = sd.getDisposable();
|
||||
b = sd.isDisposed;
|
||||
|
||||
// RefCountDisposable
|
||||
var rcd = new Rx.RefCountDisposable(d);
|
||||
d = rcd;
|
||||
d = rcd.getDisposable();
|
||||
b = rcd.isDisposed;
|
||||
|
||||
// IScheduler
|
||||
var s: Rx.IScheduler;
|
||||
var n: number = s.now();
|
||||
s = s.catch(ex => true);
|
||||
s = s.catchException(ex => true);
|
||||
d = s.schedule(() => { });
|
||||
d = s.scheduleWithState(1,
|
||||
(sh, s) => sh.scheduleWithAbsoluteAndState(s + 1, 100,
|
||||
(sh, s) => sh.scheduleWithRelativeAndState(s + 1, 200,
|
||||
(sh, s) => sh.scheduleRecursiveWithState(s + 1,
|
||||
(s, self) => self(s + 1)))));
|
||||
d = s.scheduleWithAbsolute(100, () => { });
|
||||
d = s.scheduleWithRelative(100, () => { });
|
||||
d = s.scheduleRecursive(self => self());
|
||||
d = s.scheduleRecursiveWithAbsolute(100, self => self(200));
|
||||
d = s.scheduleRecursiveWithRelative(100, self => self(200));
|
||||
d = s.schedulePeriodic(100, () => { });
|
||||
d = s.schedulePeriodicWithState('a', 100, s => s + 'b');
|
||||
|
||||
// ICurrentThreadScheduler
|
||||
Rx.Scheduler.currentThread.scheduleRequired();
|
||||
Rx.Scheduler.currentThread.ensureTrampoline(() => Rx.Disposable.empty);
|
||||
|
||||
// Observer
|
||||
var o: Rx.Observer<number> = Rx.Observer.create<number>();
|
||||
o = Rx.Observer.create<number>(i => { });
|
||||
o = Rx.Observer.create<number>(i => { }, err => { });
|
||||
o = Rx.Observer.create<number>(i => { }, err => { }, () => { });
|
||||
o = Rx.Observer.fromNotifier<number>(n => { });
|
||||
|
||||
o.onNext(10);
|
||||
o.onError(new Error());
|
||||
o.onCompleted();
|
||||
|
||||
// Observable static methods tests
|
||||
|
||||
var ns: Rx.Observable<number> = Rx.Observable.create<number>(observer => { });
|
||||
var ss: Rx.Observable<string> = Rx.Observable.create<string>(observer => (() => { }));
|
||||
var bs: Rx.Observable<boolean> = Rx.Observable.createWithDisposable<boolean>(observer => Rx.Disposable.empty);
|
||||
|
||||
ns = Rx.Observable.defer(() => ns);
|
||||
|
||||
ss = Rx.Observable.empty<string>();
|
||||
bs = Rx.Observable.empty<boolean>(Rx.Scheduler.currentThread);
|
||||
|
||||
ns = Rx.Observable.fromArray([0, 3, -7, 18]);
|
||||
ss = Rx.Observable.fromArray(['a', 'ab', 'abc'], Rx.Scheduler.timeout);
|
||||
|
||||
ns = Rx.Observable.generate(0, i => i < 100, i => i + 1, i => i * i);
|
||||
ns = Rx.Observable.generate(0, i => i < 100, i => i + 1, i => i * i, Rx.Scheduler.timeout);
|
||||
|
||||
bs = Rx.Observable.never<boolean>();
|
||||
|
||||
ns = Rx.Observable.range(0, 100);
|
||||
ns = Rx.Observable.range(0, 100, Rx.Scheduler.timeout);
|
||||
|
||||
ns = Rx.Observable.repeat(0, 100);
|
||||
ns = Rx.Observable.repeat(0, 100, Rx.Scheduler.timeout);
|
||||
|
||||
ss = Rx.Observable.return('a');
|
||||
ss = Rx.Observable.return('a', Rx.Scheduler.timeout);
|
||||
ss = Rx.Observable.returnValue('a');
|
||||
ss = Rx.Observable.returnValue('a', Rx.Scheduler.timeout);
|
||||
|
||||
bs = Rx.Observable.throw<boolean>(new Error("error"));
|
||||
bs = Rx.Observable.throw<boolean>(new Error("error"), Rx.Scheduler.timeout);
|
||||
bs = Rx.Observable.throwException<boolean>(new Error("error"));
|
||||
bs = Rx.Observable.throwException<boolean>(new Error("error"), Rx.Scheduler.timeout);
|
||||
|
||||
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.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.concat(ss, ss, ss);
|
||||
//ss = Rx.Observable.concat([ss, ss, ss]);
|
||||
|
||||
ss = Rx.Observable.merge(ss, ss, ss);
|
||||
//ss = Rx.Observable.merge([ss, ss, ss]);
|
||||
ss = Rx.Observable.merge(s, ss, ss, ss);
|
||||
//ss = Rx.Observable.merge(s, [ss, ss, ss]);
|
||||
|
||||
ss = Rx.Observable.onErrorResumeNext(ss, ss, ss);
|
||||
//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]);
|
||||
|
||||
ns = Rx.Observable.zip(ss, bs, ns, (s, b, n) => s.length + (b ? 1 : 0) + n);
|
||||
|
||||
|
||||
// Observable instance methods
|
||||
|
||||
var sss: Rx.Observable<Rx.Observable<string>>;
|
||||
ss = sss.concatAll();
|
||||
Vendored
+33
-33
@@ -10,44 +10,44 @@
|
||||
// -> rx.aggregates.js
|
||||
|
||||
declare module Rx {
|
||||
interface IObservable<T> {
|
||||
aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
|
||||
aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
|
||||
export interface Observable<T> {
|
||||
aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
|
||||
aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
|
||||
|
||||
any(): IObservable<boolean>;
|
||||
any(selector: (item: T) => boolean): IObservable<boolean>;
|
||||
any(): Observable<boolean>;
|
||||
any(selector: (item: T) => boolean): Observable<boolean>;
|
||||
|
||||
isEmpty(predicate?: (value: T) => boolean): IObservable<boolean>;
|
||||
all(predicate?: (value: T) => boolean): IObservable<boolean>;
|
||||
contains(value: T, comparer?: (value1: T, value2: T) => boolean): IObservable<boolean>;
|
||||
count(predicate?: (item: T) => boolean): IObservable<number>;
|
||||
sum(keySelector?: (item: T) => number): IObservable<number>;
|
||||
minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable<T>;
|
||||
min(comparer?: (value1: T, value2: T) => number): IObservable<T>;
|
||||
maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable<T>;
|
||||
max(comparer?: (value1: T, value2: T) => number): IObservable<number>;
|
||||
average(keySelector?: (item: T) => number): IObservable<number>;
|
||||
isEmpty(predicate?: (value: T) => boolean): Observable<boolean>;
|
||||
all(predicate?: (value: T) => boolean): Observable<boolean>;
|
||||
contains(value: T, comparer?: (value1: T, value2: T) => boolean): Observable<boolean>;
|
||||
count(predicate?: (item: T) => boolean): Observable<number>;
|
||||
sum(keySelector?: (item: T) => number): Observable<number>;
|
||||
minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
|
||||
min(comparer?: (value1: T, value2: T) => number): Observable<T>;
|
||||
maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
|
||||
max(comparer?: (value1: T, value2: T) => number): Observable<number>;
|
||||
average(keySelector?: (item: T) => number): Observable<number>;
|
||||
|
||||
sequenceEqual(second: IObservable<T>, comparer?: (value1: T, value2: T) => number): IObservable<T>;
|
||||
elementAt(index: number): IObservable<T>;
|
||||
elementAtOrDefault(index: number, defaultValue: T): IObservable<T>;
|
||||
sequenceEqual(second: Observable<T>, comparer?: (value1: T, value2: T) => number): Observable<T>;
|
||||
elementAt(index: number): Observable<T>;
|
||||
elementAtOrDefault(index: number, defaultValue: T): Observable<T>;
|
||||
|
||||
single(): IObservable<T>;
|
||||
single(predicate: (T) => boolean): IObservable<T>;
|
||||
singleOrDefault(): IObservable<T>;
|
||||
singleOrDefault(predicate: (T) => boolean): IObservable<T>;
|
||||
singleOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
|
||||
single(): Observable<T>;
|
||||
single(predicate: (item: T) => boolean): Observable<T>;
|
||||
singleOrDefault(): Observable<T>;
|
||||
singleOrDefault(predicate: (item: T) => boolean): Observable<T>;
|
||||
singleOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
|
||||
|
||||
first(): IObservable<T>;
|
||||
first(predicate: (T) => boolean): IObservable<T>;
|
||||
firstOrDefault(): IObservable<T>;
|
||||
firstOrDefault(predicate: (T) => boolean): IObservable<T>;
|
||||
firstOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
|
||||
first(): Observable<T>;
|
||||
first(predicate: (item: T) => boolean): Observable<T>;
|
||||
firstOrDefault(): Observable<T>;
|
||||
firstOrDefault(predicate: (item: T) => boolean): Observable<T>;
|
||||
firstOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
|
||||
|
||||
last(): IObservable<T>;
|
||||
last(predicate: (T) => boolean): IObservable<T>;
|
||||
lastOrDefault(): IObservable<T>;
|
||||
lastOrDefault(predicate: (T) => boolean): IObservable<T>;
|
||||
lastOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
|
||||
last(): Observable<T>;
|
||||
last(predicate: (item: T) => boolean): Observable<T>;
|
||||
lastOrDefault(): Observable<T>;
|
||||
lastOrDefault(predicate: (item: T) => boolean): Observable<T>;
|
||||
lastOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
|
||||
}
|
||||
}
|
||||
Vendored
+7
-7
@@ -11,12 +11,12 @@
|
||||
|
||||
declare module Rx {
|
||||
interface Observable {
|
||||
start<T>(func: () => T, scheduler?: IScheduler, context?: any): IObservable<T>;
|
||||
toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable<T>;
|
||||
fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => IObservable<T>;
|
||||
fromNodeCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => IObservable<T>;
|
||||
fromEvent<T>(element: any, eventName: string, selector?: (...arguments: any[])=>T): IObservable<T>;
|
||||
fromEventPattern<T>(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): IObservable<T>;
|
||||
fromPromise<T>(promise: any): IObservable<T>;
|
||||
start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
|
||||
toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => Observable<T>;
|
||||
fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => Observable<T>;
|
||||
fromNodeCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => Observable<T>;
|
||||
fromEvent<T>(element: any, eventName: string, selector?: (...arguments: any[])=>T): Observable<T>;
|
||||
fromEventPattern<T>(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): Observable<T>;
|
||||
fromPromise<T>(promise: any): Observable<T>;
|
||||
}
|
||||
}
|
||||
Vendored
+6
-6
@@ -27,25 +27,25 @@ declare module Rx {
|
||||
new <T>(initialValue: T): BehaviorSubject<T>;
|
||||
}
|
||||
|
||||
interface ConnectableObservable<T> extends IObservable<T>{
|
||||
interface ConnectableObservable<T> extends Observable<T>{
|
||||
connect(): IDisposable;
|
||||
refCount(): IObservable<T>;
|
||||
refCount(): Observable<T>;
|
||||
}
|
||||
|
||||
var ConnectableObservable: {
|
||||
new <T>(): ConnectableObservable<T>;
|
||||
}
|
||||
|
||||
interface IObservable<T> {
|
||||
interface Observable<T> {
|
||||
|
||||
publish(): ConnectableObservable<T>;
|
||||
publish<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
|
||||
publish<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
|
||||
publishLast(): ConnectableObservable<T>;
|
||||
publishLast<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
|
||||
publishLast<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
|
||||
publishValue(initialValue: T): ConnectableObservable<T>;
|
||||
publishValue<TResult>(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable<TResult>;
|
||||
|
||||
replay(selector?: (source: IObservable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
|
||||
replay(selector?: (source: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Vendored
+13
-13
@@ -11,27 +11,27 @@
|
||||
|
||||
declare module Rx {
|
||||
|
||||
interface IObservable<T> {
|
||||
interface Observable<T> {
|
||||
join<T2, TDuration, T2Duration, TResult>(
|
||||
right: IObservable<T2>,
|
||||
leftDurationSelector: (leftItem: T) => IObservable<TDuration>,
|
||||
rightDurationSelector: (rightItem: T2) => IObservable<T2Duration>,
|
||||
resultSelector: (leftItem: T, rightItem: T2) => TResult): IObservable<TResult>;
|
||||
right: Observable<T2>,
|
||||
leftDurationSelector: (leftItem: T) => Observable<TDuration>,
|
||||
rightDurationSelector: (rightItem: T2) => Observable<T2Duration>,
|
||||
resultSelector: (leftItem: T, rightItem: T2) => TResult): Observable<TResult>;
|
||||
|
||||
groupJoin<T2, TDuration, T2Duration, TResult>(
|
||||
right: IObservable<T2>,
|
||||
leftDurationSelector: (leftItem: T) => IObservable<TDuration>,
|
||||
rightDurationSelector: (rightItem: T2) => IObservable<T2Duration>,
|
||||
resultSelector: (leftItem: T, rightItem: IObservable<T2>) => TResult): IObservable<TResult>;
|
||||
right: Observable<T2>,
|
||||
leftDurationSelector: (leftItem: T) => Observable<TDuration>,
|
||||
rightDurationSelector: (rightItem: T2) => Observable<T2Duration>,
|
||||
resultSelector: (leftItem: T, rightItem: Observable<T2>) => TResult): Observable<TResult>;
|
||||
|
||||
|
||||
// lack of documentation to complete the followings...
|
||||
|
||||
buffer<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
|
||||
bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
|
||||
buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
|
||||
bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
|
||||
|
||||
window<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
|
||||
bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
|
||||
window<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
|
||||
bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Vendored
+175
-252
@@ -8,7 +8,7 @@ declare module Rx {
|
||||
export module Internals {
|
||||
function inherits(child: Function, parent: Function): Function;
|
||||
function addProperties(obj: Object, ...sourcces: Object[]): void;
|
||||
function addRef<T>(xs: IObservable<T>, r: { getDisposable(): IDisposable; }): IObservable<T>;
|
||||
function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
|
||||
}
|
||||
|
||||
//Collections
|
||||
@@ -34,7 +34,7 @@ declare module Rx {
|
||||
remove(item: IIndexedItem): boolean;
|
||||
}
|
||||
|
||||
interface IDisposable {
|
||||
export interface IDisposable {
|
||||
dispose(): void;
|
||||
}
|
||||
|
||||
@@ -59,9 +59,6 @@ declare module Rx {
|
||||
static create(action: () => void): IDisposable;
|
||||
static empty: IDisposable;
|
||||
|
||||
isDisposed: boolean;
|
||||
action: () => void;
|
||||
|
||||
dispose(): void;
|
||||
}
|
||||
|
||||
@@ -111,27 +108,27 @@ declare module Rx {
|
||||
invokeCore(): IDisposable;
|
||||
}
|
||||
|
||||
interface IScheduler {
|
||||
export interface IScheduler {
|
||||
now(): number;
|
||||
catch(handler: (exception: any) => boolean): IScheduler;
|
||||
catchException(handler: (exception: any) => boolean): IScheduler;
|
||||
|
||||
schedule(action: () => void): IDisposable;
|
||||
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
|
||||
scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
||||
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
|
||||
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
|
||||
scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
|
||||
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
|
||||
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
|
||||
scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
|
||||
|
||||
scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable;
|
||||
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): IDisposable;
|
||||
scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) =>void ) =>void ): IDisposable;
|
||||
scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable;
|
||||
scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): IDisposable;
|
||||
scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
|
||||
|
||||
schedulePeriodic(period: number, action: () => void): IDisposable;
|
||||
schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
|
||||
schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
|
||||
}
|
||||
|
||||
export class Scheduler implements IScheduler {
|
||||
@@ -152,21 +149,21 @@ declare module Rx {
|
||||
catchException(handler: (exception: any) => boolean): IScheduler;
|
||||
|
||||
schedule(action: () => void): IDisposable;
|
||||
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
|
||||
scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
||||
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
|
||||
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
|
||||
scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
||||
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
|
||||
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
|
||||
scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
||||
|
||||
scheduleRecursive(action: (action: () => void) => void): IDisposable;
|
||||
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
|
||||
scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
|
||||
|
||||
schedulePeriodic(period: number, action: () => void): IDisposable;
|
||||
schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
|
||||
schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
|
||||
}
|
||||
|
||||
// Current Thread IScheduler
|
||||
@@ -176,267 +173,193 @@ declare module Rx {
|
||||
}
|
||||
|
||||
// Notifications
|
||||
interface INotification<T> {
|
||||
accept(observer: IObserver<T>): void;
|
||||
accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void;
|
||||
toObservable(scheduler?: IScheduler): IObservable<any>;
|
||||
export class Notification<T> {
|
||||
accept(observer: Observer<T>): void;
|
||||
accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
|
||||
toObservable(scheduler?: IScheduler): Observable<T>;
|
||||
hasValue: boolean;
|
||||
equals(other: INotification<T>): boolean;
|
||||
equals(other: Notification<T>): boolean;
|
||||
kind: string;
|
||||
value?: T;
|
||||
exception?: any;
|
||||
}
|
||||
export interface Notification {
|
||||
//abstract
|
||||
//function new (): INotification;
|
||||
value: T;
|
||||
exception: any;
|
||||
|
||||
createOnNext<T>(value: T): INotification<T>;//ON
|
||||
createOnError<T>(exception): INotification<T>;//OE
|
||||
createOnCompleted<T>(): INotification<T>;//OC
|
||||
}
|
||||
|
||||
var Notification: Notification;
|
||||
|
||||
export module Internals {
|
||||
// Enumerator
|
||||
interface IEnumerator<T> {
|
||||
moveNext(): boolean;
|
||||
getCurrent(): T;
|
||||
dispose(): void;
|
||||
}
|
||||
export interface Enumerator<T> {
|
||||
(moveNext: () =>boolean, getCurrent: () => T, dispose: () =>void ): IEnumerator<T>;
|
||||
|
||||
create(moveNext: () =>boolean, getCurrent: () => T, dispose?: () =>void ): IEnumerator<T>;
|
||||
}
|
||||
|
||||
// Enumerable
|
||||
interface IEnumerable<T> {
|
||||
getEnumerator(): IEnumerator<T>;
|
||||
|
||||
concat(): IObservable<T>;
|
||||
catchException(): IObservable<T>;
|
||||
}
|
||||
export interface Enumerable<T> {
|
||||
(getEnumerator: () =>IEnumerator<T>): IEnumerable<T>;
|
||||
|
||||
repeat(value: T, repeatCount?: number): IEnumerable<any>;
|
||||
forEach<T2>(source: T[], selector?: (element: T, index: number) => T2): IEnumerable<T2>;
|
||||
forEach<T2>(source: { length: number; [index: number]: T; }, selector?: (element: T, index: number) => T2): IEnumerable<T2>;
|
||||
}
|
||||
static createOnNext<T>(value: T): Notification<T>;
|
||||
static createOnError<T>(exception): Notification<T>;
|
||||
static createOnCompleted<T>(): Notification<T>;
|
||||
}
|
||||
|
||||
// Observer
|
||||
interface IObserver<T> {
|
||||
export class Observer<T> {
|
||||
onNext(value: T): void;
|
||||
onError(exception: any): void;
|
||||
onCompleted(): void;
|
||||
|
||||
toNotifier(): (notification: INotification<T>) =>void;
|
||||
asObserver(): IObserver<T>;
|
||||
checked(): ICheckedObserver<any>;
|
||||
}
|
||||
export module Observer {
|
||||
//abstract
|
||||
//function new (): IObserver;
|
||||
toNotifier(): (notification: Notification<T>) =>void;
|
||||
asObserver(): Observer<T>;
|
||||
checked(): Observer<any>;
|
||||
|
||||
function create<T>(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver<T>;
|
||||
function fromNotifier<T>(handler: (notification: INotification<T>) =>void ): IObserver<T>;
|
||||
static create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
|
||||
static fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
|
||||
}
|
||||
|
||||
export module Internals {
|
||||
// Abstract Observer
|
||||
interface IAbstractObserver<T> extends IObserver<T> {
|
||||
isStopped: boolean;
|
||||
export interface Observable<T> {
|
||||
_subscribe: (observer: Observer<T>) => IDisposable;
|
||||
|
||||
dispose(): void;
|
||||
next(value: T): void;
|
||||
error(exception: any): void;
|
||||
completed(): void;
|
||||
fail(): boolean;
|
||||
}
|
||||
//export module AbstractObserver {
|
||||
// //abstract
|
||||
// function new (): IAbstractObserver;
|
||||
//}
|
||||
subscribe(observer: Observer<T>): IDisposable;
|
||||
|
||||
finalValue(): Observable<T>;
|
||||
subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
|
||||
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>;
|
||||
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>;
|
||||
concat(...sources: Observable<T>[]): Observable<T>;
|
||||
concat(sources: Observable<T>[]): Observable<T>;
|
||||
concatObservable(): T;
|
||||
concatAll(): T;
|
||||
merge(maxConcurrent: number): Observable<T>;
|
||||
merge(other: Observable<T>): Observable<T>;
|
||||
mergeObservable(): T;
|
||||
mergeAll(): T;
|
||||
onErrorResumeNext(second: Observable<T>): Observable<T>;
|
||||
skipUntil<T2>(other: Observable<T2>): Observable<T>;
|
||||
switchLatest(): Observable<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>;
|
||||
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>;
|
||||
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>;
|
||||
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>;
|
||||
defaultIfEmpty(defaultValue?: T): 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>;
|
||||
skip(count: number): Observable<T>;
|
||||
skipWhile(predicate: (value: T, index?: number) => boolean): 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>;
|
||||
}
|
||||
|
||||
export class AnonymousObserver<T> {
|
||||
constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void);
|
||||
interface ObservableStatic {
|
||||
create<T>(subscribe: (observer: Observer<T>) => void): Observable<T>;
|
||||
create<T>(subscribe: (observer: Observer<T>) => () => void): Observable<T>;
|
||||
createWithDisposable<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
|
||||
defer<T>(observableFactory: () => Observable<T>): Observable<T>;
|
||||
empty<T>(scheduler?: IScheduler): Observable<T>;
|
||||
fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
|
||||
fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
|
||||
generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable<TResult>;
|
||||
never<T>(): Observable<T>;
|
||||
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>;
|
||||
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>;
|
||||
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>;
|
||||
catch<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
catchException<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
concat<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
concat<T>(sources: Observable<T>[]): Observable<T>;
|
||||
merge<T>(...sources: Observable<T>[]): Observable<T>;
|
||||
merge<T>(sources: Observable<T>[]): Observable<T>;
|
||||
merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
|
||||
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>(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[]>;
|
||||
}
|
||||
|
||||
interface ICheckedObserver<T> extends IObserver<T> {
|
||||
_observer: IObserver<T>;
|
||||
_state: number; // 0 - idle, 1 - busy, 2 - done
|
||||
checkAccess(): void;
|
||||
}
|
||||
export var Observable: ObservableStatic;
|
||||
|
||||
export module Internals {
|
||||
interface IScheduledObserver<T> extends IAbstractObserver<T> {
|
||||
scheduler: IScheduler;
|
||||
observer: IObserver<T>;
|
||||
isAcquired: boolean;
|
||||
hasFaulted: boolean;
|
||||
//queue: { (value: any): void; (exception: any): void; (): void; }[];
|
||||
disposable: SerialDisposable;
|
||||
|
||||
ensureActive(): void;
|
||||
}
|
||||
export interface ScheduledObserver<T> {
|
||||
(scheduler: IScheduler, observer: IObserver<T>): IScheduledObserver<T>;
|
||||
}
|
||||
}
|
||||
|
||||
interface IObservable<T> {
|
||||
_subscribe: (observer: IObserver<T>) =>IDisposable;
|
||||
|
||||
subscribe(observer: IObserver<T>): IDisposable;
|
||||
|
||||
finalValue(): IObservable<T>;
|
||||
subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IDisposable;
|
||||
toArray(): IObservable<T>;
|
||||
|
||||
observeOn(scheduler: IScheduler): IObservable<T>;
|
||||
subscribeOn(scheduler: IScheduler): IObservable<T>;
|
||||
|
||||
amb(rightSource: IObservable<T>): IObservable<T>;
|
||||
catchException(handler: (exception: any) =>IObservable<T>): IObservable<T>;
|
||||
catchException(second: IObservable<T>): IObservable<T>;
|
||||
combineLatest<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
|
||||
combineLatest<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) =>TResult): IObservable<TResult>;
|
||||
combineLatest<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) =>TResult): IObservable<TResult>;
|
||||
combineLatest<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) =>TResult): IObservable<TResult>;
|
||||
combineLatest<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
|
||||
concat(...sources: IObservable<T>[]): IObservable<T>;
|
||||
concat(sources: IObservable<T>[]): IObservable<T>;
|
||||
//concatIObservable(): IObservable<T>;
|
||||
merge(maxConcurrent: number): IObservable<T>;
|
||||
merge(other: IObservable<T>): IObservable<T>;
|
||||
//mergeIObservable(): IObservable<any>;
|
||||
onErrorResumeNext(second: IObservable<T>): IObservable<T>;
|
||||
skipUntil<T2>(other: IObservable<T2>): IObservable<T>;
|
||||
switchLatest(): IObservable<T>;
|
||||
takeUntil<T2>(other: IObservable<T2>): IObservable<T>;
|
||||
zip<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
|
||||
zip<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): IObservable<TResult>;
|
||||
zip<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): IObservable<TResult>;
|
||||
zip<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): IObservable<TResult>;
|
||||
zip<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
|
||||
zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): IObservable<TResult>;
|
||||
asIObservable(): IObservable<any>;
|
||||
bufferWithCount(count: number, skip?: number): IObservable<T>;
|
||||
dematerialize<TOrigin>(): IObservable<TOrigin>;
|
||||
distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>boolean): IObservable<any>;
|
||||
doAction(observer: IObserver<T>): IObservable<T>;
|
||||
doAction(onNext: (value: T) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable<T>;
|
||||
finallyAction(action: () =>void): IObservable<T>;
|
||||
ignoreElements(): IObservable<T>;
|
||||
materialize(): IObservable<INotification<any>>; // IObservable<INotification<T>> not supported by TypeScript 0.9.0 !!
|
||||
repeat(repeatCount?: number): IObservable<T>;
|
||||
retry(retryCount?: number): IObservable<T>;
|
||||
scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
|
||||
scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
|
||||
skipLast(count: number): IObservable<T>;
|
||||
startWith(...values: T[]): IObservable<T>;
|
||||
startWith(scheduler: IScheduler, ...values: T[]): IObservable<T>;
|
||||
takeLast(count: number, scheduler?: IScheduler): IObservable<T>;
|
||||
takeLastBuffer(count: number): IObservable<T>;
|
||||
windowWithCount(count: number, skip?: number): IObservable<T>;
|
||||
defaultIfEmpty(defaultValue?: any): IObservable<T>;
|
||||
distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) =>string): IObservable<T>;
|
||||
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
|
||||
groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: IGroupedObservable<TKey, TElement>) => IObservable<number>, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
|
||||
select<T2>(selector: (value: T, index: number) =>T2): IObservable<T2>;
|
||||
selectMany<T2>(selector: (value: T) =>IObservable<T2>, resultSelector?: (x: any, y: any) =>any): IObservable<T2>;
|
||||
selectMany<T2>(other: IObservable<T2>): IObservable<T2>;
|
||||
skip(count: number): IObservable<T>;
|
||||
skipWhile(predicate: (value: T, index?: number) =>boolean): IObservable<T>;
|
||||
take(count: number, scheduler?: IScheduler): IObservable<T>;
|
||||
takeWhile(predicate: (value: T, index?: number) =>boolean): IObservable<T>;
|
||||
where(predicate: (value: T, index?: number) => boolean): IObservable<T>;
|
||||
}
|
||||
|
||||
interface Observable {
|
||||
(subscribe: (observer: IObserver<any>) =>IDisposable): IObservable<any>;
|
||||
|
||||
create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
|
||||
create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
|
||||
createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>IDisposable): IObservable<T>;
|
||||
defer<T>(observableFactory: () => IObservable<T>): IObservable<T>;
|
||||
empty<T>(scheduler?: IScheduler): IObservable<T>;
|
||||
fromArray<T>(array: T[], scheduler?: IScheduler): IObservable<T>;
|
||||
fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable<T>;
|
||||
generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): IObservable<TResult>;
|
||||
never<T>(): IObservable<T>;
|
||||
range(start: number, count: number, scheduler?: IScheduler): IObservable<number>;
|
||||
repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable<T>;
|
||||
return<T>(value: T, scheduler?: IScheduler): IObservable<T>;
|
||||
returnValue<T>(value: T, scheduler?: IScheduler): IObservable<T>;
|
||||
throw<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
|
||||
throw<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
|
||||
throwException<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
|
||||
throwException<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
|
||||
using<TSource, TResource>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable<TSource>): IObservable<TSource>;
|
||||
amb<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
catchException<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
catchException<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
concat<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
concat<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(scheduler: IScheduler, ...sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(scheduler: IScheduler, sources: IObservable<T>[]): IObservable<T>;
|
||||
onErrorResumeNext<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
onErrorResumeNext<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
zip<T>(...soucesAndResultSelector: any[]): IObservable<T>;
|
||||
}
|
||||
|
||||
var Observable: Observable;
|
||||
|
||||
export module Internals {
|
||||
interface IAnonymousObservable<T> extends IObservable<T> { }
|
||||
export interface AnonymousObservable<T> {
|
||||
(subscribe: (observer: IObserver<T>) =>IDisposable): IAnonymousObservable<T>;
|
||||
}
|
||||
}
|
||||
|
||||
interface IGroupedObservable<TKey, TElement> extends IObservable<TElement> {
|
||||
interface GroupedObservable<TKey, TElement> extends Observable<TElement> {
|
||||
key: TKey;
|
||||
underlyingObservable: IObservable<TElement>;
|
||||
underlyingObservable: Observable<TElement>;
|
||||
}
|
||||
|
||||
interface ISubject<T> extends IObservable<T>, IObserver<T> {
|
||||
isDisposed: boolean;
|
||||
isStopped: boolean;
|
||||
//observers: IObserver<T>[];
|
||||
|
||||
dispose(): void;
|
||||
interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
|
||||
hasObservers(): boolean;
|
||||
}
|
||||
|
||||
export interface Subject<T> extends ISubject<T> {
|
||||
create<T>(observer?: IObserver<T>, observable?: IObservable<T>): ISubject<T>;
|
||||
}
|
||||
|
||||
var Subject: {
|
||||
interface SubjectStatic {
|
||||
new <T>(): Subject<T>;
|
||||
}
|
||||
|
||||
interface IAsyncSubject<T> extends IObservable<T>, IObserver<T> {
|
||||
isDisposed: boolean;
|
||||
value: T;
|
||||
hasValue: boolean;
|
||||
observers: IObserver<T>[];
|
||||
exception: any;
|
||||
|
||||
dispose(): void;
|
||||
}
|
||||
export interface AsyncSubject<T> {
|
||||
(): IAsyncSubject<T>;
|
||||
create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
|
||||
}
|
||||
|
||||
interface IAnonymousSubject<T> extends IObservable<T> {
|
||||
onNext(value: T): void;
|
||||
onError(exception: any): void;
|
||||
onCompleted(): void;
|
||||
export var Subject: SubjectStatic;
|
||||
|
||||
export interface AsyncSubject<T> extends Subject<T> {
|
||||
}
|
||||
|
||||
interface AsyncSubjectStatic {
|
||||
new <T>(): AsyncSubject<T>;
|
||||
}
|
||||
|
||||
export var AsyncSubject: AsyncSubjectStatic;
|
||||
|
||||
export interface BehaviorSubject<T> extends Subject<T> {
|
||||
}
|
||||
|
||||
interface BehaviorSubjectStatic {
|
||||
new <T>(initialValue: T): BehaviorSubject<T>;
|
||||
}
|
||||
|
||||
export var BehaviorSubject: BehaviorSubjectStatic;
|
||||
|
||||
export interface ReplaySubject<T> extends Subject<T> {
|
||||
}
|
||||
|
||||
interface ReplaySubjectStatic {
|
||||
new <T>(initialValue: T): ReplaySubject<T>;
|
||||
}
|
||||
|
||||
export var ReplaySubject: ReplaySubjectStatic;
|
||||
}
|
||||
|
||||
Vendored
+25
-25
@@ -7,7 +7,7 @@
|
||||
|
||||
declare module Rx {
|
||||
|
||||
interface IObservable<T> {
|
||||
interface Observable<T> {
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions.
|
||||
* This operator allows for a fluent style of writing queries that use the same sequence multiple times.
|
||||
@@ -15,7 +15,7 @@ declare module Rx {
|
||||
* @param selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
|
||||
* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
let<TResult>(selector: (source: IObservable<T>) => IObservable<TResult>): IObservable<TResult>;
|
||||
let<TResult>(selector: (source: Observable<T>) => Observable<TResult>): Observable<TResult>;
|
||||
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions.
|
||||
@@ -24,14 +24,14 @@ declare module Rx {
|
||||
* @param selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
|
||||
* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
letBind<TResult>(selector: (source: IObservable<T>) => IObservable<TResult>): IObservable<TResult>;
|
||||
letBind<TResult>(selector: (source: Observable<T>) => Observable<TResult>): Observable<TResult>;
|
||||
|
||||
/**
|
||||
* Repeats source as long as condition holds emulating a do while loop.
|
||||
* @param condition The condition which determines if the source will be repeated.
|
||||
* @returns An observable sequence which is repeated as long as the condition holds.
|
||||
*/
|
||||
doWhile(condition: () => boolean): IObservable<T>;
|
||||
doWhile(condition: () => boolean): Observable<T>;
|
||||
|
||||
/**
|
||||
* Expands an observable sequence by recursively invoking selector.
|
||||
@@ -40,7 +40,7 @@ declare module Rx {
|
||||
* @param [scheduler] Scheduler on which to perform the expansion. If not provided, this defaults to the current thread scheduler.
|
||||
* @returns An observable sequence containing all the elements produced by the recursive expansion.
|
||||
*/
|
||||
expand(selector: (item: T) => IObservable<T>, scheduler?: IScheduler): IObservable<T>;
|
||||
expand(selector: (item: T) => Observable<T>, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Runs two observable sequences in parallel and combines their last elemenets.
|
||||
@@ -49,7 +49,7 @@ declare module Rx {
|
||||
* @param resultSelector Result selector function to invoke with the last elements of both sequences.
|
||||
* @returns An observable sequence with the result of calling the selector function with the last elements of both input sequences.
|
||||
*/
|
||||
forkJoin<TSecond, TResult>(second: IObservable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): IObservable<TResult>;
|
||||
forkJoin<TSecond, TResult>(second: Observable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
|
||||
|
||||
/**
|
||||
* Comonadic bind operator.
|
||||
@@ -57,7 +57,7 @@ declare module Rx {
|
||||
* @param [scheduler] Scheduler used to execute the operation. If not specified, defaults to the ImmediateScheduler.
|
||||
* @returns An observable sequence which results from the comonadic bind operation.
|
||||
*/
|
||||
manySelect<TResult>(selector: (item: IObservable<T>, index: number, source: IObservable<T>) => TResult, scheduler?: IScheduler): IObservable<TResult>;
|
||||
manySelect<TResult>(selector: (item: Observable<T>, index: number, source: Observable<T>) => TResult, scheduler?: IScheduler): Observable<TResult>;
|
||||
}
|
||||
|
||||
interface Observable {
|
||||
@@ -71,7 +71,7 @@ declare module Rx {
|
||||
* @param elseSource The observable sequence that will be run if the condition function returns false.
|
||||
* @returns An observable sequence which is either the thenSource or elseSource.
|
||||
*/
|
||||
if<T>(condition: () => boolean, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
|
||||
if<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
|
||||
@@ -83,7 +83,7 @@ declare module Rx {
|
||||
* @param scheduler Scheduler used to create Rx.Observabe.Empty.
|
||||
* @returns An observable sequence which is either the thenSource or empty sequence.
|
||||
*/
|
||||
if<T>(condition: () => boolean, thenSource: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
|
||||
if<T>(condition: () => boolean, thenSource: Observable<T>, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
|
||||
@@ -95,7 +95,7 @@ declare module Rx {
|
||||
* @param elseSource The observable sequence that will be run if the condition function returns false.
|
||||
* @returns An observable sequence which is either the thenSource or elseSource.
|
||||
*/
|
||||
ifThen<T>(condition: () => boolean, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
|
||||
ifThen<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
|
||||
@@ -107,7 +107,7 @@ declare module Rx {
|
||||
* @param scheduler Scheduler used to create Rx.Observabe.Empty.
|
||||
* @returns An observable sequence which is either the thenSource or empty sequence.
|
||||
*/
|
||||
ifThen<T>(condition: () => boolean, thenSource: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
|
||||
ifThen<T>(condition: () => boolean, thenSource: Observable<T>, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Concatenates the observable sequences obtained by running the specified result selector for each element in source.
|
||||
@@ -116,7 +116,7 @@ declare module Rx {
|
||||
* @param resultSelector A function to apply to each item in the sources array to turn it into an observable sequence.
|
||||
* @returns An observable sequence from the concatenated observable sequences.
|
||||
*/
|
||||
for<T, TResult>(sources: T[], resultSelector: (item: T) => IObservable<TResult>): IObservable<TResult>;
|
||||
for<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
|
||||
|
||||
/**
|
||||
* Concatenates the observable sequences obtained by running the specified result selector for each element in source.
|
||||
@@ -125,7 +125,7 @@ declare module Rx {
|
||||
* @param resultSelector A function to apply to each item in the sources array to turn it into an observable sequence.
|
||||
* @returns An observable sequence from the concatenated observable sequences.
|
||||
*/
|
||||
forIn<T, TResult>(sources: T[], resultSelector: (item: T) => IObservable<TResult>): IObservable<TResult>;
|
||||
forIn<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
|
||||
|
||||
/**
|
||||
* Repeats source as long as condition holds emulating a while loop.
|
||||
@@ -134,7 +134,7 @@ declare module Rx {
|
||||
* @param source The observable sequence that will be run if the condition function returns true.
|
||||
* @returns An observable sequence which is repeated as long as the condition holds.
|
||||
*/
|
||||
while<T>(condition: () => boolean, source: IObservable<T>): IObservable<T>;
|
||||
while<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Repeats source as long as condition holds emulating a while loop.
|
||||
@@ -143,7 +143,7 @@ declare module Rx {
|
||||
* @param source The observable sequence that will be run if the condition function returns true.
|
||||
* @returns An observable sequence which is repeated as long as the condition holds.
|
||||
*/
|
||||
whileDo<T>(condition: () => boolean, source: IObservable<T>): IObservable<T>;
|
||||
whileDo<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -157,7 +157,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
case<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
|
||||
case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -173,7 +173,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
case<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
|
||||
case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -187,7 +187,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
case<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
|
||||
case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -203,7 +203,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
case<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
|
||||
case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -217,7 +217,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
switchCase<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
|
||||
switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -233,7 +233,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
switchCase<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
|
||||
switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -247,7 +247,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
switchCase<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
|
||||
switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
@@ -263,7 +263,7 @@ declare module Rx {
|
||||
*
|
||||
* @returns An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
switchCase<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
|
||||
switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
|
||||
|
||||
/**
|
||||
* Runs all observable sequences in parallel and collect their last elements.
|
||||
@@ -273,7 +273,7 @@ declare module Rx {
|
||||
* @param sources Array of source sequences.
|
||||
* @returns An observable sequence with an array collecting the last elements of all the input sequences.
|
||||
*/
|
||||
forkJoin<T>(sources: IObservable<T>[]): IObservable<T[]>;
|
||||
forkJoin<T>(sources: Observable<T>[]): Observable<T[]>;
|
||||
|
||||
/**
|
||||
* Runs all observable sequences in parallel and collect their last elements.
|
||||
@@ -283,6 +283,6 @@ declare module Rx {
|
||||
* @param args Source sequences.
|
||||
* @returns An observable sequence with an array collecting the last elements of all the input sequences.
|
||||
*/
|
||||
forkJoin<T>(...args: IObservable<T>[]): IObservable<T[]>;
|
||||
forkJoin<T>(...args: Observable<T>[]): Observable<T[]>;
|
||||
}
|
||||
}
|
||||
|
||||
Vendored
+1
-1
@@ -11,7 +11,7 @@
|
||||
|
||||
declare module Rx {
|
||||
|
||||
//interface IObservable<T> {
|
||||
//interface Observable<T> {
|
||||
//}
|
||||
|
||||
|
||||
|
||||
Vendored
+38
-38
@@ -55,45 +55,45 @@ declare module JQueryResults {
|
||||
|
||||
|
||||
interface JQueryStatic {
|
||||
ajaxAsObservable<T>(settings: JQueryAjaxSettings): Rx.IObservable<T>;
|
||||
getAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
|
||||
getJSONAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
|
||||
getScriptAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
|
||||
postAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
|
||||
ajaxAsObservable<T>(settings: JQueryAjaxSettings): Rx.Observable<T>;
|
||||
getAsObservable<T>(url: string, data: any, dataType: string): Rx.Observable<T>;
|
||||
getJSONAsObservable<T>(url: string, data: any): Rx.Observable<T>;
|
||||
getScriptAsObservable<T>(url: string, data: any): Rx.Observable<T>;
|
||||
postAsObservable<T>(url: string, data: any, dataType: string): Rx.Observable<T>;
|
||||
}
|
||||
|
||||
interface JQuery {
|
||||
changeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
clickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
dblclickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
focusAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
focusinAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
focusoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
keydownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
|
||||
keyupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
|
||||
loadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.uiEvent>;
|
||||
mousedownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseenterAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseleaveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mousemoveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseoverAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
resizeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
scrollAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
selectAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
submitAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
unloadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
hideAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
|
||||
showAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
|
||||
readyAsObservable(): Rx.IObservable<any>;
|
||||
animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeInAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
|
||||
slideDownAsObservable(duration: number): Rx.IObservable<any>;
|
||||
slideUpAsObservable(duration: number): Rx.IObservable<any>;
|
||||
slideToggleAsObservable(duration: number): Rx.IObservable<any>;
|
||||
toggleAsObservable(duration: number): Rx.IObservable<any>;
|
||||
changeAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
clickAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
dblclickAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
focusAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
focusinAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
focusoutAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
keydownAsObservable(eventData?: any): Rx.Observable<JQueryResults.keyEvent>;
|
||||
keyupAsObservable(eventData?: any): Rx.Observable<JQueryResults.keyEvent>;
|
||||
loadAsObservable(eventData?: any): Rx.Observable<JQueryResults.uiEvent>;
|
||||
mousedownAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
mouseenterAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
mouseleaveAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
mousemoveAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
mouseoutAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
mouseoverAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
mouseupAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
|
||||
resizeAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
scrollAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
selectAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
submitAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
unloadAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
|
||||
hideAsObservable(duration: number): Rx.Observable<JQueryResults.eventBase>;
|
||||
showAsObservable(duration: number): Rx.Observable<JQueryResults.eventBase>;
|
||||
readyAsObservable(): Rx.Observable<any>;
|
||||
animateAsObservable(properties: any, duration: number, easing?: string): Rx.Observable<any>;
|
||||
fadeInAsObservable(duration: number, easing?: string): Rx.Observable<any>;
|
||||
fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.Observable<any>;
|
||||
fadeOutAsObservable(duration: number, easing?: string): Rx.Observable<any>;
|
||||
fadeToggleAsObservable(duration: number, easing?: string): Rx.Observable<any>;
|
||||
slideDownAsObservable(duration: number): Rx.Observable<any>;
|
||||
slideUpAsObservable(duration: number): Rx.Observable<any>;
|
||||
slideToggleAsObservable(duration: number): Rx.Observable<any>;
|
||||
toggleAsObservable(duration: number): Rx.Observable<any>;
|
||||
}
|
||||
Vendored
+44
-44
@@ -11,61 +11,61 @@
|
||||
|
||||
declare module Rx {
|
||||
|
||||
interface ITimeInterval {
|
||||
value: any;
|
||||
export interface TimeInterval<T> {
|
||||
value: T;
|
||||
interval: number;
|
||||
}
|
||||
|
||||
interface ITimestamp {
|
||||
value: any;
|
||||
interval: number;
|
||||
export interface Timestamp<T> {
|
||||
value: T;
|
||||
timestamp: number;
|
||||
}
|
||||
|
||||
interface IObservable<T> {
|
||||
ifThen(condition: () => boolean, thenSource: IObservable<T>): IObservable<T>;
|
||||
ifThen(condition: () => boolean, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
|
||||
ifThen(condition: () => boolean, thenSource: IObservable<T>, scheduler: IScheduler): IObservable<T>;
|
||||
export interface Observable<T> {
|
||||
ifThen(condition: () => boolean, thenSource: Observable<T>): Observable<T>;
|
||||
ifThen(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
|
||||
ifThen(condition: () => boolean, thenSource: Observable<T>, scheduler: IScheduler): Observable<T>;
|
||||
|
||||
delay(dueTime: number, scheduler?: IScheduler): IObservable<T>;
|
||||
throttle(dueTime: number, scheduler?: IScheduler): IObservable<T>;
|
||||
windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable<T>;
|
||||
windowWithTime(timeSpan: number, scheduler?: IScheduler): IObservable<T>;
|
||||
windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable<T>;
|
||||
bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable<T>;
|
||||
bufferWithTime(timeSpan: number, scheduler?: IScheduler): IObservable<T>;
|
||||
bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable<T>;
|
||||
timeInterval(scheduler?: IScheduler): IObservable<ITimeInterval>;
|
||||
timestamp(scheduler?: IScheduler): IObservable<ITimestamp>;
|
||||
sample(interval: number, scheduler?: IScheduler): IObservable<T>;
|
||||
sample<TSample>(sampler: IObservable<TSample>, scheduler?: IScheduler): IObservable<T>;
|
||||
timeout(dueTime: Date, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
|
||||
timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
|
||||
delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
|
||||
throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
|
||||
windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<T>;
|
||||
windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable<T>;
|
||||
windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<T>;
|
||||
bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<T>;
|
||||
bufferWithTime(timeSpan: number, scheduler?: IScheduler): Observable<T>;
|
||||
bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<T>;
|
||||
timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
|
||||
timestamp(scheduler?: IScheduler): Observable<Timestamp<T>>;
|
||||
sample(interval: number, scheduler?: IScheduler): Observable<T>;
|
||||
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): IObservable<T>;
|
||||
delayWithSelector(delayDurationSelector: (item: T) => number): IObservable<T>;
|
||||
delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): IObservable<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: IObservable<TTimeout>, timeoutdurationSelector?: (item: T) => IObservable<TTimeout>, other?: IObservable<T>): IObservable<T>;
|
||||
throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => IObservable<TTimeout>): IObservable<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): IObservable<T>;
|
||||
takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
|
||||
skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
|
||||
takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
|
||||
|
||||
takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<T[]>;
|
||||
takeWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
|
||||
skipWithTime(duration: number, scheduler?: IScheduler): IObservable<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): IObservable<T>;
|
||||
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): IObservable<T>;
|
||||
skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
|
||||
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
|
||||
}
|
||||
|
||||
interface Observable {
|
||||
interval(period: number, scheduler?: IScheduler): IObservable<number>;
|
||||
interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable<number>;
|
||||
timer(dueTime: Date, period: number, scheduler: IScheduler): IObservable<number>;
|
||||
timer(dueTime: Date, scheduler: IScheduler): IObservable<number>;
|
||||
timer(dueTime: number, period: number, scheduler: IScheduler): IObservable<number>;
|
||||
timer(dueTime: number, scheduler: IScheduler): IObservable<number>;
|
||||
interface ObservableStatic {
|
||||
interval(period: number, scheduler?: IScheduler): Observable<number>;
|
||||
interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
|
||||
timer(dueTime: Date, period: number, scheduler: IScheduler): Observable<number>;
|
||||
timer(dueTime: Date, scheduler: IScheduler): Observable<number>;
|
||||
timer(dueTime: number, period: number, scheduler: IScheduler): Observable<number>;
|
||||
timer(dueTime: number, scheduler: IScheduler): Observable<number>;
|
||||
|
||||
generateWithAbsoluteTime<TState, TResult>(
|
||||
initialState: TState,
|
||||
@@ -73,7 +73,7 @@ declare module Rx {
|
||||
iterate: (state: TState) => TState,
|
||||
resultSelector: (state: TState) => TResult,
|
||||
timeSelector: (state: TState) => Date,
|
||||
scheduler?: IScheduler): IObservable<TResult>;
|
||||
scheduler?: IScheduler): Observable<TResult>;
|
||||
|
||||
generateWithRelativeTime<TState, TResult>(
|
||||
initialState: TState,
|
||||
@@ -81,6 +81,6 @@ declare module Rx {
|
||||
iterate: (state: TState) => TState,
|
||||
resultSelector: (state: TState) => TResult,
|
||||
timeSelector: (state: TState) => number,
|
||||
scheduler?: IScheduler): IObservable<TResult>;
|
||||
scheduler?: IScheduler): Observable<TResult>;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user