From f90f624aefb0d9bff547a8b9c17bff6e61042e47 Mon Sep 17 00:00:00 2001 From: Carl de Billy Date: Mon, 1 Jul 2013 15:36:58 -0400 Subject: [PATCH 1/2] Fixed broken declarations of the upgrade to 0.9 --- rx.js/rx.js.aggregates.d.ts | 12 +- rx.js/rx.js.d.ts | 793 ++++++++++++++++++------------------ rx.js/rx.js.html.d.ts | 6 +- rx.js/rx.js.time.d.ts | 10 +- 4 files changed, 408 insertions(+), 413 deletions(-) diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts index 92ab49989..7c10866a6 100644 --- a/rx.js/rx.js.aggregates.d.ts +++ b/rx.js/rx.js.aggregates.d.ts @@ -6,11 +6,11 @@ /// declare module Rx { - export module Observable { - function all(predicate?: (any) => bool): IObservable; - function min(predicate?: (any) => bool): IObservable; - function max(predicate?: (any) => bool): IObservable; - function count(predicate?: (any) => bool): IObservable; - function sum(keySelector?: (any) => any): IObservable; + interface Observable { + all(predicate?: (any) => bool): IObservable; + min(predicate?: (any) => bool): IObservable; + max(predicate?: (any) => bool): IObservable; + count(predicate?: (any) => bool): IObservable; + sum(keySelector?: (any) => any): IObservable; } } \ No newline at end of file diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts index 481603a7c..543fb703d 100644 --- a/rx.js/rx.js.d.ts +++ b/rx.js/rx.js.d.ts @@ -5,462 +5,457 @@ 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; - } + 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; + //Collections + interface IIndexedItem { + id: number; + value: IScheduledItem; - compareTo(other: IIndexedItem): number; - } + compareTo(other: IIndexedItem): number; + } - // Priority Queue for Scheduling - interface IPriorityQueue { - items: IIndexedItem[]; - length: number; + // Priority Queue for Scheduling + interface IPriorityQueue { + items: IIndexedItem[]; + length: number; - isHigherPriority(left: number, right: number): bool; - percolate(index: number): void; - heapify(index: number): void; - peek(): IIndexedItem; - removeAt(index: number): void; - dequeue(): IIndexedItem; - enqueue(item: IIndexedItem): void; - remove(item: IIndexedItem): bool; - } + isHigherPriority(left: number, right: number): bool; + percolate(index: number): void; + heapify(index: number): void; + peek(): IIndexedItem; + removeAt(index: number): void; + dequeue(): IIndexedItem; + enqueue(item: IIndexedItem): void; + remove(item: IIndexedItem): bool; + } - interface _IDisposable { - dispose(): void; - } + interface _IDisposable { + dispose(): void; + } - interface ICompositeDisposable { - disposables: _IDisposable[]; - isDisposed: bool; - length: number; + export class CompositeDisposable { + constructor (...disposables: _IDisposable[]); - dispose(): void; - add(item: _IDisposable): void; - remove(item: _IDisposable): bool; - clear(): void; - contains(item: _IDisposable): bool; - toArray(): _IDisposable[]; - } - export interface CompositeDisposable { - (...disposables: _IDisposable[]): ICompositeDisposable; - } + disposables: _IDisposable[]; + isDisposed: bool; + length: number; - // Main disposable class - interface IDisposable { - isDisposed: bool; - action: () =>void; + dispose(): void; + add(item: _IDisposable): void; + remove(item: _IDisposable): bool; + clear(): void; + contains(item: _IDisposable): bool; + toArray(): _IDisposable[]; + } - dispose(): void; - } - export interface Disposable { - (action: () =>void ): IDisposable; + // Main disposable class + interface IDisposable { + isDisposed: bool; + action: () =>void; - create(action: () =>void ): _IDisposable; - empty: _IDisposable; - } + dispose(): void; + } + export interface Disposable { + (action: () =>void ): IDisposable; - // Single assignment - interface ISingleAssignmentDisposable { - isDisposed: bool; - current: _IDisposable; + create(action: () =>void ): _IDisposable; + empty: _IDisposable; + } - dispose(): void; - disposable(value?: _IDisposable): _IDisposable; - getDisposable(): _IDisposable; - setDisposable(value: _IDisposable): void; - } - export interface SingleAssignmentDisposable { - (): ISingleAssignmentDisposable; - } + // Single assignment + interface ISingleAssignmentDisposable { + isDisposed: bool; + current: _IDisposable; - // Multiple assignment disposable - interface ISerialDisposable { - isDisposed: bool; - current: _IDisposable; + dispose(): void; + disposable(value?: _IDisposable): _IDisposable; + getDisposable(): _IDisposable; + setDisposable(value: _IDisposable): void; + } + export interface SingleAssignmentDisposable { + (): ISingleAssignmentDisposable; + } - dispose(): void; - getDisposable(): _IDisposable; - setDisposable(value: _IDisposable): void; - disposable(value?: _IDisposable): _IDisposable; - } - export interface SerialDisposable { - (): ISerialDisposable; - } + // Multiple assignment disposable + export class SerialDisposable { + isDisposed: bool; + current: _IDisposable; - interface IRefCountDisposable { - underlyingDisposable: _IDisposable; - isDisposed: bool; - isPrimaryDisposed: bool; - count: number; + dispose(): void; + getDisposable(): _IDisposable; + setDisposable(value: _IDisposable): void; + disposable(value?: _IDisposable): _IDisposable; + } - dispose(): void; - getDisposable(): _IDisposable; - } - export interface RefCountDisposable { - (disposable: _IDisposable): IRefCountDisposable; - } + export class RefCountDisposable { + constructor(disposable: _IDisposable); - interface IScheduledItem { - scheduler: IScheduler; - state: any; - action: (scheduler: IScheduler, state) => _IDisposable; - dueTime: number; - comparer: (x: number, y: number) =>number; - disposable: ISingleAssignmentDisposable; + underlyingDisposable: _IDisposable; + isDisposed: bool; + isPrimaryDisposed: bool; + count: number; - invoke(): void; - compareTo(other: IScheduledItem): number; - isCancelled(): bool; - invokeCore(): _IDisposable; - } + dispose(): void; + getDisposable(): _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; + interface IScheduledItem { + scheduler: IScheduler; + state: any; + action: (scheduler: IScheduler, state) => _IDisposable; + dueTime: number; + comparer: (x: number, y: number) =>number; + disposable: ISingleAssignmentDisposable; - 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; + invoke(): void; + compareTo(other: IScheduledItem): number; + isCancelled(): bool; + invokeCore(): _IDisposable; + } - catchException(handler: (exception: any) =>bool): 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; - } - export interface 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; + 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; - normalize(timeSpan: number): number; + 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; - immediate: IScheduler; - currentThread: ICurrentScheduler;//IScheduler; - timeout: IScheduler; - } + catchException(handler: (exception: any) =>bool): 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; + } + export interface 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; - // Current Thread IScheduler - interface ICurrentScheduler extends IScheduler { - scheduleRequired(): bool; - ensureTrampoline(action: () =>_IDisposable): _IDisposable; - } + now(): number; + normalize(timeSpan: number): number; - // Virtual IScheduler - interface IVirtualTimeScheduler extends IScheduler { - toRelative(duetime): number; - toDateTimeOffset(duetime: number): number; + immediate: IScheduler; + currentThread: ICurrentScheduler;//IScheduler; + timeout: IScheduler; + } - clock: number; - comparer: (x: number, y: number) =>number; - isEnabled: bool; - 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; - //} + // Current Thread IScheduler + interface ICurrentScheduler extends IScheduler { + scheduleRequired(): bool; + ensureTrampoline(action: () =>_IDisposable): _IDisposable; + } + + // Virtual IScheduler + interface IVirtualTimeScheduler extends IScheduler { + toRelative(duetime): number; + toDateTimeOffset(duetime: number): number; + + clock: number; + comparer: (x: number, y: number) =>number; + isEnabled: bool; + 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; + //} - // CatchScheduler - interface ICatchScheduler extends IScheduler { } + // CatchScheduler + interface ICatchScheduler extends IScheduler { } - // Notifications - interface INotification { - accept(observer: IObserver): void; - accept(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void; - toObservable(scheduler?: IScheduler): IObservable; - hasValue: bool; - equals(other: INotification): bool; - kind: string; - value?: any; - exception?: any; - } - export interface Notification { - //abstract - //function new (): INotification; + // Notifications + interface INotification { + accept(observer: IObserver): void; + accept(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void; + toObservable(scheduler?: IScheduler): IObservable; + hasValue: bool; + equals(other: INotification): bool; + kind: string; + value?: any; + exception?: any; + } + export interface Notification { + //abstract + //function new (): INotification; - createOnNext(value: any): INotification;//ON - createOnError(exception): INotification;//OE - createOnCompleted(): INotification;//OC - } + createOnNext(value: any): INotification;//ON + createOnError(exception): INotification;//OE + createOnCompleted(): INotification;//OC + } - export module Internals { - // Enumerator - interface IEnumerator { - moveNext(): bool; - getCurrent(): any; - dispose(): void; - } - export interface Enumerator { - (moveNext: () =>bool, getCurrent: () => any, dispose: () =>void ): IEnumerator; + var Notification: Notification; - create(moveNext: () =>bool, getCurrent: () =>any, dispose?: () =>void ): IEnumerator; - } + export module Internals { + // Enumerator + interface IEnumerator { + moveNext(): bool; + getCurrent(): any; + dispose(): void; + } + export interface Enumerator { + (moveNext: () =>bool, getCurrent: () => any, dispose: () =>void ): IEnumerator; - // Enumerable - interface IEnumerable { - getEnumerator(): IEnumerator; + create(moveNext: () =>bool, getCurrent: () =>any, dispose?: () =>void ): IEnumerator; + } - concat(): IObservable; - catchException(): IObservable; - } - export interface Enumerable { - (getEnumerator: () =>IEnumerator): IEnumerable; + // Enumerable + interface IEnumerable { + getEnumerator(): IEnumerator; - repeat(value: any, repeatCount?: number): IEnumerable; - forEach(source: any[], selector?: (element: any, index: number) =>any): IEnumerable; - forEach(source: { length: number;[index: number]: any; }, selector?: (element: any, index: number) =>any): IEnumerable; - } - } + concat(): IObservable; + catchException(): IObservable; + } + export interface Enumerable { + (getEnumerator: () =>IEnumerator): IEnumerable; - // Observer - interface IObserver { - onNext(value: any): void; - onError(exception: any): void; - onCompleted(): void; + repeat(value: any, repeatCount?: number): IEnumerable; + forEach(source: any[], selector?: (element: any, index: number) =>any): IEnumerable; + forEach(source: { length: number;[index: number]: any; }, selector?: (element: any, index: number) =>any): IEnumerable; + } + } - toNotifier(): (notification: INotification) =>void; - asObserver(): IObserver; - checked(): ICheckedObserver; - } - export module Observer { - //abstract - //function new (): IObserver; + // Observer + interface IObserver { + onNext(value: any): void; + onError(exception: any): void; + onCompleted(): void; - function create(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver; - function fromNotifier(handler: (notification: INotification) =>void ): IObserver; - } + toNotifier(): (notification: INotification) =>void; + asObserver(): IObserver; + checked(): ICheckedObserver; + } + export module Observer { + //abstract + //function new (): IObserver; - export module Internals { - // Abstract Observer - interface IAbstractObserver extends IObserver { - isStopped: bool; + function create(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver; + function fromNotifier(handler: (notification: INotification) =>void ): IObserver; + } - dispose(): void; - next(value: any): void; - error(exception: any): void; - completed(): void; - fail(): bool; - } - //export module AbstractObserver { - // //abstract - // function new (): IAbstractObserver; - //} - } + export module Internals { + // Abstract Observer + interface IAbstractObserver extends IObserver { + isStopped: bool; - interface IAnonymousObserver extends Internals.IAbstractObserver { - _onNext: (value: any) =>void; - _onError: (exception: any) =>void; - _onCompleted: () =>void; - } - export interface AnonymousObserver { - (onNext: (value: any) =>void , onError: (exception: any) =>void , onCompleted: () =>void ): IAnonymousObserver; - } + dispose(): void; + next(value: any): void; + error(exception: any): void; + completed(): void; + fail(): bool; + } + //export module AbstractObserver { + // //abstract + // function new (): IAbstractObserver; + //} + } - interface ICheckedObserver extends IObserver { - _observer: IObserver; - _state: number; // 0 - idle, 1 - busy, 2 - done - checkAccess(): void; - } + export class AnonymousObserver { + constructor(onNext: (value: any) => void , onError: (exception: any) => void , onCompleted: () => void); + } - export module Internals { - interface IScheduledObserver extends IAbstractObserver { - scheduler: IScheduler; - observer: IObserver; - isAcquired: bool; - hasFaulted: bool; - //queue: { (value: any): void; (exception: any): void; (): void; }[]; - disposable: ISerialDisposable; + interface ICheckedObserver extends IObserver { + _observer: IObserver; + _state: number; // 0 - idle, 1 - busy, 2 - done + checkAccess(): void; + } - ensureActive(): void; - } - export interface ScheduledObserver { - (scheduler: IScheduler, observer: IObserver): IScheduledObserver; - } - } + export module Internals { + interface IScheduledObserver extends IAbstractObserver { + scheduler: IScheduler; + observer: IObserver; + isAcquired: bool; + hasFaulted: bool; + //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; + interface IObservable { + _subscribe: (observer: IObserver) =>_IDisposable; - subscribe(observer: IObserver): _IDisposable; + subscribe(observer: IObserver): _IDisposable; - finalValue(): IObservable; - subscribe(onNext?: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable; - toArray(): IObservable; + finalValue(): IObservable; + subscribe(onNext?: (value: any) =>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: any, v2: any) =>any): IObservable; - combineLatest(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): 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: any, v2: any) =>any): IObservable; - zip(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): IObservable; - zip(...soucesAndResultSelector: any[]): IObservable; - zip(second: any[], resultSelector: (left: any, right: any) =>any): IObservable; - asIObservable(): IObservable; - bufferWithCount(count: number, skip?: number): IObservable; - dematerialize(): IObservable; - distinctUntilChanged(keySelector?: (value: any) =>any, comparer?: (x: any, y: any) =>bool): IObservable; - doAction(observer: IObserver): IObservable; - doAction(onNext: (value: any) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable; - finallyAction(action: () =>void ): IObservable; - ignoreElements(): IObservable; - materialize(): IObservable; - repeat(repeatCount?: number): IObservable; - retry(retryCount?: number): IObservable; - scan(seed: any, accumulator: (acc: any, value: any) =>any): IObservable; - scan(accumulator: (acc: any, value: any) =>any): IObservable; - skipLast(count: number): IObservable; - startWith(...values: any[]): IObservable; - startWith(scheduler: IScheduler, ...values: any[]): IObservable; - takeLast(count: number, scheduler?: IScheduler): IObservable; - takeLastBuffer(count: number): IObservable; - windowWithCount(count: number, skip?: number): IObservable; - defaultIfEmpty(defaultValue?: any): IObservable; - distinct(keySelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IObservable; - groupBy(keySelector: (value: any) =>any, elementSelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IGroupedObservable; - groupByUntil(keySelector: (value: any) =>any, elementSelector: (value: any) =>any, durationSelector: (gloup: IGroupedObservable) =>IObservable, keySerializer?: (key: any) =>string): IGroupedObservable; - select(selector: (value: any, index: number) =>any): IObservable; - selectMany(selector: (value: any) =>IObservable, resultSelector?: (x: any, y: any) =>any): IObservable; - selectMany(other: IObservable): IObservable; - skip(count: number): IObservable; - skipWhile(predicate: (value: any, index?: number) =>bool): IObservable; - take(count: number, scheduler?: IScheduler): IObservable; - takeWhile(predicate: (value: any, index?: number) =>bool): IObservable; - where(predicate: (value: any, index?: number) => bool): 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: any, v2: any) =>any): IObservable; + combineLatest(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable; + combineLatest(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable; + combineLatest(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): 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: any, v2: any) =>any): IObservable; + zip(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable; + zip(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable; + zip(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): IObservable; + zip(...soucesAndResultSelector: any[]): IObservable; + zip(second: any[], resultSelector: (left: any, right: any) =>any): IObservable; + asIObservable(): IObservable; + bufferWithCount(count: number, skip?: number): IObservable; + dematerialize(): IObservable; + distinctUntilChanged(keySelector?: (value: any) =>any, comparer?: (x: any, y: any) =>bool): IObservable; + doAction(observer: IObserver): IObservable; + doAction(onNext: (value: any) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable; + finallyAction(action: () =>void ): IObservable; + ignoreElements(): IObservable; + materialize(): IObservable; + repeat(repeatCount?: number): IObservable; + retry(retryCount?: number): IObservable; + scan(seed: any, accumulator: (acc: any, value: any) =>any): IObservable; + scan(accumulator: (acc: any, value: any) =>any): IObservable; + skipLast(count: number): IObservable; + startWith(...values: any[]): IObservable; + startWith(scheduler: IScheduler, ...values: any[]): IObservable; + takeLast(count: number, scheduler?: IScheduler): IObservable; + takeLastBuffer(count: number): IObservable; + windowWithCount(count: number, skip?: number): IObservable; + defaultIfEmpty(defaultValue?: any): IObservable; + distinct(keySelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IObservable; + groupBy(keySelector: (value: any) =>any, elementSelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IGroupedObservable; + groupByUntil(keySelector: (value: any) =>any, elementSelector: (value: any) =>any, durationSelector: (gloup: IGroupedObservable) =>IObservable, keySerializer?: (key: any) =>string): IGroupedObservable; + select(selector: (value: any, index: number) =>any): IObservable; + selectMany(selector: (value: any) =>IObservable, resultSelector?: (x: any, y: any) =>any): IObservable; + selectMany(other: IObservable): IObservable; + skip(count: number): IObservable; + skipWhile(predicate: (value: any, index?: number) =>bool): IObservable; + take(count: number, scheduler?: IScheduler): IObservable; + takeWhile(predicate: (value: any, index?: number) =>bool): IObservable; + where(predicate: (value: any, 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; - } - export interface Observable { - (subscribe: (observer: IObserver) =>_IDisposable): 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 { + (subscribe: (observer: IObserver) =>_IDisposable): IObservable; - start(func: () =>any, scheduler?: IScheduler, context?: any): IObservable; - toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable; - create(subscribe: (Observer) =>() =>void ): IObservable; - createWithDisposable(subscribe: (Observer) =>_IDisposable): IObservable; - defer(observableFactory: () =>IObservable): IObservable; - empty(scheduler?: IScheduler): IObservable; - fromArray(array: any[], scheduler?: IScheduler): IObservable; - fromArray(array: { length: number;[index: number]: any; }, scheduler?: IScheduler): IObservable; - generate(initialState: any, condition: (state: any) =>bool, iterate: (state: any) =>any, resultSelector: (state: any) =>any, scheduler?: IScheduler): IObservable; - never(): IObservable; - range(start: number, count: number, scheduler?: IScheduler): IObservable; - repeat(value: any, repeatCount?: number, scheduler?: IScheduler): IObservable; - returnValue(value: any, scheduler?: IScheduler): IObservable; - throwException(exception: any, scheduler?: IScheduler): IObservable; - using(resourceFactory: () =>any, observableFactory: (resource: any) =>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; - } + start(func: () =>any, scheduler?: IScheduler, context?: any): IObservable; + toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable; + create(subscribe: (Observer) => void ): IObservable; + create(subscribe: (Observer) => () => void ): IObservable; + createWithDisposable(subscribe: (Observer) =>_IDisposable): IObservable; + defer(observableFactory: () =>IObservable): IObservable; + empty(scheduler?: IScheduler): IObservable; + fromArray(array: any[], scheduler?: IScheduler): IObservable; + fromArray(array: { length: number;[index: number]: any; }, scheduler?: IScheduler): IObservable; + generate(initialState: any, condition: (state: any) =>bool, iterate: (state: any) =>any, resultSelector: (state: any) =>any, scheduler?: IScheduler): IObservable; + never(): IObservable; + range(start: number, count: number, scheduler?: IScheduler): IObservable; + repeat(value: any, repeatCount?: number, scheduler?: IScheduler): IObservable; + returnValue(value: any, scheduler?: IScheduler): IObservable; + throwException(exception: any, scheduler?: IScheduler): IObservable; + using(resourceFactory: () =>any, observableFactory: (resource: any) =>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; + } - export module Internals { - interface IAnonymousObservable extends IObservable { } - export interface AnonymousObservable { - (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable; - } - } + var Observable: Observable; - interface IGroupedObservable extends IObservable { - key: any; - underlyingObservable: IObservable; - } + export module Internals { + interface IAnonymousObservable extends IObservable { } + export interface AnonymousObservable { + (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable; + } + } - interface ISubject extends IObservable, IObserver { - isDisposed: bool; - isStopped: bool; - observers: IObserver[]; + interface IGroupedObservable extends IObservable { + key: any; + underlyingObservable: IObservable; + } - dispose(): void; - } - export interface Subject { - (): ISubject; + interface ISubject extends IObservable, IObserver { + isDisposed: bool; + isStopped: bool; + observers: IObserver[]; - create(observer: IObserver, observable: IObservable): ISubject; - } + dispose(): void; + } + export interface Subject { + (): ISubject; - interface IAsyncSubject extends IObservable, IObserver { - isDisposed: bool; - value: any; - hasValue: bool; - observers: IObserver[]; - exception: any; + create(observer?: IObserver, observable?: IObservable): ISubject; + } - dispose(): void; - } - export interface AsyncSubject { - (): IAsyncSubject; - } + interface IAsyncSubject extends IObservable, IObserver { + isDisposed: bool; + value: any; + hasValue: bool; + observers: IObserver[]; + exception: any; - interface IAnonymousSubject extends IObservable { - onNext(value: any): void; - onError(exception: any): void; - onCompleted(): void; - } + dispose(): void; + } + export interface AsyncSubject { + (): IAsyncSubject; + } + + interface IAnonymousSubject extends IObservable { + onNext(value: any): void; + onError(exception: any): void; + onCompleted(): void; + } } \ No newline at end of file diff --git a/rx.js/rx.js.html.d.ts b/rx.js/rx.js.html.d.ts index 4a9eb833f..2592d3f12 100644 --- a/rx.js/rx.js.html.d.ts +++ b/rx.js/rx.js.html.d.ts @@ -1,8 +1,8 @@ /// declare module Rx { - export module Observable { - function fromEvent(element: HTMLElement, eventName: string) : IObservable; - function fromEvent(document: HTMLDocument, eventName: string): IObservable; + 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.time.d.ts b/rx.js/rx.js.time.d.ts index f1bd2a584..2c098fa6a 100644 --- a/rx.js/rx.js.time.d.ts +++ b/rx.js/rx.js.time.d.ts @@ -1,10 +1,10 @@ /// declare module Rx { - export module Observable { - function ifThen(condition: () => bool, thenSource: IObservable): IObservable; - function ifThen(condition: () => bool, thenSource: IObservable, elseSource: IObservable): IObservable; - function ifThen(condition: () => bool, thenSource: IObservable, scheduler: IScheduler): IObservable; - function interval(period: number, scheduler?: IScheduler): IObservable; + interface Observable { + ifThen(condition: () => bool, thenSource: IObservable): IObservable; + ifThen(condition: () => bool, thenSource: IObservable, elseSource: IObservable): IObservable; + ifThen(condition: () => bool, thenSource: IObservable, scheduler: IScheduler): IObservable; + interval(period: number, scheduler?: IScheduler): IObservable; } } \ No newline at end of file From bc491674fc7416065c2a5cdd6c16ac85477e2c38 Mon Sep 17 00:00:00 2001 From: Carl de Billy Date: Mon, 1 Jul 2013 22:53:39 -0400 Subject: [PATCH 2/2] IObservable => IObservable Now use generics who improve a lot the writing of Rx fluent expressions! --- rx.js/rx.js.aggregates.d.ts | 19 ++- rx.js/rx.js.d.ts | 315 ++++++++++++++++++------------------ rx.js/rx.js.html.d.ts | 6 +- rx.js/rx.js.jquery.d.ts | 122 +++++++++----- rx.js/rx.js.time.d.ts | 11 +- 5 files changed, 262 insertions(+), 211 deletions(-) diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts index 7c10866a6..16426a96e 100644 --- a/rx.js/rx.js.aggregates.d.ts +++ b/rx.js/rx.js.aggregates.d.ts @@ -1,16 +1,19 @@ +/// + // Type definitions for RxJS "Aggregates" // Project: http://rx.codeplex.com/ // Definitions by: Carl de Billy // Definitions: https://github.com/borisyankov/DefinitelyTyped -/// - declare module Rx { - interface Observable { - all(predicate?: (any) => bool): IObservable; - min(predicate?: (any) => bool): IObservable; - max(predicate?: (any) => bool): IObservable; - count(predicate?: (any) => bool): IObservable; - sum(keySelector?: (any) => any): IObservable; + 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; + sum(keySelector?: (item: T) => number): IObservable; + isEmpty(predicate?: (value: T) => bool): IObservable; + contains(value: T, comparer?: (value1: T, value2: T) => bool): IObservable; + average(keySelector?: (item: T) => number): IObservable; } } \ No newline at end of file diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts index 543fb703d..1cce070dc 100644 --- a/rx.js/rx.js.d.ts +++ b/rx.js/rx.js.d.ts @@ -8,7 +8,7 @@ declare module Rx { export module Internals { function inherits(child: Function, parent: Function): Function; function addProperties(obj: Object, ...sourcces: Object[]): void; - function addRef(xs: IObservable, r: { getDisposable(): _IDisposable; }): IObservable; + function addRef(xs: IObservable, r: { getDisposable(): _IDisposable; }): IObservable; } //Collections @@ -192,81 +192,81 @@ declare module Rx { interface ICatchScheduler extends IScheduler { } // Notifications - interface INotification { - accept(observer: IObserver): void; - accept(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void; + interface INotification { + accept(observer: IObserver): void; + accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void; toObservable(scheduler?: IScheduler): IObservable; hasValue: bool; - equals(other: INotification): bool; + equals(other: INotification): bool; kind: string; - value?: any; + value?: T; exception?: any; } export interface Notification { //abstract //function new (): INotification; - createOnNext(value: any): INotification;//ON - createOnError(exception): INotification;//OE - createOnCompleted(): INotification;//OC + createOnNext(value: T): INotification;//ON + createOnError(exception): INotification;//OE + createOnCompleted(): INotification;//OC } var Notification: Notification; export module Internals { // Enumerator - interface IEnumerator { + interface IEnumerator { moveNext(): bool; - getCurrent(): any; + getCurrent(): T; dispose(): void; } - export interface Enumerator { - (moveNext: () =>bool, getCurrent: () => any, dispose: () =>void ): IEnumerator; + export interface Enumerator { + (moveNext: () =>bool, getCurrent: () => T, dispose: () =>void ): IEnumerator; - create(moveNext: () =>bool, getCurrent: () =>any, dispose?: () =>void ): IEnumerator; + create(moveNext: () =>bool, getCurrent: () => T, dispose?: () =>void ): IEnumerator; } // Enumerable - interface IEnumerable { - getEnumerator(): IEnumerator; + interface IEnumerable { + getEnumerator(): IEnumerator; - concat(): IObservable; - catchException(): IObservable; + concat(): IObservable; + catchException(): IObservable; } - export interface Enumerable { - (getEnumerator: () =>IEnumerator): IEnumerable; + export interface Enumerable { + (getEnumerator: () =>IEnumerator): IEnumerable; - repeat(value: any, repeatCount?: number): IEnumerable; - forEach(source: any[], selector?: (element: any, index: number) =>any): IEnumerable; - forEach(source: { length: number;[index: number]: any; }, selector?: (element: any, index: number) =>any): 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: any): void; + interface IObserver { + onNext(value: T): void; onError(exception: any): void; onCompleted(): void; - toNotifier(): (notification: INotification) =>void; - asObserver(): IObserver; + toNotifier(): (notification: INotification) =>void; + asObserver(): IObserver; checked(): ICheckedObserver; } export module Observer { //abstract //function new (): IObserver; - function create(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver; - function fromNotifier(handler: (notification: INotification) =>void ): 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 { + interface IAbstractObserver extends IObserver { isStopped: bool; dispose(): void; - next(value: any): void; + next(value: T): void; error(exception: any): void; completed(): void; fail(): bool; @@ -277,20 +277,20 @@ declare module Rx { //} } - export class AnonymousObserver { - constructor(onNext: (value: any) => void , onError: (exception: any) => void , onCompleted: () => void); + export class AnonymousObserver { + constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void); } - interface ICheckedObserver extends IObserver { - _observer: IObserver; + interface ICheckedObserver extends IObserver { + _observer: IObserver; _state: number; // 0 - idle, 1 - busy, 2 - done checkAccess(): void; } export module Internals { - interface IScheduledObserver extends IAbstractObserver { + interface IScheduledObserver extends IAbstractObserver { scheduler: IScheduler; - observer: IObserver; + observer: IObserver; isAcquired: bool; hasFaulted: bool; //queue: { (value: any): void; (exception: any): void; (): void; }[]; @@ -298,163 +298,164 @@ declare module Rx { ensureActive(): void; } - export interface ScheduledObserver { - (scheduler: IScheduler, observer: IObserver): IScheduledObserver; + export interface ScheduledObserver { + (scheduler: IScheduler, observer: IObserver): IScheduledObserver; } } + interface IObservable { + _subscribe: (observer: IObserver) =>_IDisposable; - interface IObservable { - _subscribe: (observer: IObserver) =>_IDisposable; + subscribe(observer: IObserver): _IDisposable; - subscribe(observer: IObserver): _IDisposable; + finalValue(): IObservable; + subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable; + toArray(): IObservable; - finalValue(): IObservable; - subscribe(onNext?: (value: any) =>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: any, v2: any) =>any): IObservable; - combineLatest(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): 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: any, v2: any) =>any): IObservable; - zip(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): IObservable; - zip(...soucesAndResultSelector: any[]): IObservable; - zip(second: any[], resultSelector: (left: any, right: any) =>any): 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: any) =>any, comparer?: (x: any, y: any) =>bool): IObservable; - doAction(observer: IObserver): IObservable; - doAction(onNext: (value: any) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable; - finallyAction(action: () =>void ): IObservable; - ignoreElements(): IObservable; - materialize(): IObservable; - repeat(repeatCount?: number): IObservable; - retry(retryCount?: number): IObservable; - scan(seed: any, accumulator: (acc: any, value: any) =>any): IObservable; - scan(accumulator: (acc: any, value: any) =>any): IObservable; - skipLast(count: number): IObservable; - startWith(...values: any[]): IObservable; - startWith(scheduler: IScheduler, ...values: any[]): IObservable; - takeLast(count: number, scheduler?: IScheduler): IObservable; - takeLastBuffer(count: number): IObservable; - windowWithCount(count: number, skip?: number): IObservable; - defaultIfEmpty(defaultValue?: any): IObservable; - distinct(keySelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IObservable; - groupBy(keySelector: (value: any) =>any, elementSelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IGroupedObservable; - groupByUntil(keySelector: (value: any) =>any, elementSelector: (value: any) =>any, durationSelector: (gloup: IGroupedObservable) =>IObservable, keySerializer?: (key: any) =>string): IGroupedObservable; - select(selector: (value: any, index: number) =>any): IObservable; - selectMany(selector: (value: any) =>IObservable, resultSelector?: (x: any, y: any) =>any): IObservable; - selectMany(other: IObservable): IObservable; - skip(count: number): IObservable; - skipWhile(predicate: (value: any, index?: number) =>bool): IObservable; - take(count: number, scheduler?: IScheduler): IObservable; - takeWhile(predicate: (value: any, index?: number) =>bool): IObservable; - where(predicate: (value: any, index?: number) => bool): IObservable; + bufferWithCount(count: number, skip?: number): IObservable; + dematerialize(): IObservable; + distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>bool): 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) =>bool): IObservable; + 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; + 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 { - (subscribe: (observer: IObserver) =>_IDisposable): IObservable; - start(func: () =>any, scheduler?: IScheduler, context?: any): IObservable; - toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable; - create(subscribe: (Observer) => void ): IObservable; - create(subscribe: (Observer) => () => void ): IObservable; - createWithDisposable(subscribe: (Observer) =>_IDisposable): IObservable; - defer(observableFactory: () =>IObservable): IObservable; - empty(scheduler?: IScheduler): IObservable; - fromArray(array: any[], scheduler?: IScheduler): IObservable; - fromArray(array: { length: number;[index: number]: any; }, scheduler?: IScheduler): IObservable; - generate(initialState: any, condition: (state: any) =>bool, iterate: (state: any) =>any, resultSelector: (state: any) =>any, scheduler?: IScheduler): IObservable; - never(): IObservable; - range(start: number, count: number, scheduler?: IScheduler): IObservable; - repeat(value: any, repeatCount?: number, scheduler?: IScheduler): IObservable; - returnValue(value: any, scheduler?: IScheduler): IObservable; - throwException(exception: any, scheduler?: IScheduler): IObservable; - using(resourceFactory: () =>any, observableFactory: (resource: any) =>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; + interface Observable { + (subscribe: (observer: IObserver) =>_IDisposable): IObservable; + + 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; + 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) => bool, 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; } var Observable: Observable; export module Internals { - interface IAnonymousObservable extends IObservable { } - export interface AnonymousObservable { - (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable; + interface IAnonymousObservable extends IObservable { } + export interface AnonymousObservable { + (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable; } } - interface IGroupedObservable extends IObservable { - key: any; - underlyingObservable: IObservable; + interface IGroupedObservable extends IObservable { + key: TKey; + underlyingObservable: IObservable; } - interface ISubject extends IObservable, IObserver { + interface ISubject extends IObservable, IObserver { isDisposed: bool; isStopped: bool; - observers: IObserver[]; + //observers: IObserver[]; dispose(): void; } - export interface Subject { - (): ISubject; - create(observer?: IObserver, observable?: IObservable): ISubject; + export interface Subject { + (): ISubject; + + create(observer?: IObserver, observable?: IObservable): ISubject; } - interface IAsyncSubject extends IObservable, IObserver { + interface IAsyncSubject extends IObservable, IObserver { isDisposed: bool; - value: any; + value: T; hasValue: bool; - observers: IObserver[]; + observers: IObserver[]; exception: any; dispose(): void; } - export interface AsyncSubject { - (): IAsyncSubject; + export interface AsyncSubject { + (): IAsyncSubject; } - interface IAnonymousSubject extends IObservable { - onNext(value: any): void; + interface IAnonymousSubject extends IObservable { + onNext(value: T): void; onError(exception: any): void; onCompleted(): void; } diff --git a/rx.js/rx.js.html.d.ts b/rx.js/rx.js.html.d.ts index 2592d3f12..e1dcf69dd 100644 --- a/rx.js/rx.js.html.d.ts +++ b/rx.js/rx.js.html.d.ts @@ -1,8 +1,8 @@ -/// +/// declare module Rx { interface Observable { - fromEvent(element: HTMLElement, eventName: string) : IObservable; - fromEvent(document: HTMLDocument, eventName: string): IObservable; + 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.jquery.d.ts b/rx.js/rx.js.jquery.d.ts index 7f87a37da..361040390 100644 --- a/rx.js/rx.js.jquery.d.ts +++ b/rx.js/rx.js.jquery.d.ts @@ -1,46 +1,90 @@ -/// +/// /// +declare module JQueryResults { + + export interface eventBase{ + bubbles: bool; + cancelable: bool; + type: string; + preventDefault(): void; + isDefaultPrevented(): bool; + stopPropagation(): void; + isPropagationStopped(): bool; + data: any; + originalEvent: any; + eventPhase: number; + } + + export interface keyEvent extends eventBase { + key: number; + keyCode: number; + altKey: bool; + ctrlKey: bool; + shiftKey: bool; + char: string; + metaKey: bool; + } + + 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; + 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; - readyAsObservable(): Rx.IObservable; - hideAsObservable(duration: number): Rx.IObservable; - showAsObservable(duration: number): 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; + 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.time.d.ts b/rx.js/rx.js.time.d.ts index 2c098fa6a..fc1299255 100644 --- a/rx.js/rx.js.time.d.ts +++ b/rx.js/rx.js.time.d.ts @@ -1,10 +1,13 @@ /// declare module Rx { + interface IObservable { + ifThen(condition: () => bool, thenSource: IObservable): IObservable; + ifThen(condition: () => bool, thenSource: IObservable, elseSource: IObservable): IObservable; + ifThen(condition: () => bool, thenSource: IObservable, scheduler: IScheduler): IObservable; + } interface Observable { - ifThen(condition: () => bool, thenSource: IObservable): IObservable; - ifThen(condition: () => bool, thenSource: IObservable, elseSource: IObservable): IObservable; - ifThen(condition: () => bool, thenSource: IObservable, scheduler: IScheduler): IObservable; - interval(period: number, scheduler?: IScheduler): IObservable; + interval(period: number, scheduler?: IScheduler): IObservable; + interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable; } } \ No newline at end of file