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

Merge pull request #1455 from Igorbek/switch-0.9.5

Browse Source 
Updated rx.js project
This commit is contained in:
Masahiro Wakame
2013-12-17 18:31:16 -08:00
parent e257e479fd 7fcae51ab1
commit dcdc4408ee
32 changed files with 895 additions and 883 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+1 -1
View File
@@ -202,7 +202,7 @@ List of Definitions
* [Riot.js](https://github.com/moot/riotjs) (by [vvakame](https://github.com/vvakame))
* [Restify](https://github.com/mcavage/node-restify) (by [Bret Little](https://github.com/blittle))
* [Royalslider](http://dimsemenov.com/plugins/royal-slider/) (by [Christiaan Rakowski](https://github.com/csrakowski))
* [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino))
* [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino), [Igor Oleinikov](https://github.com/Igorbek), [Carl de Billy](http://carl.debilly.net/), [zoetrope](https://github.com/zoetrope))
* [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall))
* [Restangular](https://github.com/mgonto/restangular/) (by [Boris Yankov](https://github.com/borisyankov))
* [require.js](http://requirejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/))
knockout.rx/knockout.rx.d.ts
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
/// <reference path="../knockout/knockout.d.ts"/>
/// <reference path="../rx.js/rx.js.d.ts"/>
/// <reference path="../rx.js/rx.d.ts"/>
interface KnockoutSubscribableFunctions<T> {
toObservable(event?: string): Rx.IObservable<T>;
rx.js/rx.aggregates.d.ts
Vendored
+55
View File
@@ -0,0 +1,55 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS-Aggregates package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
export interface Observable<T> {
aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
reduce(accumulator: (acc: T, value: T) => T): Observable<T>;
reduce<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable<TAcc>; // TS0.9.5: won't work https://typescript.codeplex.com/discussions/471751
any(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
some(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>; // alias for any
isEmpty(): Observable<boolean>;
all(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;
every(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>; // alias for all
contains(value: T): Observable<boolean>;
contains<TOther>(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable<boolean>;
count(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
sum(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
minBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
minBy(keySelector: (item: T) => number): Observable<T>;
min(comparer?: (value1: T, value2: T) => number): Observable<T>;
maxBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
maxBy(keySelector: (item: T) => number): Observable<T>;
max(comparer?: (value1: T, value2: T) => number): Observable<number>;
average(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
sequenceEqual<TOther>(second: Observable<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
sequenceEqual(second: Observable<T>): Observable<boolean>;
sequenceEqual<TOther>(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
sequenceEqual(second: T[]): Observable<boolean>;
elementAt(index: number): Observable<T>;
elementAtOrDefault(index: number, defaultValue?: T): Observable<T>;
single(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
singleOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
first(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
firstOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
last(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
lastOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
find(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
findIndex(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
}
}
rx.js/rx.async.d.ts
Vendored
+90
View File
@@ -0,0 +1,90 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS-Async package 2.2
// Project: http://rx.codeplex.com/
// Definitions by: zoetrope <https://github.com/zoetrope>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
interface ObservableStatic {
start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;
toAsync<T1, TResult>(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable<TResult>;
toAsync<T1, T2, TResult>(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
toAsync<T1, T2, TResult>(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable<TResult>;
toAsync<T1, T2, TResult>(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable<TResult>;
toAsync<T1, T2, TResult>(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable<TResult>;
toAsync<T1, T2, TResult>(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
fromCallback: {
// with single result callback without selector
<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
// with any callback with selector
<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
// with any callback without selector
<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
// with any function with selector
<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
// with any function without selector
<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
};
fromNodeCallback: {
// with single result callback without selector
<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
// with any callback with selector
<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
// with any callback without selector
<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
// with any function with selector
<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
// with any function without selector
<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
};
fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
fromPromise<T>(promise: { then(onFulfill: (value: T) => any, onReject?: (reason: any) => any): any; }): Observable<T>;
fromPromise<T>(promise: any): Observable<T>;
}
}
rx.js/rx.binding.d.ts
Vendored
+49
View File
@@ -0,0 +1,49 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS-Binding package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
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>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
export var ReplaySubject: ReplaySubjectStatic;
interface ConnectableObservable<T> extends Observable<T> {
connect(): IDisposable;
refCount(): Observable<T>;
}
interface ConnectableObservableStatic {
new <T>(): ConnectableObservable<T>;
}
export var ConnectableObservable: ConnectableObservableStatic;
export interface Observable<T> {
publish(): ConnectableObservable<T>;
publish<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
publishLast(): ConnectableObservable<T>;
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: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
}
rx.js/rx.coincidence.d.ts
Vendored
+32
View File
@@ -0,0 +1,32 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS-Coincidence package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
interface Observable<T> {
join<TRight, TDurationLeft, TDurationRight, TResult>(
right: Observable<TRight>,
leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
resultSelector: (leftItem: T, rightItem: TRight) => TResult): Observable<TResult>;
groupJoin<TRight, TDurationLeft, TDurationRight, TResult>(
right: Observable<TRight>,
leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
resultSelector: (leftItem: T, rightItem: Observable<TRight>) => TResult): Observable<TResult>;
window<TWindowOpening>(windowOpenings: Observable<TWindowOpening>): Observable<Observable<T>>;
window<TWindowClosing>(windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
window<TWindowOpening, TWindowClosing>(windowOpenings: Observable<TWindowOpening>, windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
buffer<TBufferOpening>(bufferOpenings: Observable<TBufferOpening>): Observable<T[]>;
buffer<TBufferClosing>(bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>, bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
}
}
rx.js/rx.d.ts
Vendored
+356
View File
@@ -0,0 +1,356 @@
// Type definitions for RxJS
// Project: http://rx.codeplex.com/
// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
export module Internals {
function isEqual(left: any, right: any): boolean;
function inherits(child: Function, parent: Function): Function;
function addProperties(obj: Object, ...sourcces: Object[]): void;
function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
// Priority Queue for Scheduling
export class PriorityQueue<TTime> {
constructor(capacity: number);
length: number;
isHigherPriority(left: number, right: number): boolean;
percolate(index: number): void;
heapify(index: number): void;
peek(): ScheduledItem<TTime>;
removeAt(index: number): void;
dequeue(): ScheduledItem<TTime>;
enqueue(item: ScheduledItem<TTime>): void;
remove(item: ScheduledItem<TTime>): boolean;
static count: number;
}
export class ScheduledItem<TTime> {
constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
scheduler: IScheduler;
state: TTime;
action: (scheduler: IScheduler, state: any) => IDisposable;
dueTime: TTime;
comparer: (x: TTime, y: TTime) => number;
disposable: SingleAssignmentDisposable;
invoke(): void;
compareTo(other: ScheduledItem<TTime>): number;
isCancelled(): boolean;
invokeCore(): IDisposable;
}
}
export interface IDisposable {
dispose(): void;
}
export class CompositeDisposable implements IDisposable {
constructor (...disposables: IDisposable[]);
constructor (disposables: IDisposable[]);
isDisposed: boolean;
length: number;
dispose(): void;
add(item: IDisposable): void;
remove(item: IDisposable): boolean;
clear(): void;
contains(item: IDisposable): boolean;
toArray(): IDisposable[];
}
export class Disposable implements IDisposable {
constructor(action: () => void);
static create(action: () => void): IDisposable;
static empty: IDisposable;
dispose(): void;
}
// Single assignment
export class SingleAssignmentDisposable implements IDisposable {
constructor();
isDisposed: boolean;
current: IDisposable;
dispose(): void ;
getDisposable(): IDisposable;
setDisposable(value: IDisposable): void ;
}
// Multiple assignment disposable
export class SerialDisposable implements IDisposable {
constructor();
isDisposed: boolean;
dispose(): void;
getDisposable(): IDisposable;
setDisposable(value: IDisposable): void;
}
export class RefCountDisposable implements IDisposable {
constructor(disposable: IDisposable);
dispose(): void;
isDisposed: boolean;
getDisposable(): IDisposable;
}
export interface IScheduler {
now(): number;
catch(handler: (exception: any) => boolean): IScheduler;
catchException(handler: (exception: any) => boolean): IScheduler;
schedule(action: () => void): IDisposable;
scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
scheduleRecursive(action: (action: () =>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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
schedulePeriodic(period: number, action: () => void): IDisposable;
schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
}
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;
now(): number;
catch(handler: (exception: any) => boolean): IScheduler;
catchException(handler: (exception: any) => boolean): IScheduler;
schedule(action: () => void): IDisposable;
scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
scheduleRecursive(action: (action: () => 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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
schedulePeriodic(period: number, action: () => void): IDisposable;
schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
}
// Current Thread IScheduler
interface ICurrentThreadScheduler extends IScheduler {
scheduleRequired(): boolean;
ensureTrampoline(action: () =>IDisposable): IDisposable;
}
// Notifications
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: Notification<T>): boolean;
kind: string;
value: T;
exception: any;
static createOnNext<T>(value: T): Notification<T>;
static createOnError<T>(exception: any): Notification<T>;
static createOnCompleted<T>(): Notification<T>;
}
// Observer
export class Observer<T> {
onNext(value: T): void;
onError(exception: any): void;
onCompleted(): void;
toNotifier(): (notification: Notification<T>) =>void;
asObserver(): Observer<T>;
checked(): Observer<any>;
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 interface Observable<T> {
subscribe(observer: Observer<T>): IDisposable;
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>;
catch(handler: (exception: any) => Observable<T>): Observable<T>;
catchException(handler: (exception: any) => Observable<T>): Observable<T>; // alias for catch
catch(second: Observable<T>): Observable<T>;
catchException(second: Observable<T>): Observable<T>; // alias for catch
combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
combineLatest<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
concat(...sources: Observable<T>[]): Observable<T>;
concat(sources: Observable<T>[]): Observable<T>;
concatAll(): T;
concatObservable(): T; // alias for concatAll
merge(maxConcurrent: number): Observable<T>;
merge(other: Observable<T>): Observable<T>;
mergeAll(): T;
mergeObservable(): T; // alias for mergeAll
onErrorResumeNext(second: Observable<T>): Observable<T>;
skipUntil<T2>(other: Observable<T2>): Observable<T>;
switchLatest(): T;
takeUntil<T2>(other: Observable<T2>): Observable<T>;
zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
zip<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
zip<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
zip<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, right: Observable<TOther>) => TResult): Observable<TResult>;
asObservable(): Observable<T>;
bufferWithCount(count: number, skip?: number): Observable<T[]>;
dematerialize<TOrigin>(): Observable<TOrigin>;
distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
do(observer: Observer<T>): Observable<T>;
doAction(observer: Observer<T>): Observable<T>; // alias for do
do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>; // alias for do
finally(action: () => void): Observable<T>;
finallyAction(action: () => void): Observable<T>; // alias for finally
ignoreElements(): Observable<T>;
materialize(): Observable<Notification<T>>;
repeat(repeatCount?: number): Observable<T>;
retry(retryCount?: number): Observable<T>;
scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
scan(accumulator: (acc: T, value: T) => T): Observable<T>;
skipLast(count: number): Observable<T>;
startWith(...values: T[]): Observable<T>;
startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
takeLast(count: number, scheduler?: IScheduler): Observable<T>;
takeLastBuffer(count: number): Observable<T[]>;
windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
defaultIfEmpty(defaultValue?: T): Observable<T>;
distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>; // alias for select
selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>; // alias for selectMany
flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>; // alias for selectMany
flatMap<TResult>(other: Observable<TResult>): Observable<TResult>; // alias for selectMany
skip(count: number): Observable<T>;
skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
take(count: number, scheduler?: IScheduler): Observable<T>;
takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
}
interface ObservableStatic {
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>; // alias for return
throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>; // alias for throw
using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
amb<T>(...sources: Observable<T>[]): Observable<T>;
amb<T>(sources: Observable<T>[]): Observable<T>;
catch<T>(sources: Observable<T>[]): Observable<T>;
catchException<T>(sources: Observable<T>[]): Observable<T>; // alias for catch
catch<T>(...sources: Observable<T>[]): Observable<T>;
catchException<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
concat<T>(...sources: Observable<T>[]): Observable<T>;
concat<T>(sources: Observable<T>[]): Observable<T>;
merge<T>(...sources: Observable<T>[]): Observable<T>;
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<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<T2>) => TResult): Observable<TResult>;
zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, source5: Observable<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
zipArray<T>(...sources: Observable<T>[]): Observable<T[]>;
zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
}
export var Observable: ObservableStatic;
interface GroupedObservable<TKey, TElement> extends Observable<TElement> {
key: TKey;
underlyingObservable: Observable<TElement>;
}
interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
hasObservers(): boolean;
}
export interface Subject<T> extends ISubject<T> {
}
interface SubjectStatic {
new <T>(): Subject<T>;
create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
}
export var Subject: SubjectStatic;
export interface AsyncSubject<T> extends Subject<T> {
}
interface AsyncSubjectStatic {
new <T>(): AsyncSubject<T>;
}
export var AsyncSubject: AsyncSubjectStatic;
}
rx.js/rx.js.experimental.d.ts → rx.js/rx.experimental.d.ts
Vendored
+27 -27
View File
@@ -3,11 +3,11 @@
// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
/// <reference path="rx.js.d.ts"/>
/// <reference path="rx.d.ts"/>
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,10 +57,10 @@ 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 {
interface ObservableStatic {
/**
* Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
*
@@ -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[]>;
}
}
rx.js/rx.joinpatterns.d.ts
Vendored
+56
View File
@@ -0,0 +1,56 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS-Join package
// Project: http://rx.codeplex.com/
// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
interface Pattern1<T1> {
and<T2>(other: Observable<T2>): Pattern2<T1, T2>;
then<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>;
}
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>;
}
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>;
}
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>;
}
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>;
}
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>;
}
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>;
}
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>;
}
interface Plan<T> { }
interface Observable<T> {
and<T2>(other: Observable<T2>): Pattern2<T, T2>;
then<TR>(selector: (item1: T) => TR): Plan<TR>;
}
interface ObservableStatic {
when<TR>(plan: Plan<TR>): Observable<TR>;
}
}
rx.js/rx.jquery.d.ts
Vendored
+56
View File
@@ -0,0 +1,56 @@
// Type definitions for bridging RxJS with jQuery.
// Project: https://github.com/Reactive-Extensions/RxJS-jQuery/
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
///<reference path="../jquery/jquery.d.ts"/>
///<reference path="rx.d.ts"/>
interface JQueryStatic {
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 {
onAsObservable<T extends BaseJQueryEventObject>(events: string, selector?: string, eventData?: any): Rx.Observable<T>;
bindAsObservable<T extends BaseJQueryEventObject>(eventType: string, eventData?: any): Rx.Observable<T>;
delegateAsObservable<T extends BaseJQueryEventObject>(selector: string, eventType: string, eventData?: any): Rx.Observable<T>;
//liveAsObservable<T extends BaseJQueryEventObject>(eventType: string, eventData?: any): Rx.Observable<T>; // removed in jquery 1.9
changeAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
clickAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
dblclickAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
focusAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
focusinAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
focusoutAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
keydownAsObservable(eventData?: any): Rx.Observable<JQueryKeyEventObject>;
keyupAsObservable(eventData?: any): Rx.Observable<JQueryKeyEventObject>;
loadAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
mousedownAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
mouseenterAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
mouseleaveAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
mousemoveAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
mouseoutAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
mouseoverAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
mouseupAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
resizeAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
scrollAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
selectAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
submitAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
unloadAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
hideAsObservable(duration: number): Rx.Observable<BaseJQueryEventObject>;
showAsObservable(duration: number): Rx.Observable<BaseJQueryEventObject>;
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>;
}
rx.js/rx.js.aggregates.d.ts
Vendored
-53
View File
@@ -1,53 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS-Aggregates package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> 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>;
any(): IObservable<boolean>;
any(selector: (item: T) => boolean): IObservable<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>;
sequenceEqual(second: IObservable<T>, comparer?: (value1: T, value2: T) => number): IObservable<T>;
elementAt(index: number): IObservable<T>;
elementAtOrDefault(index: number, defaultValue: T): IObservable<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>;
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>;
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>;
}
}
rx.js/rx.js.aggregates.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.async.d.ts
Vendored
-22
View File
@@ -1,22 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS-Async package 2.2
// Project: http://rx.codeplex.com/
// Definitions by: zoetrope <https://github.com/zoetrope>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.async.js
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>;
}
}
rx.js/rx.js.async.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.binding.d.ts
Vendored
-54
View File
@@ -1,54 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS-Binding package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.binding.js
declare module Rx {
interface ReplaySubject<T> extends ISubject<T> {
new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
var ReplaySubject: {
new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
interface BehaviorSubject<T> extends ISubject<T> {
new (initialValue: T): BehaviorSubject<any>;
}
var BehaviorSubject: {
new <T>(initialValue: T): BehaviorSubject<T>;
}
interface ConnectableObservable<T> extends IObservable<T>{
connect(): _IDisposable;
refCount(): IObservable<T>;
}
var ConnectableObservable: {
new <T>(): ConnectableObservable<T>;
}
interface IObservable<T> {
publish(): ConnectableObservable<T>;
publish<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
publishLast(): ConnectableObservable<T>;
publishLast<TResult>(selector: (item: T) => IObservable<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>;
}
interface Observable {
}
}
rx.js/rx.js.binding.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.coincidence.d.ts
Vendored
-40
View File
@@ -1,40 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS-Coincidence package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.coincidence.js
declare module Rx {
interface IObservable<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>;
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>;
// lack of documentation to complete the followings...
buffer<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
window<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
}
interface Observable {
}
}
rx.js/rx.js.coincidence.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.d.ts
Vendored
-433
View File
@@ -1,433 +0,0 @@
// Type definitions for RxJS
// Project: http://rx.codeplex.com/
// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
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>;
}
//Collections
interface IIndexedItem {
id: number;
value: IScheduledItem;
compareTo(other: IIndexedItem): number;
}
// Priority Queue for Scheduling
interface IPriorityQueue {
items: IIndexedItem[];
length: number;
isHigherPriority(left: number, right: number): boolean;
percolate(index: number): void;
heapify(index: number): void;
peek(): IIndexedItem;
removeAt(index: number): void;
dequeue(): IIndexedItem;
enqueue(item: IIndexedItem): void;
remove(item: IIndexedItem): boolean;
}
interface _IDisposable {
dispose(): void;
}
export class CompositeDisposable {
constructor (...disposables: _IDisposable[]);
disposables: _IDisposable[];
isDisposed: boolean;
length: number;
dispose(): void;
add(item: _IDisposable): void;
remove(item: _IDisposable): boolean;
clear(): void;
contains(item: _IDisposable): boolean;
toArray(): _IDisposable[];
}
// Main disposable class
interface IDisposable {
isDisposed: boolean;
action: () =>void;
dispose(): void;
}
export interface Disposable {
new (action: () =>void ): IDisposable;
}
var Disposable: {
create(action: () => void): _IDisposable;
empty: _IDisposable;
}
// Single assignment
interface ISingleAssignmentDisposable {
isDisposed: boolean;
current: _IDisposable;
dispose(): void;
disposable(value?: _IDisposable): _IDisposable;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
}
export interface SingleAssignmentDisposable {
(): ISingleAssignmentDisposable;
}
// Multiple assignment disposable
export class SerialDisposable {
isDisposed: boolean;
current: _IDisposable;
dispose(): void;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
disposable(value?: _IDisposable): _IDisposable;
}
export class RefCountDisposable {
constructor(disposable: _IDisposable);
underlyingDisposable: _IDisposable;
isDisposed: boolean;
isPrimaryDisposed: boolean;
count: number;
dispose(): void;
getDisposable(): _IDisposable;
}
interface IScheduledItem {
scheduler: IScheduler;
state: any;
action: (scheduler: IScheduler, state) => _IDisposable;
dueTime: number;
comparer: (x: number, y: number) =>number;
disposable: ISingleAssignmentDisposable;
invoke(): void;
compareTo(other: IScheduledItem): number;
isCancelled(): boolean;
invokeCore(): _IDisposable;
}
interface IScheduler {
_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;
now(): number;
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
catchException(handler: (exception: any) =>boolean): ICatchScheduler;
schedulePeriodic(period: number, action: () =>void ): _IDisposable;
schedulePeriodicWithState(state: any, period: number, action: (state: any) =>any): _IDisposable;//returns {Disposable|SingleAssignmentDisposable}
schedule(action: () =>void ): _IDisposable;
scheduleWithRelative(dueTime: number, action: () =>void ): _IDisposable;
scheduleWithAbsolute(dueTime: number, action: () =>void ): _IDisposable;
scheduleRecursive(action: (action: () =>void ) =>void ): _IDisposable;
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>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;
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;
}
var Scheduler: {
//(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
// ): IScheduler;
now(): number;
normalize(timeSpan: number): number;
immediate: IScheduler;
currentThread: ICurrentScheduler;//IScheduler;
timeout: IScheduler;
}
// Current Thread IScheduler
interface ICurrentScheduler extends IScheduler {
scheduleRequired(): boolean;
ensureTrampoline(action: () =>_IDisposable): _IDisposable;
}
// CatchScheduler
interface ICatchScheduler extends IScheduler { }
// 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>;
hasValue: boolean;
equals(other: INotification<T>): boolean;
kind: string;
value?: T;
exception?: any;
}
export interface Notification {
//abstract
//function new (): INotification;
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>;
}
}
// Observer
interface IObserver<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;
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>;
}
export module Internals {
// Abstract Observer
interface IAbstractObserver<T> extends IObserver<T> {
isStopped: boolean;
dispose(): void;
next(value: T): void;
error(exception: any): void;
completed(): void;
fail(): boolean;
}
//export module AbstractObserver {
// //abstract
// function new (): IAbstractObserver;
//}
}
export class AnonymousObserver<T> {
constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void);
}
interface ICheckedObserver<T> extends IObserver<T> {
_observer: IObserver<T>;
_state: number; // 0 - idle, 1 - busy, 2 - done
checkAccess(): void;
}
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>;
returnValue<T>(value: T, 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> {
key: TKey;
underlyingObservable: IObservable<TElement>;
}
interface ISubject<T> extends IObservable<T>, IObserver<T> {
isDisposed: boolean;
isStopped: boolean;
//observers: IObserver<T>[];
dispose(): void;
}
export interface Subject<T> extends ISubject<T> {
create<T>(observer?: IObserver<T>, observable?: IObservable<T>): ISubject<T>;
}
var Subject: {
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>;
}
interface IAnonymousSubject<T> extends IObservable<T> {
onNext(value: T): void;
onError(exception: any): void;
onCompleted(): void;
}
}
rx.js/rx.js.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.experimental.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.joinpatterns.d.ts
Vendored
-20
View File
@@ -1,20 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS-Join package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.joinpatterns.js
declare module Rx {
//interface IObservable<T> {
//}
//interface Observable {
//}
}
rx.js/rx.js.joinpatterns.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.jquery.d.ts
Vendored
-99
View File
@@ -1,99 +0,0 @@
///<reference path="../jquery/jquery.d.ts"/>
///<reference path="rx.js.d.ts"/>
// Those are the definitions for bridging Rx with jQuery.
//
// Using the https://github.com/Reactive-Extensions/rxjs-jquery project
//
// Dependencies:
// -> rx.js
// -> rx.jquery.js
// -> jquery.js
declare module JQueryResults {
export interface eventBase{
bubbles: boolean;
cancelable: boolean;
type: string;
preventDefault(): void;
isDefaultPrevented(): boolean;
stopPropagation(): void;
isPropagationStopped(): boolean;
data: any;
originalEvent: any;
eventPhase: number;
}
export interface keyEvent extends eventBase {
key: number;
keyCode: number;
altKey: boolean;
ctrlKey: boolean;
shiftKey: boolean;
char: string;
metaKey: boolean;
}
export interface uiEvent extends eventBase{
target: any;
currentTarget: any;
}
export interface mouseEvent extends keyEvent{
clientX: number;
clientY: number;
screenX: number;
screenY: number;
offsetX: number;
offsetY: number;
pageX: number;
pageY: number;
which: number;
}
}
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>;
}
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>;
}
rx.js/rx.js.jquery.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.time.d.ts
Vendored
-86
View File
@@ -1,86 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS "Aggregates"
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.time.js
declare module Rx {
interface ITimeInterval {
value: any;
interval: number;
}
interface ITimestamp {
value: any;
interval: 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>;
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>;
delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
delayWithSelector(delayDurationSelector: (item: T) => number): IObservable<T>;
delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): IObservable<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>;
skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<T[]>;
takeWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
skipWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
skipUntilWithTime(startTime: Date, scheduler?: IScheduler): IObservable<T>;
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): IObservable<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>;
generateWithAbsoluteTime<TState, TResult>(
initialState: TState,
condition: (state: TState) => boolean,
iterate: (state: TState) => TState,
resultSelector: (state: TState) => TResult,
timeSelector: (state: TState) => Date,
scheduler?: IScheduler): IObservable<TResult>;
generateWithRelativeTime<TState, TResult>(
initialState: TState,
condition: (state: TState) => boolean,
iterate: (state: TState) => TState,
resultSelector: (state: TState) => TResult,
timeSelector: (state: TState) => number,
scheduler?: IScheduler): IObservable<TResult>;
}
}
rx.js/rx.js.time.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.js.virtualtime.d.ts
Vendored
-37
View File
@@ -1,37 +0,0 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS-VirtualTime package 2.2
// Project: http://rx.codeplex.com/
// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.virtualtime.js
declare module Rx {
// Virtual IScheduler
interface IVirtualTimeScheduler extends IScheduler {
toRelative(duetime): number;
toDateTimeOffset(duetime: number): number;
clock: number;
comparer: (x: number, y: number) =>number;
isEnabled: boolean;
queue: IPriorityQueue;
scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleRelative(dueTime: number, action: () =>void ): _IDisposable;
start(): _IDisposable;
stop(): void;
advanceTo(time: number);
advanceBy(time: number);
sleep(time: number);
getNext(): IScheduledItem;
scheduleAbsolute(dueTime: number, action: () =>void );
scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
}
//export module VirtualTimeScheduler {
// //absract
// function new (initialClock: number, comparer: (x: number, y: number) =>number): IVirtualTimeScheduler;
//}
}
rx.js/rx.js.virtualtime.d.ts.tscparams
-1
View File
@@ -1 +0,0 @@
""
rx.js/rx.testing.d.ts
Vendored
+53
View File
@@ -0,0 +1,53 @@
///<reference path="rx.d.ts" />
///<reference path="rx.virtualtime.d.ts" />
// Type definitions for RxJS-Testing
// Project: https://github.com/Reactive-Extensions/RxJS/
// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
export class TestScheduler extends VirtualTimeScheduler<number, number> {
constructor();
createColdObservable<T>(...records: Recorded[]): Observable<T>;
createHotObservable<T>(...records: Recorded[]): Observable<T>;
createObserver<T>(): MockObserver<T>;
startWithTiming<T>(create: () => Observable<T>, createdAt: number, subscribedAt: number, disposedAt: number): MockObserver<T>;
startWithDispose<T>(create: () => Observable<T>, disposedAt: number): MockObserver<T>;
startWithCreate<T>(create: () => Observable<T>): MockObserver<T>;
}
export class Recorded {
constructor(time: number, value: any, equalityComparer?: (x: any, y: any) => boolean);
equals(other: Recorded): boolean;
toString(): string;
time: number;
value: any;
}
export var ReactiveTest: {
created: number;
subscribed: number;
disposed: number;
onNext(ticks: number, value: any): Recorded;
onNext(ticks: number, predicate: (value: any) => boolean): Recorded;
onError(ticks: number, exception: any): Recorded;
onError(ticks: number, predicate: (exception: any) => boolean): Recorded;
onCompleted(ticks: number): Recorded;
subscribe(subscribeAt: number, unsubscribeAt?: number): Subscription;
};
export class Subscription {
constructor(subscribeAt: number, unsubscribeAt?: number);
equals(other: Subscription): boolean;
}
export class MockObserver<T> extends Observer<T> {
constructor(scheduler: IScheduler);
messages: Recorded[];
}
}
rx.js/rx.time.d.ts
Vendored
+83
View File
@@ -0,0 +1,83 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS "Aggregates"
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
export interface TimeInterval<T> {
value: T;
interval: number;
}
export interface Timestamp<T> {
value: T;
timestamp: number;
}
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): 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): 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>;
takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
}
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,
condition: (state: TState) => boolean,
iterate: (state: TState) => TState,
resultSelector: (state: TState) => TResult,
timeSelector: (state: TState) => Date,
scheduler?: IScheduler): Observable<TResult>;
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.js/rx.virtualtime.d.ts
Vendored
+36
View File
@@ -0,0 +1,36 @@
///<reference path="rx.d.ts" />
// Type definitions for RxJS-VirtualTime package 2.2
// Project: http://rx.codeplex.com/
// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
// Virtual IScheduler
export /*abstract*/ class VirtualTimeScheduler<TAbsolute, TRelative> extends Scheduler {
constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number);
advanceBy(time: TRelative): void;
advanceTo(time: TAbsolute): void;
scheduleAbsolute(dueTime: TAbsolute, action: () => void): IDisposable;
scheduleAbsoluteWithState<TState>(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
scheduleRelativeWithState<TState>(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
sleep(time: TRelative): void;
start(): IDisposable;
stop(): void;
isEnabled: boolean;
/* protected abstract */ add(from: TAbsolute, by: TRelative): TAbsolute;
/* protected abstract */ toDateTimeOffset(duetime: TAbsolute): number;
/* protected abstract */ toRelative(duetime: number): TRelative;
/* protected */ getNext(): Internals.ScheduledItem<TAbsolute>;
}
export class HistoricalScheduler extends VirtualTimeScheduler<number, number> {
constructor(initialClock: number, comparer: (first: number, second: number) => number);
}
}