Support for more RxJS packages + bool => boolean for TS0.9

rx.js/rx.js.aggregates.d.ts

@@ -1,19 +1,53 @@
 ///<reference path="rx.js.d.ts" />
 
-// Type definitions for RxJS "Aggregates"
+// Type definitions for RxJS-Aggregates package
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
+//
+// Dependencies:
+// -> rx.js
+// -> rx.aggregates.js
 
 declare module Rx {
 	interface IObservable<T> {
-		all(predicate?: (value: T) => bool): IObservable<bool>;
-		min(comparer?: (value1: T, value2: T) => number): IObservable<T>;
-		max(comparer?: (value1: T, value2: T) => number): IObservable<number>;
-		count(predicate?: (item: T) => bool): IObservable<number>;
+		aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
+		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
+
+		any(): IObservable<boolean>;
+		any(selector: (item: T) => boolean): IObservable<boolean>;
+
+		isEmpty(predicate?: (value: T) => boolean): IObservable<boolean>;
+		all(predicate?: (value: T) => boolean): IObservable<boolean>;
+		contains(value: T, comparer?: (value1: T, value2: T) => boolean): IObservable<boolean>;
+		count(predicate?: (item: T) => boolean): IObservable<number>;
 		sum(keySelector?: (item: T) => number): IObservable<number>;
-		isEmpty(predicate?: (value: T) => bool): IObservable<bool>;
-		contains(value: T, comparer?: (value1: T, value2: T) => bool): IObservable<bool>;
+		minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable<T>;
+		min(comparer?: (value1: T, value2: T) => number): IObservable<T>;
+		maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable<T>;
+		max(comparer?: (value1: T, value2: T) => number): IObservable<number>;
 		average(keySelector?: (item: T) => number): IObservable<number>;
+
+		sequenceEqual(second: IObservable<T>, comparer?: (value1: T, value2: T) => number): IObservable<T>;
+		elementAt(index: number): IObservable<T>;
+		elementAtOrDefault(index: number, defaultValue: T): IObservable<T>;
+
+		single(): IObservable<T>;
+		single(predicate: (T) => boolean): IObservable<T>;
+		singleOrDefault(): IObservable<T>;
+		singleOrDefault(predicate: (T) => boolean): IObservable<T>;
+		singleOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
+
+		first(): IObservable<T>;
+		first(predicate: (T) => boolean): IObservable<T>;
+		firstOrDefault(): IObservable<T>;
+		firstOrDefault(predicate: (T) => boolean): IObservable<T>;
+		firstOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
+
+		last(): IObservable<T>;
+		last(predicate: (T) => boolean): IObservable<T>;
+		lastOrDefault(): IObservable<T>;
+		lastOrDefault(predicate: (T) => boolean): IObservable<T>;
+		lastOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
 	}
 }

rx.js/rx.js.binding.d.ts

@@ -0,0 +1,42 @@
+///<reference path="rx.js.d.ts" />
+
+// Type definitions for RxJS-Binding package
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+//
+// Dependencies:
+// -> rx.js
+// -> rx.binding.js
+
+declare module Rx {
+
+	interface ReplaySubject<T> extends ISubject<T> {
+		new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+	}
+
+	interface BehaviorSubject<T> extends ISubject<T> {
+		new (initialValue: T): BehaviorSubject;
+	}
+
+	interface ConnectableObservable<T> extends IObservable<T>{
+		connect(): _IDisposable;
+		refCount(): IObservable<T>;
+	}
+
+	interface IObservable<T> {
+
+		publish(): ConnectableObservable<T>;
+		publish<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
+		publishLast(): ConnectableObservable<T>;
+		publishLast<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
+		publishValue(initialValue: T): ConnectableObservable<T>;
+		publishValue<TResult>(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable<TResult>;
+
+		replay(selector?: (source: IObservable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+	}
+
+
+	interface Observable {
+	}
+}

rx.js/rx.js.coincidence.d.ts

@@ -0,0 +1,40 @@
+///<reference path="rx.js.d.ts" />
+
+// Type definitions for RxJS-Coincidence package
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+//
+// Dependencies:
+// -> rx.js
+// -> rx.coincidence.js
+
+declare module Rx {
+
+	interface IObservable<T> {
+		join<T2, TDuration, T2Duration, TResult>(
+			right: IObservable<T2>,
+			leftDurationSelector: (leftItem: T) => IObservable<TDuration>,
+			rightDurationSelector: (rightItem: T2) => IObservable<T2Duration>,
+			resultSelector: (leftItem: T, rightItem: T2) => TResult): IObservable<TResult>;
+
+		groupJoin<T2, TDuration, T2Duration, TResult>(
+			right: IObservable<T2>,
+			leftDurationSelector: (leftItem: T) => IObservable<TDuration>,
+			rightDurationSelector: (rightItem: T2) => IObservable<T2Duration>,
+			resultSelector: (leftItem: T, rightItem: IObservable<T2>) => TResult): IObservable<TResult>;
+
+
+		// lack of documentation to complete the followings...
+
+		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
+			bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
+
+		window<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
+			bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
+	}
+
+
+	interface Observable {
+	}
+}

rx.js/rx.js.d.ts

@@ -314,6 +314,7 @@ declare module Rx {
 
 		observeOn(scheduler: IScheduler): IObservable<T>;
 		subscribeOn(scheduler: IScheduler): IObservable<T>;
+
 		amb(rightSource: IObservable<T>): IObservable<T>;
 		catchException(handler: (exception: any) =>IObservable<T>): IObservable<T>;
 		catchException(second: IObservable<T>): IObservable<T>;
@@ -369,16 +370,6 @@ declare module Rx {
 		take(count: number, scheduler?: IScheduler): IObservable<T>;
 		takeWhile(predicate: (value: T, index?: number) =>bool): IObservable<T>;
 		where(predicate: (value: T, index?: number) => bool): IObservable<T>;
-
-		// time
-		delay(dueTime: number, scheduler?: IScheduler): IObservable<T>;
-		throttle(dueTime: number, scheduler?: IScheduler): IObservable<T>;
-		windowWithTime(dueTime: number, timeShiftOrScheduler?: any, scheduler?: IScheduler): IObservable<T>;
-		timeInterval(scheduler: IScheduler): IObservable<T>;
-		sample(interval: number, scheduler?: IScheduler): IObservable<T>;
-		sample<TSample>(sampler: IObservable<TSample>, scheduler?: IScheduler): IObservable<T>;
-		timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
-		delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
 	}
 
 	interface Observable {
@@ -387,9 +378,9 @@ declare module Rx {
 		start<T>(func: () =>T, scheduler?: IScheduler, context?: any): IObservable<T>;
 		toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable<T>;
 		create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
-		create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
+		//create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
 		createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>_IDisposable): IObservable<T>;
-		defer<T>(observableFactory: () =>IObservable<T>): IObservable<T>;
+		defer<T>(observableFactory: () => IObservable<T>): IObservable<T>;
 		empty<T>(scheduler?: IScheduler): IObservable<T>;
 		fromArray<T>(array: T[], scheduler?: IScheduler): IObservable<T>;
 		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable<T>;

rx.js/rx.js.html.d.ts

@@ -1,8 +0,0 @@
-///<reference path="rx.js.d.ts"/>
-
-declare module Rx {
-	interface Observable {
-		fromEvent<TEvent>(element: HTMLElement, eventName: string): IObservable<TEvent>;
-		fromEvent<TEvent>(document: HTMLDocument, eventName: string): IObservable<TEvent>;
-	}
-}

rx.js/rx.js.joinpatterns.d.ts

@@ -0,0 +1,20 @@
+///<reference path="rx.js.d.ts" />
+
+// Type definitions for RxJS-Join package
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+//
+// Dependencies:
+// -> rx.js
+// -> rx.joinpatterns.js
+
+declare module Rx {
+
+	//interface IObservable<T> {
+	//}
+
+
+	//interface Observable {
+	//}
+}

rx.js/rx.js.jquery.d.ts

@@ -1,6 +1,15 @@
 ///<reference path="../jquery/jquery.d.ts"/>
 ///<reference path="rx.js.d.ts"/>
 
+// Those are the definitions for bridging Rx with jQuery.
+//
+// Using the https://github.com/Reactive-Extensions/rxjs-jquery project
+//
+// Dependencies:
+// -> rx.js
+// -> rx.jquery.js
+// -> jquery.js
+
 declare module JQueryResults {
 
 	export interface eventBase{
@@ -8,9 +17,9 @@ declare module JQueryResults {
 		cancelable: bool;
 		type: string;
 		preventDefault(): void;
-		isDefaultPrevented(): bool;
+		isDefaultPrevented(): boolean;
 		stopPropagation(): void;
-		isPropagationStopped(): bool;
+		isPropagationStopped(): boolean;
 		data: any;
 		originalEvent: any;
 		eventPhase: number;
@@ -19,11 +28,11 @@ declare module JQueryResults {
 	export interface keyEvent extends eventBase {
 		key: number;
 		keyCode: number;
-		altKey: bool;
-		ctrlKey: bool;
-		shiftKey: bool;
+		altKey: boolean;
+		ctrlKey: boolean;
+		shiftKey: boolean;
 		char: string;
-		metaKey: bool;
+		metaKey: boolean;
 	}
 
 	export interface uiEvent extends eventBase{

rx.js/rx.js.time.d.ts

@@ -1,13 +1,86 @@
 ///<reference path="rx.js.d.ts" />
 
+// Type definitions for RxJS "Aggregates"
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+//
+// Dependencies:
+// -> rx.js
+// -> rx.time.js
+
 declare module Rx {
+
+	interface ITimeInterval {
+		value: any;
+		interval: number;
+	}
+
+	interface ITimestamp {
+		value: any;
+		interval: number;
+	}
+
 	interface IObservable<T> {
 		ifThen(condition: () => bool, thenSource: IObservable<T>): IObservable<T>;
 		ifThen(condition: () => bool, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
 		ifThen(condition: () => bool, thenSource: IObservable<T>, scheduler: IScheduler): IObservable<T>;
+
+		delay(dueTime: number, scheduler?: IScheduler): IObservable<T>;
+		throttle(dueTime: number, scheduler?: IScheduler): IObservable<T>;
+		windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable<T>;
+		windowWithTime(timeSpan: number, scheduler?: IScheduler): IObservable<T>;
+		windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable<T>;
+		bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable<T>;
+		bufferWithTime(timeSpan: number, scheduler?: IScheduler): IObservable<T>;
+		bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable<T>;
+		timeInterval(scheduler?: IScheduler): IObservable<ITimeInterval>;
+		timestamp(scheduler?: IScheduler): IObservable<ITimestamp>;
+		sample(interval: number, scheduler?: IScheduler): IObservable<T>;
+		sample<TSample>(sampler: IObservable<TSample>, scheduler?: IScheduler): IObservable<T>;
+		timeout(dueTime: Date, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
+		timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
+
+		delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
+		delayWithSelector(delayDurationSelector: (T) => number): IObservable<T>;
+		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (T) => number): IObservable<T>;
+
+		timeoutWithSelector<TTimeout>(firstTimeout: IObservable<TTimeout>, timeoutdurationSelector?: (T) => IObservable<TTimeout>, other?: IObservable<T>): IObservable<T>;
+		throttleWithSelector<TTimeout>(throttleDurationSelector: (T) => IObservable<TTimeout>): IObservable<T>;
+
+		skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
+		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
+
+		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<Array>;
+		takeWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
+		skipWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
+
+		skipUntilWithTime(startTime: Date, scheduler?: IScheduler): IObservable<T>;
+		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): IObservable<T>;
 	}
+
 	interface Observable {
 		interval(period: number, scheduler?: IScheduler): IObservable<number>;
 		interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable<number>;
+		timer(dueTime: Date, period: number, scheduler: IScheduler): IObservable<number>;
+		timer(dueTime: Date, scheduler: IScheduler): IObservable<number>;
+		timer(dueTime: number, period: number, scheduler: IScheduler): IObservable<number>;
+		timer(dueTime: number, scheduler: IScheduler): IObservable<number>;
+
+		generateWithAbsoluteTime<TState, TResult>(
+			initialState: TState,
+			condition: (TState) => boolean,
+			iterate: (TState) => TState,
+			resultSelector: (TState) => TResult,
+			timeSelector: (TState) => Date,
+			scheduler?: IScheduler): IObservable<TResult>;
+
+		generateWithRelativeTime<TState, TResult>(
+			initialState: TState,
+			condition: (TState) => boolean,
+			iterate: (TState) => TState,
+			resultSelector: (TState) => TResult,
+			timeSelector: (TState) => number,
+			scheduler?: IScheduler): IObservable<TResult>;
 	}
 }