vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-08-16 23:10:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

rx.js.virtualtime.d.ts: updated names, added HistoricalScheduler

Browse Source 
rx.js.d.ts: updated names, moved some interfaces to Internal
This commit is contained in:
Igor Oleinikov
2013-12-15 11:21:23 +04:00
parent 36513cf85f
commit 9c2f13f04d
6 changed files with 80 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rx.js/rx.js.async.d.ts
Vendored
+2 -5
View File
@@ -3,14 +3,11 @@
// Type definitions for RxJS-Async package 2.2
// Project: http://rx.codeplex.com/
// Definitions by: zoetrope <https://github.com/zoetrope>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.async.js
declare module Rx {
interface Observable {
interface ObservableStatic {
start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => Observable<T>;
fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => Observable<T>;
rx.js/rx.js.binding.d.ts
Vendored
+19 -24
View File
@@ -3,41 +3,40 @@
// Type definitions for RxJS-Binding package
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.binding.js
declare module Rx {
interface ReplaySubject<T> extends ISubject<T> {
new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
export interface BehaviorSubject<T> extends Subject<T> {
}
var ReplaySubject: {
new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
interface BehaviorSubject<T> extends ISubject<T> {
new (initialValue: T): BehaviorSubject<any>;
interface BehaviorSubjectStatic {
new <T>(initialValue: T): BehaviorSubject<T>;
}
var BehaviorSubject: {
new <T>(initialValue: T): BehaviorSubject<T>;
}
export var BehaviorSubject: BehaviorSubjectStatic;
interface ConnectableObservable<T> extends Observable<T>{
export interface ReplaySubject<T> extends Subject<T> {
}
interface ReplaySubjectStatic {
new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
export var ReplaySubject: ReplaySubjectStatic;
interface ConnectableObservable<T> extends Observable<T> {
connect(): IDisposable;
refCount(): Observable<T>;
}
var ConnectableObservable: {
interface ConnectableObservableStatic {
new <T>(): ConnectableObservable<T>;
}
}
interface Observable<T> {
export var ConnectableObservable: ConnectableObservableStatic;
export interface Observable<T> {
publish(): ConnectableObservable<T>;
publish<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
publishLast(): ConnectableObservable<T>;
@@ -47,8 +46,4 @@ declare module Rx {
replay(selector?: (source: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
}
interface Observable {
}
}
rx.js/rx.js.coincidence.d.ts
Vendored
-4
View File
@@ -33,8 +33,4 @@ declare module Rx {
window<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
}
interface Observable {
}
}
rx.js/rx.js.d.ts
Vendored
+32 -52
View File
@@ -1,37 +1,49 @@
// Type definitions for RxJS
// Project: http://rx.codeplex.com/
// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module Rx {
export module Internals {
function isEqual(left: any, right: any): boolean;
function inherits(child: Function, parent: Function): Function;
function addProperties(obj: Object, ...sourcces: Object[]): void;
function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
}
//Collections
interface IIndexedItem {
id: number;
value: IScheduledItem;
// Priority Queue for Scheduling
export class PriorityQueue<TTime> {
constructor(capacity: number);
compareTo(other: IIndexedItem): number;
}
length: number;
// Priority Queue for Scheduling
interface IPriorityQueue {
items: IIndexedItem[];
length: number;
isHigherPriority(left: number, right: number): boolean;
percolate(index: number): void;
heapify(index: number): void;
peek(): ScheduledItem<TTime>;
removeAt(index: number): void;
dequeue(): ScheduledItem<TTime>;
enqueue(item: ScheduledItem<TTime>): void;
remove(item: ScheduledItem<TTime>): boolean;
isHigherPriority(left: number, right: number): boolean;
percolate(index: number): void;
heapify(index: number): void;
peek(): IIndexedItem;
removeAt(index: number): void;
dequeue(): IIndexedItem;
enqueue(item: IIndexedItem): void;
remove(item: IIndexedItem): boolean;
static count: number;
}
export class ScheduledItem<TTime> {
constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
scheduler: IScheduler;
state: TTime;
action: (scheduler: IScheduler, state: any) => IDisposable;
dueTime: TTime;
comparer: (x: TTime, y: TTime) => number;
disposable: SingleAssignmentDisposable;
invoke(): void;
compareTo(other: ScheduledItem<TTime>): number;
isCancelled(): boolean;
invokeCore(): IDisposable;
}
}
export interface IDisposable {
@@ -94,20 +106,6 @@ declare module Rx {
getDisposable(): IDisposable;
}
interface IScheduledItem {
scheduler: IScheduler;
state: any;
action: (scheduler: IScheduler, state) => IDisposable;
dueTime: number;
comparer: (x: number, y: number) =>number;
disposable: SingleAssignmentDisposable;
invoke(): void;
compareTo(other: IScheduledItem): number;
isCancelled(): boolean;
invokeCore(): IDisposable;
}
export interface IScheduler {
now(): number;
catch(handler: (exception: any) => boolean): IScheduler;
@@ -355,22 +353,4 @@ declare module Rx {
}
export var AsyncSubject: AsyncSubjectStatic;
export interface BehaviorSubject<T> extends Subject<T> {
}
interface BehaviorSubjectStatic {
new <T>(initialValue: T): BehaviorSubject<T>;
}
export var BehaviorSubject: BehaviorSubjectStatic;
export interface ReplaySubject<T> extends Subject<T> {
}
interface ReplaySubjectStatic {
new <T>(initialValue: T): ReplaySubject<T>;
}
export var ReplaySubject: ReplaySubjectStatic;
}
rx.js/rx.js.experimental.d.ts
Vendored
+1 -1
View File
@@ -60,7 +60,7 @@ declare module Rx {
manySelect<TResult>(selector: (item: Observable<T>, index: number, source: Observable<T>) => TResult, scheduler?: IScheduler): Observable<TResult>;
}
interface Observable {
interface ObservableStatic {
/**
* Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
*
rx.js/rx.js.virtualtime.d.ts
Vendored
+26 -27
View File
@@ -3,35 +3,34 @@
// Type definitions for RxJS-VirtualTime package 2.2
// Project: http://rx.codeplex.com/
// Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
// Revision by: Igor Oleinikov <https://github.com/Igorbek>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
//
// Dependencies:
// -> rx.js
// -> rx.virtualtime.js
declare module Rx {
// Virtual IScheduler
interface IVirtualTimeScheduler extends IScheduler {
toRelative(duetime): number;
toDateTimeOffset(duetime: number): number;
export /*abstract*/ class VirtualTimeScheduler<TAbsolute, TRelative> extends Scheduler {
constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number);
clock: number;
comparer: (x: number, y: number) =>number;
isEnabled: boolean;
queue: IPriorityQueue;
scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
scheduleRelative(dueTime: number, action: () =>void ): IDisposable;
start(): IDisposable;
stop(): void;
advanceTo(time: number);
advanceBy(time: number);
sleep(time: number);
getNext(): IScheduledItem;
scheduleAbsolute(dueTime: number, action: () =>void );
scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
}
//export module VirtualTimeScheduler {
// //absract
// function new (initialClock: number, comparer: (x: number, y: number) =>number): IVirtualTimeScheduler;
//}
}
advanceBy(time: TRelative);
advanceTo(time: TAbsolute);
scheduleAbsolute(dueTime: TAbsolute, action: () => void);
scheduleAbsoluteWithState<TState>(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
scheduleRelativeWithState<TState>(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
sleep(time: TRelative);
start(): IDisposable;
stop(): void;
isEnabled: boolean;
/* protected abstract */ add(from: TAbsolute, by: TRelative): TAbsolute;
/* protected abstract */ toDateTimeOffset(duetime: TAbsolute): number;
/* protected abstract */ toRelative(duetime: number): TRelative;
/* protected */ getNext(): Internals.ScheduledItem<TAbsolute>;
}
export class HistoricalScheduler extends VirtualTimeScheduler<number, number> {
constructor(initialClock: number, comparer: (first: number, second: number) => number);
}
}