From f83fb6805bc1630792f7503f3ec4b56565e7049d Mon Sep 17 00:00:00 2001 From: Carl de Billy Date: Fri, 5 Jul 2013 01:03:30 -0400 Subject: [PATCH] Support for more RxJS packages + bool => boolean for TS0.9 --- rx.js/rx.js.aggregates.d.ts | 48 +++++++++++++++++++---- rx.js/rx.js.binding.d.ts | 42 ++++++++++++++++++++ rx.js/rx.js.coincidence.d.ts | 40 +++++++++++++++++++ rx.js/rx.js.d.ts | 15 ++----- rx.js/rx.js.html.d.ts | 8 ---- rx.js/rx.js.joinpatterns.d.ts | 20 ++++++++++ rx.js/rx.js.jquery.d.ts | 21 +++++++--- rx.js/rx.js.time.d.ts | 73 +++++++++++++++++++++++++++++++++++ 8 files changed, 234 insertions(+), 33 deletions(-) create mode 100644 rx.js/rx.js.binding.d.ts create mode 100644 rx.js/rx.js.coincidence.d.ts delete mode 100644 rx.js/rx.js.html.d.ts create mode 100644 rx.js/rx.js.joinpatterns.d.ts diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts index 16426a96e4..93a304db4f 100644 --- a/rx.js/rx.js.aggregates.d.ts +++ b/rx.js/rx.js.aggregates.d.ts @@ -1,19 +1,53 @@ /// -// Type definitions for RxJS "Aggregates" +// 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 { - all(predicate?: (value: T) => bool): IObservable; - min(comparer?: (value1: T, value2: T) => number): IObservable; - max(comparer?: (value1: T, value2: T) => number): IObservable; - count(predicate?: (item: T) => bool): 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; - isEmpty(predicate?: (value: T) => bool): IObservable; - contains(value: T, comparer?: (value1: T, value2: T) => bool): 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.binding.d.ts b/rx.js/rx.js.binding.d.ts new file mode 100644 index 0000000000..e2d4bfd981 --- /dev/null +++ b/rx.js/rx.js.binding.d.ts @@ -0,0 +1,42 @@ +/// + +// 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; + } + + interface BehaviorSubject extends ISubject { + new (initialValue: T): BehaviorSubject; + } + + interface ConnectableObservable extends IObservable{ + connect(): _IDisposable; + refCount(): IObservable; + } + + 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.coincidence.d.ts b/rx.js/rx.js.coincidence.d.ts new file mode 100644 index 0000000000..138e992368 --- /dev/null +++ b/rx.js/rx.js.coincidence.d.ts @@ -0,0 +1,40 @@ +/// + +// 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.d.ts b/rx.js/rx.js.d.ts index 1cce070dcb..7426944316 100644 --- a/rx.js/rx.js.d.ts +++ b/rx.js/rx.js.d.ts @@ -314,6 +314,7 @@ declare module Rx { observeOn(scheduler: IScheduler): IObservable; subscribeOn(scheduler: IScheduler): IObservable; + amb(rightSource: IObservable): IObservable; catchException(handler: (exception: any) =>IObservable): IObservable; catchException(second: IObservable): IObservable; @@ -369,16 +370,6 @@ declare module Rx { take(count: number, scheduler?: IScheduler): IObservable; takeWhile(predicate: (value: T, index?: number) =>bool): IObservable; where(predicate: (value: T, index?: number) => bool): IObservable; - - // time - delay(dueTime: number, scheduler?: IScheduler): IObservable; - throttle(dueTime: number, scheduler?: IScheduler): IObservable; - windowWithTime(dueTime: number, timeShiftOrScheduler?: any, scheduler?: IScheduler): IObservable; - timeInterval(scheduler: IScheduler): IObservable; - sample(interval: number, scheduler?: IScheduler): IObservable; - sample(sampler: IObservable, scheduler?: IScheduler): IObservable; - timeout(dueTime: number, other?: IObservable, scheduler?: IScheduler): IObservable; - delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable; } interface Observable { @@ -387,9 +378,9 @@ declare module Rx { start(func: () =>T, scheduler?: IScheduler, context?: any): IObservable; toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable; create(subscribe: (observer: IObserver) => void ): IObservable; - create(subscribe: (observer: IObserver) => () => void ): IObservable; + //create(subscribe: (observer: IObserver) => () => void ): IObservable; createWithDisposable(subscribe: (observer: IObserver) =>_IDisposable): IObservable; - defer(observableFactory: () =>IObservable): 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; diff --git a/rx.js/rx.js.html.d.ts b/rx.js/rx.js.html.d.ts deleted file mode 100644 index e1dcf69dd5..0000000000 --- a/rx.js/rx.js.html.d.ts +++ /dev/null @@ -1,8 +0,0 @@ -/// - -declare module Rx { - interface Observable { - fromEvent(element: HTMLElement, eventName: string): IObservable; - fromEvent(document: HTMLDocument, eventName: string): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.joinpatterns.d.ts b/rx.js/rx.js.joinpatterns.d.ts new file mode 100644 index 0000000000..a62b1914de --- /dev/null +++ b/rx.js/rx.js.joinpatterns.d.ts @@ -0,0 +1,20 @@ +/// + +// 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.jquery.d.ts b/rx.js/rx.js.jquery.d.ts index 361040390b..2a0b29b270 100644 --- a/rx.js/rx.js.jquery.d.ts +++ b/rx.js/rx.js.jquery.d.ts @@ -1,6 +1,15 @@ /// /// +// 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{ diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts index fc12992558..698cc300c2 100644 --- a/rx.js/rx.js.time.d.ts +++ b/rx.js/rx.js.time.d.ts @@ -1,13 +1,86 @@ /// +// 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: () => bool, thenSource: IObservable): IObservable; ifThen(condition: () => bool, thenSource: IObservable, elseSource: IObservable): IObservable; ifThen(condition: () => bool, 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: (T) => number): IObservable; + delayWithSelector(subscriptionDelay: number, delayDurationSelector: (T) => number): IObservable; + + timeoutWithSelector(firstTimeout: IObservable, timeoutdurationSelector?: (T) => IObservable, other?: IObservable): IObservable; + throttleWithSelector(throttleDurationSelector: (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: (TState) => boolean, + iterate: (TState) => TState, + resultSelector: (TState) => TResult, + timeSelector: (TState) => Date, + scheduler?: IScheduler): IObservable; + + generateWithRelativeTime( + initialState: TState, + condition: (TState) => boolean, + iterate: (TState) => TState, + resultSelector: (TState) => TResult, + timeSelector: (TState) => number, + scheduler?: IScheduler): IObservable; } } \ No newline at end of file