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

rx.js: started to make consistent with official documentation

Browse Source
This commit is contained in:
Igor Oleinikov
2013-12-11 18:19:18 +04:00
parent 4dea8bf7d2
commit 188cf5885d
4 changed files with 104 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rx.js/rx.js.binding.d.ts
Vendored
+1 -1
View File
@@ -28,7 +28,7 @@ declare module Rx {
}
interface ConnectableObservable<T> extends IObservable<T>{
connect(): _IDisposable;
connect(): IDisposable;
refCount(): IObservable<T>;
}
rx.js/rx.js.d.ts
Vendored
+98 -89
View File
@@ -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<T>(xs: IObservable<T>, r: { getDisposable(): _IDisposable; }): IObservable<T>;
function addRef<T>(xs: IObservable<T>, r: { getDisposable(): IDisposable; }): IObservable<T>;
}
//Collections
@@ -34,142 +34,147 @@ declare module Rx {
remove(item: IIndexedItem): boolean;
}
interface _IDisposable {
interface IDisposable {
dispose(): void;
}
export class CompositeDisposable {
constructor (...disposables: _IDisposable[]);
export class CompositeDisposable implements IDisposable {
constructor (...disposables: IDisposable[]);
constructor (disposables: IDisposable[]);
disposables: _IDisposable[];
isDisposed: boolean;
length: number;
dispose(): void;
add(item: _IDisposable): void;
remove(item: _IDisposable): boolean;
add(item: IDisposable): void;
remove(item: IDisposable): boolean;
clear(): void;
contains(item: _IDisposable): boolean;
toArray(): _IDisposable[];
contains(item: IDisposable): boolean;
toArray(): IDisposable[];
}
// Main disposable class
interface IDisposable {
export class Disposable implements IDisposable {
constructor(action: () => void);
static create(action: () => void): IDisposable;
static empty: IDisposable;
isDisposed: boolean;
action: () =>void;
action: () => void;
dispose(): void;
}
export interface Disposable {
new (action: () =>void ): IDisposable;
}
var Disposable: {
create(action: () => void): _IDisposable;
empty: _IDisposable;
}
// Single assignment
interface ISingleAssignmentDisposable {
isDisposed: boolean;
current: _IDisposable;
export class SingleAssignmentDisposable implements IDisposable {
constructor();
dispose(): void;
disposable(value?: _IDisposable): _IDisposable;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
}
export interface SingleAssignmentDisposable {
(): ISingleAssignmentDisposable;
isDisposed: boolean;
current: IDisposable;
dispose(): void ;
getDisposable(): IDisposable;
setDisposable(value: IDisposable): void ;
}
// Multiple assignment disposable
export class SerialDisposable {
export class SerialDisposable implements IDisposable {
constructor();
isDisposed: boolean;
current: _IDisposable;
dispose(): void;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
disposable(value?: _IDisposable): _IDisposable;
getDisposable(): IDisposable;
setDisposable(value: IDisposable): void;
}
export class RefCountDisposable {
constructor(disposable: _IDisposable);
underlyingDisposable: _IDisposable;
isDisposed: boolean;
isPrimaryDisposed: boolean;
count: number;
export class RefCountDisposable implements IDisposable {
constructor(disposable: IDisposable);
dispose(): void;
getDisposable(): _IDisposable;
isDisposed: boolean;
getDisposable(): IDisposable;
}
interface IScheduledItem {
scheduler: IScheduler;
state: any;
action: (scheduler: IScheduler, state) => _IDisposable;
action: (scheduler: IScheduler, state) => IDisposable;
dueTime: number;
comparer: (x: number, y: number) =>number;
disposable: ISingleAssignmentDisposable;
disposable: SingleAssignmentDisposable;
invoke(): void;
compareTo(other: IScheduledItem): number;
isCancelled(): boolean;
invokeCore(): _IDisposable;
invokeCore(): IDisposable;
}
interface IScheduler {
_schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable;
_scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
_scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
now(): number;
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
catch(handler: (exception: any) => boolean): IScheduler;
catchException(handler: (exception: any) => boolean): IScheduler;
catchException(handler: (exception: any) =>boolean): ICatchScheduler;
schedulePeriodic(period: number, action: () =>void ): _IDisposable;
schedulePeriodicWithState(state: any, period: number, action: (state: any) =>any): _IDisposable;//returns {Disposable|SingleAssignmentDisposable}
schedule(action: () =>void ): _IDisposable;
scheduleWithRelative(dueTime: number, action: () =>void ): _IDisposable;
scheduleWithAbsolute(dueTime: number, action: () =>void ): _IDisposable;
scheduleRecursive(action: (action: () =>void ) =>void ): _IDisposable;
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
schedule(action: () => void): IDisposable;
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable;
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>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;
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;
schedulePeriodic(period: number, action: () => void): IDisposable;
schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
}
var Scheduler: {
//(now: () =>number,
// schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable,
// scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable,
// scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable
// ): IScheduler;
export class Scheduler implements IScheduler {
constructor(
now: () => number,
schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable);
static normalize(timeSpan: number): number;
static immediate: IScheduler;
static currentThread: ICurrentThreadScheduler;
static timeout: IScheduler;
now(): number;
normalize(timeSpan: number): number;
catch(handler: (exception: any) => boolean): IScheduler;
catchException(handler: (exception: any) => boolean): IScheduler;
immediate: IScheduler;
currentThread: ICurrentScheduler;//IScheduler;
timeout: IScheduler;
schedule(action: () => void): IDisposable;
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
scheduleRecursive(action: (action: () => void) => void): IDisposable;
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) => 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;
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;
schedulePeriodic(period: number, action: () => void): IDisposable;
schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
}
// Current Thread IScheduler
interface ICurrentScheduler extends IScheduler {
interface ICurrentThreadScheduler extends IScheduler {
scheduleRequired(): boolean;
ensureTrampoline(action: () =>_IDisposable): _IDisposable;
ensureTrampoline(action: () =>IDisposable): IDisposable;
}
// CatchScheduler
interface ICatchScheduler extends IScheduler { }
// Notifications
interface INotification<T> {
accept(observer: IObserver<T>): void;
@@ -283,12 +288,12 @@ declare module Rx {
}
interface IObservable<T> {
_subscribe: (observer: IObserver<T>) =>_IDisposable;
_subscribe: (observer: IObserver<T>) =>IDisposable;
subscribe(observer: IObserver<T>): _IDisposable;
subscribe(observer: IObserver<T>): IDisposable;
finalValue(): IObservable<T>;
subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable;
subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IDisposable;
toArray(): IObservable<T>;
observeOn(scheduler: IScheduler): IObservable<T>;
@@ -352,11 +357,11 @@ declare module Rx {
}
interface Observable {
(subscribe: (observer: IObserver<any>) =>_IDisposable): IObservable<any>;
(subscribe: (observer: IObserver<any>) =>IDisposable): IObservable<any>;
create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
//create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>_IDisposable): IObservable<T>;
create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>IDisposable): IObservable<T>;
defer<T>(observableFactory: () => IObservable<T>): IObservable<T>;
empty<T>(scheduler?: IScheduler): IObservable<T>;
fromArray<T>(array: T[], scheduler?: IScheduler): IObservable<T>;
@@ -365,7 +370,11 @@ declare module Rx {
never<T>(): IObservable<T>;
range(start: number, count: number, scheduler?: IScheduler): IObservable<number>;
repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable<T>;
return<T>(value: T, scheduler?: IScheduler): IObservable<T>;
returnValue<T>(value: T, scheduler?: IScheduler): IObservable<T>;
throw<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
throw<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
throwException<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
throwException<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
using<TSource, TResource>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable<TSource>): IObservable<TSource>;
amb<T>(...sources: IObservable<T>[]): IObservable<T>;
@@ -387,7 +396,7 @@ declare module Rx {
export module Internals {
interface IAnonymousObservable<T> extends IObservable<T> { }
export interface AnonymousObservable<T> {
(subscribe: (observer: IObserver<T>) =>_IDisposable): IAnonymousObservable<T>;
(subscribe: (observer: IObserver<T>) =>IDisposable): IAnonymousObservable<T>;
}
}
rx.js/rx.js.time.d.ts
Vendored
+1 -1
View File
@@ -51,7 +51,7 @@ declare module Rx {
skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<Array>;
takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<T[]>;
takeWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
skipWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
rx.js/rx.js.virtualtime.d.ts
Vendored
+4 -4
View File
@@ -19,16 +19,16 @@ declare module Rx {
comparer: (x: number, y: number) =>number;
isEnabled: boolean;
queue: IPriorityQueue;
scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleRelative(dueTime: number, action: () =>void ): _IDisposable;
start(): _IDisposable;
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;
scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
}
//export module VirtualTimeScheduler {
// //absract