diff --git a/README.md b/README.md index 7e305efe3..800f6abf9 100755 --- a/README.md +++ b/README.md @@ -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/)) diff --git a/knockout.rx/knockout.rx.d.ts b/knockout.rx/knockout.rx.d.ts index 4f44153d8..e9c85a7f8 100644 --- a/knockout.rx/knockout.rx.d.ts +++ b/knockout.rx/knockout.rx.d.ts @@ -3,7 +3,7 @@ // Definitions by: Igor Oleinikov /// -/// +/// interface KnockoutSubscribableFunctions { toObservable(event?: string): Rx.IObservable; diff --git a/rx.js/rx.aggregates.d.ts b/rx.js/rx.aggregates.d.ts new file mode 100644 index 000000000..24ed13f1d --- /dev/null +++ b/rx.js/rx.aggregates.d.ts @@ -0,0 +1,55 @@ +/// + +// Type definitions for RxJS-Aggregates package +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export interface Observable { + aggregate(accumulator: (acc: T, value: T) => T): Observable; + aggregate(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable; + + reduce(accumulator: (acc: T, value: T) => T): Observable; + reduce(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable; // TS0.9.5: won't work https://typescript.codeplex.com/discussions/471751 + + any(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + some(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; // alias for any + + isEmpty(): Observable; + all(predicate?: (value: T) => boolean, thisArg?: any): Observable; + every(predicate?: (value: T) => boolean, thisArg?: any): Observable; // alias for all + contains(value: T): Observable; + contains(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable; + count(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + sum(keySelector?: (value: T, index: number, source: Observable) => number, thisArg?: any): Observable; + minBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable; + minBy(keySelector: (item: T) => number): Observable; + min(comparer?: (value1: T, value2: T) => number): Observable; + maxBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable; + maxBy(keySelector: (item: T) => number): Observable; + max(comparer?: (value1: T, value2: T) => number): Observable; + average(keySelector?: (value: T, index: number, source: Observable) => number, thisArg?: any): Observable; + + sequenceEqual(second: Observable, comparer: (value1: T, value2: TOther) => number): Observable; + sequenceEqual(second: Observable): Observable; + sequenceEqual(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable; + sequenceEqual(second: T[]): Observable; + + elementAt(index: number): Observable; + elementAtOrDefault(index: number, defaultValue?: T): Observable; + + single(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + singleOrDefault(predicate?: (value: T, index: number, source: Observable) => boolean, defaultValue?: T, thisArg?: any): Observable; + + first(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + firstOrDefault(predicate?: (value: T, index: number, source: Observable) => boolean, defaultValue?: T, thisArg?: any): Observable; + + last(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + lastOrDefault(predicate?: (value: T, index: number, source: Observable) => boolean, defaultValue?: T, thisArg?: any): Observable; + + find(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + findIndex(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + } +} diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts new file mode 100644 index 000000000..5ee13b89a --- /dev/null +++ b/rx.js/rx.async.d.ts @@ -0,0 +1,90 @@ +/// + +// Type definitions for RxJS-Async package 2.2 +// Project: http://rx.codeplex.com/ +// Definitions by: zoetrope +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + interface ObservableStatic { + start(func: () => T, scheduler?: IScheduler, context?: any): Observable; + + toAsync(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable; + toAsync(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + toAsync(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable; + toAsync(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + toAsync(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable; + toAsync(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable; + toAsync(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable; + toAsync(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable; + + fromCallback: { + // with single result callback without selector + (func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any callback with selector + (func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable; + (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; + // with any callback without selector + (func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any function with selector + (func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable; + // with any function without selector + (func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable; + }; + + fromNodeCallback: { + // with single result callback without selector + (func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (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; + // with any callback with selector + (func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable; + (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; + // with any callback without selector + (func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any function with selector + (func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable; + // with any function without selector + (func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable; + }; + + fromEvent(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable; + fromEvent(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable; + fromEventPattern(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable; + + fromPromise(promise: { then(onFulfill: (value: T) => any, onReject?: (reason: any) => any): any; }): Observable; + fromPromise(promise: any): Observable; + } +} diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts new file mode 100644 index 000000000..22624cc23 --- /dev/null +++ b/rx.js/rx.binding.d.ts @@ -0,0 +1,49 @@ +/// + +// Type definitions for RxJS-Binding package +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export interface BehaviorSubject extends Subject { + } + + interface BehaviorSubjectStatic { + new (initialValue: T): BehaviorSubject; + } + + export var BehaviorSubject: BehaviorSubjectStatic; + + export interface ReplaySubject extends Subject { + } + + interface ReplaySubjectStatic { + new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; + } + + export var ReplaySubject: ReplaySubjectStatic; + + interface ConnectableObservable extends Observable { + connect(): IDisposable; + refCount(): Observable; + } + + interface ConnectableObservableStatic { + new (): ConnectableObservable; + } + + export var ConnectableObservable: ConnectableObservableStatic; + + export interface Observable { + publish(): ConnectableObservable; + publish(selector: (item: T) => Observable): ConnectableObservable; + publishLast(): ConnectableObservable; + publishLast(selector: (item: T) => Observable): ConnectableObservable; + publishValue(initialValue: T): ConnectableObservable; + publishValue(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable; + + replay(selector?: (source: Observable) => ReplaySubject, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; + } +} diff --git a/rx.js/rx.coincidence.d.ts b/rx.js/rx.coincidence.d.ts new file mode 100644 index 000000000..2afa5cfe9 --- /dev/null +++ b/rx.js/rx.coincidence.d.ts @@ -0,0 +1,32 @@ +/// + +// Type definitions for RxJS-Coincidence package +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + + interface Observable { + join( + right: Observable, + leftDurationSelector: (leftItem: T) => Observable, + rightDurationSelector: (rightItem: TRight) => Observable, + resultSelector: (leftItem: T, rightItem: TRight) => TResult): Observable; + + groupJoin( + right: Observable, + leftDurationSelector: (leftItem: T) => Observable, + rightDurationSelector: (rightItem: TRight) => Observable, + resultSelector: (leftItem: T, rightItem: Observable) => TResult): Observable; + + window(windowOpenings: Observable): Observable>; + window(windowClosingSelector: () => Observable): Observable>; + window(windowOpenings: Observable, windowClosingSelector: () => Observable): Observable>; + + buffer(bufferOpenings: Observable): Observable; + buffer(bufferClosingSelector: () => Observable): Observable; + buffer(bufferOpenings: Observable, bufferClosingSelector: () => Observable): Observable; + } +} diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts new file mode 100644 index 000000000..f055452e3 --- /dev/null +++ b/rx.js/rx.d.ts @@ -0,0 +1,356 @@ +// Type definitions for RxJS +// Project: http://rx.codeplex.com/ +// Definitions by: gsino +// Revision by: Igor Oleinikov +// 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(xs: Observable, r: { getDisposable(): IDisposable; }): Observable; + + // Priority Queue for Scheduling + export class PriorityQueue { + constructor(capacity: number); + + length: number; + + isHigherPriority(left: number, right: number): boolean; + percolate(index: number): void; + heapify(index: number): void; + peek(): ScheduledItem; + removeAt(index: number): void; + dequeue(): ScheduledItem; + enqueue(item: ScheduledItem): void; + remove(item: ScheduledItem): boolean; + + static count: number; + } + + export class ScheduledItem { + 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): 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(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable; + scheduleWithAbsoluteAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable; + scheduleWithRelative(dueTime: number, action: () => void): IDisposable; + scheduleWithRelativeAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable; + + scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable; + scheduleRecursiveWithState(state: TState, action: (state: TState, action: (state: TState) =>void ) =>void ): IDisposable; + scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithAbsoluteAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable; + scheduleRecursiveWithRelativeAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable; + + schedulePeriodic(period: number, action: () => void): IDisposable; + schedulePeriodicWithState(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(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable; + scheduleWithAbsoluteAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleWithRelative(dueTime: number, action: () => void): IDisposable; + scheduleWithRelativeAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + + scheduleRecursive(action: (action: () => void) => void): IDisposable; + scheduleRecursiveWithState(state: TState, action: (state: TState, action: (state: TState) => void) => void): IDisposable; + scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithAbsoluteAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithRelativeAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable; + + schedulePeriodic(period: number, action: () => void): IDisposable; + schedulePeriodicWithState(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 { + accept(observer: Observer): void; + accept(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult; + toObservable(scheduler?: IScheduler): Observable; + hasValue: boolean; + equals(other: Notification): boolean; + kind: string; + value: T; + exception: any; + + static createOnNext(value: T): Notification; + static createOnError(exception: any): Notification; + static createOnCompleted(): Notification; + } + + // Observer + export class Observer { + onNext(value: T): void; + onError(exception: any): void; + onCompleted(): void; + + toNotifier(): (notification: Notification) =>void; + asObserver(): Observer; + checked(): Observer; + + static create(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer; + static fromNotifier(handler: (notification: Notification) => void): Observer; + } + + export interface Observable { + subscribe(observer: Observer): IDisposable; + subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable; + + toArray(): Observable; + + observeOn(scheduler: IScheduler): Observable; + subscribeOn(scheduler: IScheduler): Observable; + + amb(rightSource: Observable): Observable; + catch(handler: (exception: any) => Observable): Observable; + catchException(handler: (exception: any) => Observable): Observable; // alias for catch + catch(second: Observable): Observable; + catchException(second: Observable): Observable; // alias for catch + combineLatest(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; + combineLatest(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable; + combineLatest(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable; + combineLatest(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable; + combineLatest(souces: Observable[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable; + concat(...sources: Observable[]): Observable; + concat(sources: Observable[]): Observable; + concatAll(): T; + concatObservable(): T; // alias for concatAll + merge(maxConcurrent: number): Observable; + merge(other: Observable): Observable; + mergeAll(): T; + mergeObservable(): T; // alias for mergeAll + onErrorResumeNext(second: Observable): Observable; + skipUntil(other: Observable): Observable; + switchLatest(): T; + takeUntil(other: Observable): Observable; + zip(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; + zip(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable; + zip(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable; + zip(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable; + zip(second: Observable[], resultSelector: (left: T, right: Observable) => TResult): Observable; + asObservable(): Observable; + bufferWithCount(count: number, skip?: number): Observable; + dematerialize(): Observable; + distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable; + distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable; + do(observer: Observer): Observable; + doAction(observer: Observer): Observable; // alias for do + do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; + doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; // alias for do + finally(action: () => void): Observable; + finallyAction(action: () => void): Observable; // alias for finally + ignoreElements(): Observable; + materialize(): Observable>; + repeat(repeatCount?: number): Observable; + retry(retryCount?: number): Observable; + scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable; + scan(accumulator: (acc: T, value: T) => T): Observable; + skipLast(count: number): Observable; + startWith(...values: T[]): Observable; + startWith(scheduler: IScheduler, ...values: T[]): Observable; + takeLast(count: number, scheduler?: IScheduler): Observable; + takeLastBuffer(count: number): Observable; + windowWithCount(count: number, skip?: number): Observable>; + defaultIfEmpty(defaultValue?: T): Observable; + distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable; + distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable; + groupBy(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable>; + groupBy(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable>; + groupByUntil(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): Observable>; + groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): Observable>; + select(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; + map(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; // alias for select + selectMany(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; + selectMany(selector: (value: T) => Observable): Observable; + selectMany(other: Observable): Observable; + flatMap(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; // alias for selectMany + flatMap(selector: (value: T) => Observable): Observable; // alias for selectMany + flatMap(other: Observable): Observable; // alias for selectMany + skip(count: number): Observable; + skipWhile(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + take(count: number, scheduler?: IScheduler): Observable; + takeWhile(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + where(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + filter(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; // alias for where + } + + interface ObservableStatic { + create(subscribe: (observer: Observer) => void): Observable; + create(subscribe: (observer: Observer) => () => void): Observable; + createWithDisposable(subscribe: (observer: Observer) => IDisposable): Observable; + defer(observableFactory: () => Observable): Observable; + empty(scheduler?: IScheduler): Observable; + fromArray(array: T[], scheduler?: IScheduler): Observable; + fromArray(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable; + generate(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable; + never(): Observable; + range(start: number, count: number, scheduler?: IScheduler): Observable; + repeat(value: T, repeatCount?: number, scheduler?: IScheduler): Observable; + return(value: T, scheduler?: IScheduler): Observable; + returnValue(value: T, scheduler?: IScheduler): Observable; // alias for return + throw(exception: Error, scheduler?: IScheduler): Observable; + throw(exception: any, scheduler?: IScheduler): Observable; + throwException(exception: Error, scheduler?: IScheduler): Observable; // alias for throw + throwException(exception: any, scheduler?: IScheduler): Observable; // alias for throw + using(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable): Observable; + amb(...sources: Observable[]): Observable; + amb(sources: Observable[]): Observable; + catch(sources: Observable[]): Observable; + catchException(sources: Observable[]): Observable; // alias for catch + catch(...sources: Observable[]): Observable; + catchException(...sources: Observable[]): Observable; // alias for catch + concat(...sources: Observable[]): Observable; + concat(sources: Observable[]): Observable; + merge(...sources: Observable[]): Observable; + merge(sources: Observable[]): Observable; + merge(scheduler: IScheduler, ...sources: Observable[]): Observable; + merge(scheduler: IScheduler, sources: Observable[]): Observable; + onErrorResumeNext(...sources: Observable[]): Observable; + onErrorResumeNext(sources: Observable[]): Observable; + zip(first: Observable, sources: Observable[], resultSelector: (item1: T1, right: Observable) => TResult): Observable; + zip(source1: Observable, source2: Observable, resultSelector: (item1: T1, item2: T2) => TResult): Observable; + zip(source1: Observable, source2: Observable, source3: Observable, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable; + zip(source1: Observable, source2: Observable, source3: Observable, source4: Observable, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable; + zip(source1: Observable, source2: Observable, source3: Observable, source4: Observable, source5: Observable, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable; + zipArray(...sources: Observable[]): Observable; + zipArray(sources: Observable[]): Observable; + } + + export var Observable: ObservableStatic; + + interface GroupedObservable extends Observable { + key: TKey; + underlyingObservable: Observable; + } + + interface ISubject extends Observable, Observer, IDisposable { + hasObservers(): boolean; + } + + export interface Subject extends ISubject { + } + + interface SubjectStatic { + new (): Subject; + create(observer?: Observer, observable?: Observable): ISubject; + } + + export var Subject: SubjectStatic; + + export interface AsyncSubject extends Subject { + } + + interface AsyncSubjectStatic { + new (): AsyncSubject; + } + + export var AsyncSubject: AsyncSubjectStatic; +} diff --git a/rx.js/rx.js.experimental.d.ts b/rx.js/rx.experimental.d.ts similarity index 84% rename from rx.js/rx.js.experimental.d.ts rename to rx.js/rx.experimental.d.ts index a43788b87..db23df3fd 100644 --- a/rx.js/rx.js.experimental.d.ts +++ b/rx.js/rx.experimental.d.ts @@ -3,11 +3,11 @@ // Definitions by: Igor Oleinikov // Definitions: https://github.com/borisyankov/DefinitelyTyped -/// +/// declare module Rx { - interface IObservable { + interface Observable { /** * 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(selector: (source: IObservable) => IObservable): IObservable; + let(selector: (source: Observable) => Observable): Observable; /** * 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(selector: (source: IObservable) => IObservable): IObservable; + letBind(selector: (source: Observable) => Observable): Observable; /** * 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; + doWhile(condition: () => boolean): Observable; /** * 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, scheduler?: IScheduler): IObservable; + expand(selector: (item: T) => Observable, scheduler?: IScheduler): Observable; /** * 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(second: IObservable, resultSelector: (left: T, right: TSecond) => TResult): IObservable; + forkJoin(second: Observable, resultSelector: (left: T, right: TSecond) => TResult): Observable; /** * 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(selector: (item: IObservable, index: number, source: IObservable) => TResult, scheduler?: IScheduler): IObservable; + manySelect(selector: (item: Observable, index: number, source: Observable) => TResult, scheduler?: IScheduler): Observable; } - interface Observable { + interface ObservableStatic { /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, elseSource: IObservable): IObservable; + if(condition: () => boolean, thenSource: Observable, elseSource: Observable): Observable; /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, scheduler?: IScheduler): IObservable; + if(condition: () => boolean, thenSource: Observable, scheduler?: IScheduler): Observable; /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, elseSource: IObservable): IObservable; + ifThen(condition: () => boolean, thenSource: Observable, elseSource: Observable): Observable; /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, scheduler?: IScheduler): IObservable; + ifThen(condition: () => boolean, thenSource: Observable, scheduler?: IScheduler): Observable; /** * 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(sources: T[], resultSelector: (item: T) => IObservable): IObservable; + for(sources: T[], resultSelector: (item: T) => Observable): Observable; /** * 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(sources: T[], resultSelector: (item: T) => IObservable): IObservable; + forIn(sources: T[], resultSelector: (item: T) => Observable): Observable; /** * 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(condition: () => boolean, source: IObservable): IObservable; + while(condition: () => boolean, source: Observable): Observable; /** * 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(condition: () => boolean, source: IObservable): IObservable; + whileDo(condition: () => boolean, source: Observable): Observable; /** * 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(selector: () => string, sources: { [key: string]: IObservable; }, elseSource: IObservable): IObservable; + case(selector: () => string, sources: { [key: string]: Observable; }, elseSource: Observable): Observable; /** * 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(selector: () => string, sources: { [key: string]: IObservable; }, scheduler?: IScheduler): IObservable; + case(selector: () => string, sources: { [key: string]: Observable; }, scheduler?: IScheduler): Observable; /** * 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(selector: () => number, sources: { [key: number]: IObservable; }, elseSource: IObservable): IObservable; + case(selector: () => number, sources: { [key: number]: Observable; }, elseSource: Observable): Observable; /** * 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(selector: () => number, sources: { [key: number]: IObservable; }, scheduler?: IScheduler): IObservable; + case(selector: () => number, sources: { [key: number]: Observable; }, scheduler?: IScheduler): Observable; /** * 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(selector: () => string, sources: { [key: string]: IObservable; }, elseSource: IObservable): IObservable; + switchCase(selector: () => string, sources: { [key: string]: Observable; }, elseSource: Observable): Observable; /** * 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(selector: () => string, sources: { [key: string]: IObservable; }, scheduler?: IScheduler): IObservable; + switchCase(selector: () => string, sources: { [key: string]: Observable; }, scheduler?: IScheduler): Observable; /** * 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(selector: () => number, sources: { [key: number]: IObservable; }, elseSource: IObservable): IObservable; + switchCase(selector: () => number, sources: { [key: number]: Observable; }, elseSource: Observable): Observable; /** * 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(selector: () => number, sources: { [key: number]: IObservable; }, scheduler?: IScheduler): IObservable; + switchCase(selector: () => number, sources: { [key: number]: Observable; }, scheduler?: IScheduler): Observable; /** * 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(sources: IObservable[]): IObservable; + forkJoin(sources: Observable[]): Observable; /** * 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(...args: IObservable[]): IObservable; + forkJoin(...args: Observable[]): Observable; } } diff --git a/rx.js/rx.joinpatterns.d.ts b/rx.js/rx.joinpatterns.d.ts new file mode 100644 index 000000000..d23264f8e --- /dev/null +++ b/rx.js/rx.joinpatterns.d.ts @@ -0,0 +1,56 @@ +/// + +// Type definitions for RxJS-Join package +// Project: http://rx.codeplex.com/ +// Definitions by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + + interface Pattern1 { + and(other: Observable): Pattern2; + then(selector: (item1: T1) => TR): Plan; + } + interface Pattern2 { + and(other: Observable): Pattern3; + then(selector: (item1: T1, item2: T2) => TR): Plan; + } + interface Pattern3 { + and(other: Observable): Pattern4; + then(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan; + } + interface Pattern4 { + and(other: Observable): Pattern5; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan; + } + interface Pattern5 { + and(other: Observable): Pattern6; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan; + } + interface Pattern6 { + and(other: Observable): Pattern7; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan; + } + interface Pattern7 { + and(other: Observable): Pattern8; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan; + } + interface Pattern8 { + and(other: Observable): Pattern9; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan; + } + interface Pattern9 { + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan; + } + + interface Plan { } + + interface Observable { + and(other: Observable): Pattern2; + then(selector: (item1: T) => TR): Plan; + } + + interface ObservableStatic { + when(plan: Plan): Observable; + } +} diff --git a/rx.js/rx.jquery.d.ts b/rx.js/rx.jquery.d.ts new file mode 100644 index 000000000..fd9311ee4 --- /dev/null +++ b/rx.js/rx.jquery.d.ts @@ -0,0 +1,56 @@ +// Type definitions for bridging RxJS with jQuery. +// Project: https://github.com/Reactive-Extensions/RxJS-jQuery/ +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// +/// + +interface JQueryStatic { + ajaxAsObservable(settings: JQueryAjaxSettings): Rx.Observable; + getAsObservable(url: string, data: any, dataType: string): Rx.Observable; + getJSONAsObservable(url: string, data: any): Rx.Observable; + getScriptAsObservable(url: string, data: any): Rx.Observable; + postAsObservable(url: string, data: any, dataType: string): Rx.Observable; +} + +interface JQuery { + onAsObservable(events: string, selector?: string, eventData?: any): Rx.Observable; + bindAsObservable(eventType: string, eventData?: any): Rx.Observable; + delegateAsObservable(selector: string, eventType: string, eventData?: any): Rx.Observable; + //liveAsObservable(eventType: string, eventData?: any): Rx.Observable; // removed in jquery 1.9 + + changeAsObservable(eventData?: any): Rx.Observable; + clickAsObservable(eventData?: any): Rx.Observable; + dblclickAsObservable(eventData?: any): Rx.Observable; + focusAsObservable(eventData?: any): Rx.Observable; + focusinAsObservable(eventData?: any): Rx.Observable; + focusoutAsObservable(eventData?: any): Rx.Observable; + keydownAsObservable(eventData?: any): Rx.Observable; + keyupAsObservable(eventData?: any): Rx.Observable; + loadAsObservable(eventData?: any): Rx.Observable; + mousedownAsObservable(eventData?: any): Rx.Observable; + mouseenterAsObservable(eventData?: any): Rx.Observable; + mouseleaveAsObservable(eventData?: any): Rx.Observable; + mousemoveAsObservable(eventData?: any): Rx.Observable; + mouseoutAsObservable(eventData?: any): Rx.Observable; + mouseoverAsObservable(eventData?: any): Rx.Observable; + mouseupAsObservable(eventData?: any): Rx.Observable; + resizeAsObservable(eventData?: any): Rx.Observable; + scrollAsObservable(eventData?: any): Rx.Observable; + selectAsObservable(eventData?: any): Rx.Observable; + submitAsObservable(eventData?: any): Rx.Observable; + unloadAsObservable(eventData?: any): Rx.Observable; + hideAsObservable(duration: number): Rx.Observable; + showAsObservable(duration: number): Rx.Observable; + readyAsObservable(): Rx.Observable; + animateAsObservable(properties: any, duration: number, easing?: string): Rx.Observable; + fadeInAsObservable(duration: number, easing?: string): Rx.Observable; + fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.Observable; + fadeOutAsObservable(duration: number, easing?: string): Rx.Observable; + fadeToggleAsObservable(duration: number, easing?: string): Rx.Observable; + slideDownAsObservable(duration: number): Rx.Observable; + slideUpAsObservable(duration: number): Rx.Observable; + slideToggleAsObservable(duration: number): Rx.Observable; + toggleAsObservable(duration: number): Rx.Observable; +} diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts deleted file mode 100644 index 93a304db4..000000000 --- a/rx.js/rx.js.aggregates.d.ts +++ /dev/null @@ -1,53 +0,0 @@ -/// - -// Type definitions for RxJS-Aggregates package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.aggregates.js - -declare module Rx { - interface IObservable { - aggregate(accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - aggregate(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - - any(): IObservable; - any(selector: (item: T) => boolean): IObservable; - - isEmpty(predicate?: (value: T) => boolean): IObservable; - all(predicate?: (value: T) => boolean): IObservable; - contains(value: T, comparer?: (value1: T, value2: T) => boolean): IObservable; - count(predicate?: (item: T) => boolean): IObservable; - sum(keySelector?: (item: T) => number): IObservable; - minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable; - min(comparer?: (value1: T, value2: T) => number): IObservable; - maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable; - max(comparer?: (value1: T, value2: T) => number): IObservable; - average(keySelector?: (item: T) => number): IObservable; - - sequenceEqual(second: IObservable, comparer?: (value1: T, value2: T) => number): IObservable; - elementAt(index: number): IObservable; - elementAtOrDefault(index: number, defaultValue: T): IObservable; - - single(): IObservable; - single(predicate: (T) => boolean): IObservable; - singleOrDefault(): IObservable; - singleOrDefault(predicate: (T) => boolean): IObservable; - singleOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable; - - first(): IObservable; - first(predicate: (T) => boolean): IObservable; - firstOrDefault(): IObservable; - firstOrDefault(predicate: (T) => boolean): IObservable; - firstOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable; - - last(): IObservable; - last(predicate: (T) => boolean): IObservable; - lastOrDefault(): IObservable; - lastOrDefault(predicate: (T) => boolean): IObservable; - lastOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.aggregates.d.ts.tscparams b/rx.js/rx.js.aggregates.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.aggregates.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.js.async.d.ts deleted file mode 100644 index 98fb930f7..000000000 --- a/rx.js/rx.js.async.d.ts +++ /dev/null @@ -1,22 +0,0 @@ -/// - -// Type definitions for RxJS-Async package 2.2 -// Project: http://rx.codeplex.com/ -// Definitions by: zoetrope -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.async.js - -declare module Rx { - interface Observable { - start(func: () => T, scheduler?: IScheduler, context?: any): IObservable; - toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable; - fromCallback(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => IObservable; - fromNodeCallback(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => IObservable; - fromEvent(element: any, eventName: string, selector?: (...arguments: any[])=>T): IObservable; - fromEventPattern(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): IObservable; - fromPromise(promise: any): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.async.d.ts.tscparams b/rx.js/rx.js.async.d.ts.tscparams deleted file mode 100644 index 3cc762b55..000000000 --- a/rx.js/rx.js.async.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" \ No newline at end of file diff --git a/rx.js/rx.js.binding.d.ts b/rx.js/rx.js.binding.d.ts deleted file mode 100644 index b1f7c687a..000000000 --- a/rx.js/rx.js.binding.d.ts +++ /dev/null @@ -1,54 +0,0 @@ -/// - -// Type definitions for RxJS-Binding package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.binding.js - -declare module Rx { - - interface ReplaySubject extends ISubject { - new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; - } - - var ReplaySubject: { - new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; - } - - interface BehaviorSubject extends ISubject { - new (initialValue: T): BehaviorSubject; - } - - var BehaviorSubject: { - new (initialValue: T): BehaviorSubject; - } - - interface ConnectableObservable extends IObservable{ - connect(): _IDisposable; - refCount(): IObservable; - } - - var ConnectableObservable: { - new (): ConnectableObservable; - } - - interface IObservable { - - publish(): ConnectableObservable; - publish(selector: (item: T) => IObservable): ConnectableObservable; - publishLast(): ConnectableObservable; - publishLast(selector: (item: T) => IObservable): ConnectableObservable; - publishValue(initialValue: T): ConnectableObservable; - publishValue(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable; - - replay(selector?: (source: IObservable) => ReplaySubject, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; - } - - - interface Observable { - } -} diff --git a/rx.js/rx.js.binding.d.ts.tscparams b/rx.js/rx.js.binding.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.binding.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.coincidence.d.ts b/rx.js/rx.js.coincidence.d.ts deleted file mode 100644 index 138e99236..000000000 --- a/rx.js/rx.js.coincidence.d.ts +++ /dev/null @@ -1,40 +0,0 @@ -/// - -// Type definitions for RxJS-Coincidence package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.coincidence.js - -declare module Rx { - - interface IObservable { - join( - right: IObservable, - leftDurationSelector: (leftItem: T) => IObservable, - rightDurationSelector: (rightItem: T2) => IObservable, - resultSelector: (leftItem: T, rightItem: T2) => TResult): IObservable; - - groupJoin( - right: IObservable, - leftDurationSelector: (leftItem: T) => IObservable, - rightDurationSelector: (rightItem: T2) => IObservable, - resultSelector: (leftItem: T, rightItem: IObservable) => TResult): IObservable; - - - // lack of documentation to complete the followings... - - buffer(bufferOpenings: IObservable, - bufferClosingSelector: (opening: TBufferOpening) => IObservable): IObservable; - - window(bufferOpenings: IObservable, - bufferClosingSelector: (opening: TBufferOpening) => IObservable): IObservable; - } - - - interface Observable { - } -} diff --git a/rx.js/rx.js.coincidence.d.ts.tscparams b/rx.js/rx.js.coincidence.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.coincidence.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts deleted file mode 100644 index aeefce98f..000000000 --- a/rx.js/rx.js.d.ts +++ /dev/null @@ -1,433 +0,0 @@ -// Type definitions for RxJS -// Project: http://rx.codeplex.com/ -// Definitions by: 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(xs: IObservable, r: { getDisposable(): _IDisposable; }): IObservable; - } - - //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 { - accept(observer: IObserver): void; - accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void; - toObservable(scheduler?: IScheduler): IObservable; - hasValue: boolean; - equals(other: INotification): boolean; - kind: string; - value?: T; - exception?: any; - } - export interface Notification { - //abstract - //function new (): INotification; - - createOnNext(value: T): INotification;//ON - createOnError(exception): INotification;//OE - createOnCompleted(): INotification;//OC - } - - var Notification: Notification; - - export module Internals { - // Enumerator - interface IEnumerator { - moveNext(): boolean; - getCurrent(): T; - dispose(): void; - } - export interface Enumerator { - (moveNext: () =>boolean, getCurrent: () => T, dispose: () =>void ): IEnumerator; - - create(moveNext: () =>boolean, getCurrent: () => T, dispose?: () =>void ): IEnumerator; - } - - // Enumerable - interface IEnumerable { - getEnumerator(): IEnumerator; - - concat(): IObservable; - catchException(): IObservable; - } - export interface Enumerable { - (getEnumerator: () =>IEnumerator): IEnumerable; - - repeat(value: T, repeatCount?: number): IEnumerable; - forEach(source: T[], selector?: (element: T, index: number) => T2): IEnumerable; - forEach(source: { length: number; [index: number]: T; }, selector?: (element: T, index: number) => T2): IEnumerable; - } - } - - // Observer - interface IObserver { - onNext(value: T): void; - onError(exception: any): void; - onCompleted(): void; - - toNotifier(): (notification: INotification) =>void; - asObserver(): IObserver; - checked(): ICheckedObserver; - } - export module Observer { - //abstract - //function new (): IObserver; - - function create(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver; - function fromNotifier(handler: (notification: INotification) =>void ): IObserver; - } - - export module Internals { - // Abstract Observer - interface IAbstractObserver extends IObserver { - 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 { - constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void); - } - - interface ICheckedObserver extends IObserver { - _observer: IObserver; - _state: number; // 0 - idle, 1 - busy, 2 - done - checkAccess(): void; - } - - export module Internals { - interface IScheduledObserver extends IAbstractObserver { - scheduler: IScheduler; - observer: IObserver; - isAcquired: boolean; - hasFaulted: boolean; - //queue: { (value: any): void; (exception: any): void; (): void; }[]; - disposable: SerialDisposable; - - ensureActive(): void; - } - export interface ScheduledObserver { - (scheduler: IScheduler, observer: IObserver): IScheduledObserver; - } - } - - interface IObservable { - _subscribe: (observer: IObserver) =>_IDisposable; - - subscribe(observer: IObserver): _IDisposable; - - finalValue(): IObservable; - subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable; - toArray(): IObservable; - - observeOn(scheduler: IScheduler): IObservable; - subscribeOn(scheduler: IScheduler): IObservable; - - amb(rightSource: IObservable): IObservable; - catchException(handler: (exception: any) =>IObservable): IObservable; - catchException(second: IObservable): IObservable; - combineLatest(second: IObservable, resultSelector: (v1: T, v2: T2) =>TResult): IObservable; - combineLatest(second: IObservable, third: IObservable, resultSelector: (v1: T, v2: T2, v3: T3) =>TResult): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) =>TResult): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, fifth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) =>TResult): IObservable; - combineLatest(...soucesAndResultSelector: any[]): IObservable; - concat(...sources: IObservable[]): IObservable; - concat(sources: IObservable[]): IObservable; - //concatIObservable(): IObservable; - merge(maxConcurrent: number): IObservable; - merge(other: IObservable): IObservable; - //mergeIObservable(): IObservable; - onErrorResumeNext(second: IObservable): IObservable; - skipUntil(other: IObservable): IObservable; - switchLatest(): IObservable; - takeUntil(other: IObservable): IObservable; - zip(second: IObservable, resultSelector: (v1: T, v2: T2) =>TResult): IObservable; - zip(second: IObservable, third: IObservable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, fifth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): IObservable; - zip(...soucesAndResultSelector: any[]): IObservable; - zip(second: any[], resultSelector: (left: T, right: any) => TResult): IObservable; - asIObservable(): IObservable; - bufferWithCount(count: number, skip?: number): IObservable; - dematerialize(): IObservable; - distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>boolean): IObservable; - doAction(observer: IObserver): IObservable; - doAction(onNext: (value: T) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable; - finallyAction(action: () =>void): IObservable; - ignoreElements(): IObservable; - materialize(): IObservable>; // IObservable> not supported by TypeScript 0.9.0 !! - repeat(repeatCount?: number): IObservable; - retry(retryCount?: number): IObservable; - scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - scan(accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - skipLast(count: number): IObservable; - startWith(...values: T[]): IObservable; - startWith(scheduler: IScheduler, ...values: T[]): IObservable; - takeLast(count: number, scheduler?: IScheduler): IObservable; - takeLastBuffer(count: number): IObservable; - windowWithCount(count: number, skip?: number): IObservable; - defaultIfEmpty(defaultValue?: any): IObservable; - distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) =>string): IObservable; - groupBy(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): IGroupedObservable; - groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: IGroupedObservable) => IObservable, keySerializer?: (key: TKey) => string): IGroupedObservable; - select(selector: (value: T, index: number) =>T2): IObservable; - selectMany(selector: (value: T) =>IObservable, resultSelector?: (x: any, y: any) =>any): IObservable; - selectMany(other: IObservable): IObservable; - skip(count: number): IObservable; - skipWhile(predicate: (value: T, index?: number) =>boolean): IObservable; - take(count: number, scheduler?: IScheduler): IObservable; - takeWhile(predicate: (value: T, index?: number) =>boolean): IObservable; - where(predicate: (value: T, index?: number) => boolean): IObservable; - } - - interface Observable { - (subscribe: (observer: IObserver) =>_IDisposable): IObservable; - - create(subscribe: (observer: IObserver) => void ): IObservable; - //create(subscribe: (observer: IObserver) => () => void ): IObservable; - createWithDisposable(subscribe: (observer: IObserver) =>_IDisposable): IObservable; - defer(observableFactory: () => IObservable): IObservable; - empty(scheduler?: IScheduler): IObservable; - fromArray(array: T[], scheduler?: IScheduler): IObservable; - fromArray(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable; - generate(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): IObservable; - never(): IObservable; - range(start: number, count: number, scheduler?: IScheduler): IObservable; - repeat(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable; - returnValue(value: T, scheduler?: IScheduler): IObservable; - throwException(exception: any, scheduler?: IScheduler): IObservable; - using(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable): IObservable; - amb(...sources: IObservable[]): IObservable; - catchException(sources: IObservable[]): IObservable; - catchException(...sources: IObservable[]): IObservable; - concat(...sources: IObservable[]): IObservable; - concat(sources: IObservable[]): IObservable; - merge(...sources: IObservable[]): IObservable; - merge(sources: IObservable[]): IObservable; - merge(scheduler: IScheduler, ...sources: IObservable[]): IObservable; - merge(scheduler: IScheduler, sources: IObservable[]): IObservable; - onErrorResumeNext(...sources: IObservable[]): IObservable; - onErrorResumeNext(sources: IObservable[]): IObservable; - zip(...soucesAndResultSelector: any[]): IObservable; - } - - var Observable: Observable; - - export module Internals { - interface IAnonymousObservable extends IObservable { } - export interface AnonymousObservable { - (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable; - } - } - - interface IGroupedObservable extends IObservable { - key: TKey; - underlyingObservable: IObservable; - } - - interface ISubject extends IObservable, IObserver { - isDisposed: boolean; - isStopped: boolean; - //observers: IObserver[]; - - dispose(): void; - } - - export interface Subject extends ISubject { - create(observer?: IObserver, observable?: IObservable): ISubject; - } - - var Subject: { - new (): Subject; - } - - interface IAsyncSubject extends IObservable, IObserver { - isDisposed: boolean; - value: T; - hasValue: boolean; - observers: IObserver[]; - exception: any; - - dispose(): void; - } - export interface AsyncSubject { - (): IAsyncSubject; - } - - interface IAnonymousSubject extends IObservable { - onNext(value: T): void; - onError(exception: any): void; - onCompleted(): void; - } -} diff --git a/rx.js/rx.js.d.ts.tscparams b/rx.js/rx.js.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.experimental.d.ts.tscparams b/rx.js/rx.js.experimental.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.experimental.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.joinpatterns.d.ts b/rx.js/rx.js.joinpatterns.d.ts deleted file mode 100644 index a62b1914d..000000000 --- a/rx.js/rx.js.joinpatterns.d.ts +++ /dev/null @@ -1,20 +0,0 @@ -/// - -// Type definitions for RxJS-Join package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.joinpatterns.js - -declare module Rx { - - //interface IObservable { - //} - - - //interface Observable { - //} -} diff --git a/rx.js/rx.js.joinpatterns.d.ts.tscparams b/rx.js/rx.js.joinpatterns.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.joinpatterns.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.jquery.d.ts b/rx.js/rx.js.jquery.d.ts deleted file mode 100644 index bfd514631..000000000 --- a/rx.js/rx.js.jquery.d.ts +++ /dev/null @@ -1,99 +0,0 @@ -/// -/// - -// 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(settings: JQueryAjaxSettings): Rx.IObservable; - getAsObservable(url: string, data: any, dataType: string): Rx.IObservable; - getJSONAsObservable(url: string, data: any): Rx.IObservable; - getScriptAsObservable(url: string, data: any): Rx.IObservable; - postAsObservable(url: string, data: any, dataType: string): Rx.IObservable; -} - -interface JQuery { - changeAsObservable(eventData?: any): Rx.IObservable; - clickAsObservable(eventData?: any): Rx.IObservable; - dblclickAsObservable(eventData?: any): Rx.IObservable; - focusAsObservable(eventData?: any): Rx.IObservable; - focusinAsObservable(eventData?: any): Rx.IObservable; - focusoutAsObservable(eventData?: any): Rx.IObservable; - keydownAsObservable(eventData?: any): Rx.IObservable; - keyupAsObservable(eventData?: any): Rx.IObservable; - loadAsObservable(eventData?: any): Rx.IObservable; - mousedownAsObservable(eventData?: any): Rx.IObservable; - mouseenterAsObservable(eventData?: any): Rx.IObservable; - mouseleaveAsObservable(eventData?: any): Rx.IObservable; - mousemoveAsObservable(eventData?: any): Rx.IObservable; - mouseoutAsObservable(eventData?: any): Rx.IObservable; - mouseoverAsObservable(eventData?: any): Rx.IObservable; - mouseupAsObservable(eventData?: any): Rx.IObservable; - resizeAsObservable(eventData?: any): Rx.IObservable; - scrollAsObservable(eventData?: any): Rx.IObservable; - selectAsObservable(eventData?: any): Rx.IObservable; - submitAsObservable(eventData?: any): Rx.IObservable; - unloadAsObservable(eventData?: any): Rx.IObservable; - hideAsObservable(duration: number): Rx.IObservable; - showAsObservable(duration: number): Rx.IObservable; - readyAsObservable(): Rx.IObservable; - animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable; - fadeInAsObservable(duration: number, easing?: string): Rx.IObservable; - fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable; - fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable; - fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable; - slideDownAsObservable(duration: number): Rx.IObservable; - slideUpAsObservable(duration: number): Rx.IObservable; - slideToggleAsObservable(duration: number): Rx.IObservable; - toggleAsObservable(duration: number): Rx.IObservable; -} \ No newline at end of file diff --git a/rx.js/rx.js.jquery.d.ts.tscparams b/rx.js/rx.js.jquery.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.jquery.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts deleted file mode 100644 index e329a823c..000000000 --- a/rx.js/rx.js.time.d.ts +++ /dev/null @@ -1,86 +0,0 @@ -/// - -// Type definitions for RxJS "Aggregates" -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// 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 { - ifThen(condition: () => boolean, thenSource: IObservable): IObservable; - ifThen(condition: () => boolean, thenSource: IObservable, elseSource: IObservable): IObservable; - ifThen(condition: () => boolean, thenSource: IObservable, scheduler: IScheduler): IObservable; - - delay(dueTime: number, scheduler?: IScheduler): IObservable; - throttle(dueTime: number, scheduler?: IScheduler): IObservable; - windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable; - windowWithTime(timeSpan: number, scheduler?: IScheduler): IObservable; - windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable; - bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable; - bufferWithTime(timeSpan: number, scheduler?: IScheduler): IObservable; - bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable; - timeInterval(scheduler?: IScheduler): IObservable; - timestamp(scheduler?: IScheduler): IObservable; - sample(interval: number, scheduler?: IScheduler): IObservable; - sample(sampler: IObservable, scheduler?: IScheduler): IObservable; - timeout(dueTime: Date, other?: IObservable, scheduler?: IScheduler): IObservable; - timeout(dueTime: number, other?: IObservable, scheduler?: IScheduler): IObservable; - - delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable; - delayWithSelector(delayDurationSelector: (item: T) => number): IObservable; - delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): IObservable; - - timeoutWithSelector(firstTimeout: IObservable, timeoutdurationSelector?: (item: T) => IObservable, other?: IObservable): IObservable; - throttleWithSelector(throttleDurationSelector: (item: T) => IObservable): IObservable; - - skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable; - takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable; - - takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable; - takeWithTime(duration: number, scheduler?: IScheduler): IObservable; - skipWithTime(duration: number, scheduler?: IScheduler): IObservable; - - skipUntilWithTime(startTime: Date, scheduler?: IScheduler): IObservable; - takeUntilWithTime(endTime: Date, scheduler?: IScheduler): IObservable; - } - - interface Observable { - interval(period: number, scheduler?: IScheduler): IObservable; - interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable; - timer(dueTime: Date, period: number, scheduler: IScheduler): IObservable; - timer(dueTime: Date, scheduler: IScheduler): IObservable; - timer(dueTime: number, period: number, scheduler: IScheduler): IObservable; - timer(dueTime: number, scheduler: IScheduler): IObservable; - - generateWithAbsoluteTime( - initialState: TState, - condition: (state: TState) => boolean, - iterate: (state: TState) => TState, - resultSelector: (state: TState) => TResult, - timeSelector: (state: TState) => Date, - scheduler?: IScheduler): IObservable; - - generateWithRelativeTime( - initialState: TState, - condition: (state: TState) => boolean, - iterate: (state: TState) => TState, - resultSelector: (state: TState) => TResult, - timeSelector: (state: TState) => number, - scheduler?: IScheduler): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.time.d.ts.tscparams b/rx.js/rx.js.time.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.time.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.virtualtime.d.ts b/rx.js/rx.js.virtualtime.d.ts deleted file mode 100644 index 24d40e601..000000000 --- a/rx.js/rx.js.virtualtime.d.ts +++ /dev/null @@ -1,37 +0,0 @@ -/// - -// Type definitions for RxJS-VirtualTime package 2.2 -// Project: http://rx.codeplex.com/ -// Definitions by: 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; - //} -} \ No newline at end of file diff --git a/rx.js/rx.js.virtualtime.d.ts.tscparams b/rx.js/rx.js.virtualtime.d.ts.tscparams deleted file mode 100644 index 3cc762b55..000000000 --- a/rx.js/rx.js.virtualtime.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" \ No newline at end of file diff --git a/rx.js/rx.testing.d.ts b/rx.js/rx.testing.d.ts new file mode 100644 index 000000000..8a2dc35e5 --- /dev/null +++ b/rx.js/rx.testing.d.ts @@ -0,0 +1,53 @@ +/// +/// + +// Type definitions for RxJS-Testing +// Project: https://github.com/Reactive-Extensions/RxJS/ +// Definitions by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export class TestScheduler extends VirtualTimeScheduler { + constructor(); + + createColdObservable(...records: Recorded[]): Observable; + createHotObservable(...records: Recorded[]): Observable; + createObserver(): MockObserver; + + startWithTiming(create: () => Observable, createdAt: number, subscribedAt: number, disposedAt: number): MockObserver; + startWithDispose(create: () => Observable, disposedAt: number): MockObserver; + startWithCreate(create: () => Observable): MockObserver; + } + + 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 extends Observer { + constructor(scheduler: IScheduler); + messages: Recorded[]; + } +} diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts new file mode 100644 index 000000000..2d5f1d14f --- /dev/null +++ b/rx.js/rx.time.d.ts @@ -0,0 +1,83 @@ +/// + +// Type definitions for RxJS "Aggregates" +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + + export interface TimeInterval { + value: T; + interval: number; + } + + export interface Timestamp { + value: T; + timestamp: number; + } + + export interface Observable { + ifThen(condition: () => boolean, thenSource: Observable): Observable; + ifThen(condition: () => boolean, thenSource: Observable, elseSource: Observable): Observable; + ifThen(condition: () => boolean, thenSource: Observable, scheduler: IScheduler): Observable; + + delay(dueTime: number, scheduler?: IScheduler): Observable; + throttle(dueTime: number, scheduler?: IScheduler): Observable; + windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable; + windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable; + windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable; + bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable; + bufferWithTime(timeSpan: number, scheduler?: IScheduler): Observable; + bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable; + timeInterval(scheduler?: IScheduler): Observable>; + timestamp(scheduler?: IScheduler): Observable>; + sample(interval: number, scheduler?: IScheduler): Observable; + sample(sampler: Observable, scheduler?: IScheduler): Observable; + timeout(dueTime: Date, other?: Observable, scheduler?: IScheduler): Observable; + timeout(dueTime: number, other?: Observable, scheduler?: IScheduler): Observable; + + delaySubscription(dueTime: number, scheduler?: IScheduler): Observable; + delayWithSelector(delayDurationSelector: (item: T) => number): Observable; + delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable; + + timeoutWithSelector(firstTimeout: Observable, timeoutdurationSelector?: (item: T) => Observable, other?: Observable): Observable; + throttleWithSelector(throttleDurationSelector: (item: T) => Observable): Observable; + + skipLastWithTime(duration: number, scheduler?: IScheduler): Observable; + takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable; + + takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable; + takeWithTime(duration: number, scheduler?: IScheduler): Observable; + skipWithTime(duration: number, scheduler?: IScheduler): Observable; + + skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable; + takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable; + } + + interface ObservableStatic { + interval(period: number, scheduler?: IScheduler): Observable; + interval(dutTime: number, period: number, scheduler?: IScheduler): Observable; + timer(dueTime: Date, period: number, scheduler: IScheduler): Observable; + timer(dueTime: Date, scheduler: IScheduler): Observable; + timer(dueTime: number, period: number, scheduler: IScheduler): Observable; + timer(dueTime: number, scheduler: IScheduler): Observable; + + generateWithAbsoluteTime( + initialState: TState, + condition: (state: TState) => boolean, + iterate: (state: TState) => TState, + resultSelector: (state: TState) => TResult, + timeSelector: (state: TState) => Date, + scheduler?: IScheduler): Observable; + + generateWithRelativeTime( + initialState: TState, + condition: (state: TState) => boolean, + iterate: (state: TState) => TState, + resultSelector: (state: TState) => TResult, + timeSelector: (state: TState) => number, + scheduler?: IScheduler): Observable; + } +} \ No newline at end of file diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts new file mode 100644 index 000000000..293343fda --- /dev/null +++ b/rx.js/rx.virtualtime.d.ts @@ -0,0 +1,36 @@ +/// + +// Type definitions for RxJS-VirtualTime package 2.2 +// Project: http://rx.codeplex.com/ +// Definitions by: gsino +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + // Virtual IScheduler + export /*abstract*/ class VirtualTimeScheduler 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(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleRelative(dueTime: TRelative, action: () => void): IDisposable; + scheduleRelativeWithState(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; + } + + export class HistoricalScheduler extends VirtualTimeScheduler { + constructor(initialClock: number, comparer: (first: number, second: number) => number); + } +}