mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-08-29 11:12:23 +08:00
Merge pull request #732 from carldebilly/master
Fixed broken + upgraded Rx.JS to 0.9 with generics
This commit is contained in:
Diullei Gomes
Vendored
+11
-8
@@ -1,16 +1,19 @@
|
||||
///<reference path="rx.js.d.ts" />
|
||||
|
||||
// Type definitions for RxJS "Aggregates"
|
||||
// Project: http://rx.codeplex.com/
|
||||
// Definitions by: Carl de Billy <http://carl.debilly.net/>
|
||||
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
||||
|
||||
///<reference path="rx.js.d.ts" />
|
||||
|
||||
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 IObservable<T> {
|
||||
all(predicate?: (value: T) => bool): IObservable<bool>;
|
||||
min(comparer?: (value1: T, value2: T) => number): IObservable<T>;
|
||||
max(comparer?: (value1: T, value2: T) => number): IObservable<number>;
|
||||
count(predicate?: (item: T) => bool): IObservable<number>;
|
||||
sum(keySelector?: (item: T) => number): IObservable<number>;
|
||||
isEmpty(predicate?: (value: T) => bool): IObservable<bool>;
|
||||
contains(value: T, comparer?: (value1: T, value2: T) => bool): IObservable<bool>;
|
||||
average(keySelector?: (item: T) => number): IObservable<number>;
|
||||
}
|
||||
}
|
||||
Vendored
+395
-399
@@ -5,462 +5,458 @@
|
||||
|
||||
|
||||
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<T>(xs: IObservable<T>, r: { getDisposable(): _IDisposable; }): IObservable<T>;
|
||||
}
|
||||
|
||||
//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<T> {
|
||||
accept(observer: IObserver<T>): void;
|
||||
accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void;
|
||||
toObservable(scheduler?: IScheduler): IObservable;
|
||||
hasValue: bool;
|
||||
equals(other: INotification<T>): bool;
|
||||
kind: string;
|
||||
value?: T;
|
||||
exception?: any;
|
||||
}
|
||||
export interface Notification {
|
||||
//abstract
|
||||
//function new (): INotification;
|
||||
|
||||
createOnNext(value: any): INotification;//ON
|
||||
createOnError(exception): INotification;//OE
|
||||
createOnCompleted(): INotification;//OC
|
||||
}
|
||||
createOnNext<T>(value: T): INotification<T>;//ON
|
||||
createOnError<T>(exception): INotification<T>;//OE
|
||||
createOnCompleted<T>(): INotification<T>;//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<T> {
|
||||
moveNext(): bool;
|
||||
getCurrent(): T;
|
||||
dispose(): void;
|
||||
}
|
||||
export interface Enumerator<T> {
|
||||
(moveNext: () =>bool, getCurrent: () => T, dispose: () =>void ): IEnumerator<T>;
|
||||
|
||||
// Enumerable
|
||||
interface IEnumerable {
|
||||
getEnumerator(): IEnumerator;
|
||||
create(moveNext: () =>bool, getCurrent: () => T, dispose?: () =>void ): IEnumerator<T>;
|
||||
}
|
||||
|
||||
concat(): IObservable;
|
||||
catchException(): IObservable;
|
||||
}
|
||||
export interface Enumerable {
|
||||
(getEnumerator: () =>IEnumerator): IEnumerable;
|
||||
// Enumerable
|
||||
interface IEnumerable<T> {
|
||||
getEnumerator(): IEnumerator<T>;
|
||||
|
||||
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<T>;
|
||||
catchException(): IObservable<T>;
|
||||
}
|
||||
export interface Enumerable<T> {
|
||||
(getEnumerator: () =>IEnumerator<T>): IEnumerable<T>;
|
||||
|
||||
// Observer
|
||||
interface IObserver {
|
||||
onNext(value: any): void;
|
||||
onError(exception: any): void;
|
||||
onCompleted(): void;
|
||||
repeat(value: T, repeatCount?: number): IEnumerable;
|
||||
forEach<T2>(source: T[], selector?: (element: T, index: number) => T2): IEnumerable<T2>;
|
||||
forEach<T2>(source: { length: number; [index: number]: T; }, selector?: (element: T, index: number) => T2): IEnumerable<T2>;
|
||||
}
|
||||
}
|
||||
|
||||
toNotifier(): (notification: INotification) =>void;
|
||||
asObserver(): IObserver;
|
||||
checked(): ICheckedObserver;
|
||||
}
|
||||
export module Observer {
|
||||
//abstract
|
||||
//function new (): IObserver;
|
||||
// Observer
|
||||
interface IObserver<T> {
|
||||
onNext(value: T): 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<T>) =>void;
|
||||
asObserver(): IObserver<T>;
|
||||
checked(): ICheckedObserver;
|
||||
}
|
||||
export module Observer {
|
||||
//abstract
|
||||
//function new (): IObserver;
|
||||
|
||||
export module Internals {
|
||||
// Abstract Observer
|
||||
interface IAbstractObserver extends IObserver {
|
||||
isStopped: bool;
|
||||
function create<T>(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver<T>;
|
||||
function fromNotifier<T>(handler: (notification: INotification<T>) =>void ): IObserver<T>;
|
||||
}
|
||||
|
||||
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<T> extends IObserver<T> {
|
||||
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: T): 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<T> {
|
||||
constructor(onNext: (value: T) => 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<T> extends IObserver<T> {
|
||||
_observer: IObserver<T>;
|
||||
_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<T> extends IAbstractObserver<T> {
|
||||
scheduler: IScheduler;
|
||||
observer: IObserver<T>;
|
||||
isAcquired: bool;
|
||||
hasFaulted: bool;
|
||||
//queue: { (value: any): void; (exception: any): void; (): void; }[];
|
||||
disposable: SerialDisposable;
|
||||
|
||||
ensureActive(): void;
|
||||
}
|
||||
export interface ScheduledObserver<T> {
|
||||
(scheduler: IScheduler, observer: IObserver<T>): IScheduledObserver<T>;
|
||||
}
|
||||
}
|
||||
|
||||
interface IObservable {
|
||||
_subscribe: (observer: IObserver) =>_IDisposable;
|
||||
interface IObservable<T> {
|
||||
_subscribe: (observer: IObserver<T>) =>_IDisposable;
|
||||
|
||||
subscribe(observer: IObserver): _IDisposable;
|
||||
subscribe(observer: IObserver<T>): _IDisposable;
|
||||
|
||||
finalValue(): IObservable;
|
||||
subscribe(onNext?: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable;
|
||||
toArray(): IObservable;
|
||||
finalValue(): IObservable<T>;
|
||||
subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable;
|
||||
toArray(): IObservable<T>;
|
||||
|
||||
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<T>;
|
||||
subscribeOn(scheduler: IScheduler): IObservable<T>;
|
||||
amb(rightSource: IObservable<T>): IObservable<T>;
|
||||
catchException(handler: (exception: any) =>IObservable<T>): IObservable<T>;
|
||||
catchException(second: IObservable<T>): IObservable<T>;
|
||||
combineLatest<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
|
||||
combineLatest<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) =>TResult): IObservable<TResult>;
|
||||
combineLatest<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) =>TResult): IObservable<TResult>;
|
||||
combineLatest<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) =>TResult): IObservable<TResult>;
|
||||
combineLatest<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
|
||||
concat(...sources: IObservable<T>[]): IObservable<T>;
|
||||
concat(sources: IObservable<T>[]): IObservable<T>;
|
||||
//concatIObservable(): IObservable<T>;
|
||||
merge(maxConcurrent: number): IObservable<T>;
|
||||
merge(other: IObservable<T>): IObservable<T>;
|
||||
//mergeIObservable(): IObservable;
|
||||
onErrorResumeNext(second: IObservable<T>): IObservable<T>;
|
||||
skipUntil<T2>(other: IObservable<T2>): IObservable<T>;
|
||||
switchLatest(): IObservable<T>;
|
||||
takeUntil<T2>(other: IObservable<T2>): IObservable<T>;
|
||||
zip<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
|
||||
zip<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): IObservable<TResult>;
|
||||
zip<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): IObservable<TResult>;
|
||||
zip<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): IObservable<TResult>;
|
||||
zip<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
|
||||
zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): IObservable<TResult>;
|
||||
asIObservable(): IObservable;
|
||||
bufferWithCount(count: number, skip?: number): IObservable<T>;
|
||||
dematerialize<TOrigin>(): IObservable<TOrigin>;
|
||||
distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>bool): IObservable;
|
||||
doAction(observer: IObserver<T>): IObservable<T>;
|
||||
doAction(onNext: (value: T) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable<T>;
|
||||
finallyAction(action: () =>void): IObservable<T>;
|
||||
ignoreElements(): IObservable<T>;
|
||||
materialize(): IObservable<INotification<any>>; // IObservable<INotification<T>> not supported by TypeScript 0.9.0 !!
|
||||
repeat(repeatCount?: number): IObservable<T>;
|
||||
retry(retryCount?: number): IObservable<T>;
|
||||
scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
|
||||
scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
|
||||
skipLast(count: number): IObservable<T>;
|
||||
startWith(...values: T[]): IObservable<T>;
|
||||
startWith(scheduler: IScheduler, ...values: T[]): IObservable<T>;
|
||||
takeLast(count: number, scheduler?: IScheduler): IObservable<T>;
|
||||
takeLastBuffer(count: number): IObservable<T>;
|
||||
windowWithCount(count: number, skip?: number): IObservable<T>;
|
||||
defaultIfEmpty(defaultValue?: any): IObservable<T>;
|
||||
distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) =>string): IObservable<T>;
|
||||
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
|
||||
groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: IGroupedObservable<TKey, TElement>) => IObservable<number>, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
|
||||
select<T2>(selector: (value: T, index: number) =>T2): IObservable<T2>;
|
||||
selectMany<T2>(selector: (value: T) =>IObservable<T2>, resultSelector?: (x: any, y: any) =>any): IObservable<T2>;
|
||||
selectMany<T2>(other: IObservable<T2>): IObservable<T2>;
|
||||
skip(count: number): IObservable<T>;
|
||||
skipWhile(predicate: (value: T, index?: number) =>bool): IObservable<T>;
|
||||
take(count: number, scheduler?: IScheduler): IObservable<T>;
|
||||
takeWhile(predicate: (value: T, index?: number) =>bool): IObservable<T>;
|
||||
where(predicate: (value: T, index?: number) => bool): IObservable<T>;
|
||||
|
||||
// time
|
||||
delay(dueTime: number, scheduler?: IScheduler): IObservable;
|
||||
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<T>;
|
||||
throttle(dueTime: number, scheduler?: IScheduler): IObservable<T>;
|
||||
windowWithTime(dueTime: number, timeShiftOrScheduler?: any, scheduler?: IScheduler): IObservable<T>;
|
||||
timeInterval(scheduler: IScheduler): IObservable<T>;
|
||||
sample(interval: number, scheduler?: IScheduler): IObservable<T>;
|
||||
sample<TSample>(sampler: IObservable<TSample>, scheduler?: IScheduler): IObservable<T>;
|
||||
timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
|
||||
delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
interface Observable {
|
||||
(subscribe: (observer: IObserver<any>) =>_IDisposable): IObservable;
|
||||
|
||||
export module Internals {
|
||||
interface IAnonymousObservable extends IObservable { }
|
||||
export interface AnonymousObservable {
|
||||
(subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable;
|
||||
}
|
||||
}
|
||||
start<T>(func: () =>T, scheduler?: IScheduler, context?: any): IObservable<T>;
|
||||
toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable<T>;
|
||||
create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
|
||||
create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
|
||||
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>;
|
||||
fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable<T>;
|
||||
generate<TState, TResult>(initialState: TState, condition: (state: TState) => bool, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): IObservable<TResult>;
|
||||
never<T>(): IObservable<T>;
|
||||
range(start: number, count: number, scheduler?: IScheduler): IObservable<number>;
|
||||
repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable<T>;
|
||||
returnValue<T>(value: T, 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>;
|
||||
catchException<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
catchException<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
concat<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
concat<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(scheduler: IScheduler, ...sources: IObservable<T>[]): IObservable<T>;
|
||||
merge<T>(scheduler: IScheduler, sources: IObservable<T>[]): IObservable<T>;
|
||||
onErrorResumeNext<T>(...sources: IObservable<T>[]): IObservable<T>;
|
||||
onErrorResumeNext<T>(sources: IObservable<T>[]): IObservable<T>;
|
||||
}
|
||||
|
||||
interface IGroupedObservable extends IObservable {
|
||||
key: any;
|
||||
underlyingObservable: IObservable;
|
||||
}
|
||||
var Observable: Observable;
|
||||
|
||||
interface ISubject extends IObservable, IObserver {
|
||||
isDisposed: bool;
|
||||
isStopped: bool;
|
||||
observers: IObserver[];
|
||||
export module Internals {
|
||||
interface IAnonymousObservable<T> extends IObservable<T> { }
|
||||
export interface AnonymousObservable<T> {
|
||||
(subscribe: (observer: IObserver<T>) =>_IDisposable): IAnonymousObservable<T>;
|
||||
}
|
||||
}
|
||||
|
||||
dispose(): void;
|
||||
}
|
||||
export interface Subject {
|
||||
(): ISubject;
|
||||
interface IGroupedObservable<TKey, TElement> extends IObservable<TElement> {
|
||||
key: TKey;
|
||||
underlyingObservable: IObservable<TElement>;
|
||||
}
|
||||
|
||||
create(observer: IObserver, observable: IObservable): ISubject;
|
||||
}
|
||||
interface ISubject<T> extends IObservable<T>, IObserver<T> {
|
||||
isDisposed: bool;
|
||||
isStopped: bool;
|
||||
//observers: IObserver<T>[];
|
||||
|
||||
interface IAsyncSubject extends IObservable, IObserver {
|
||||
isDisposed: bool;
|
||||
value: any;
|
||||
hasValue: bool;
|
||||
observers: IObserver[];
|
||||
exception: any;
|
||||
dispose(): void;
|
||||
}
|
||||
|
||||
dispose(): void;
|
||||
}
|
||||
export interface AsyncSubject {
|
||||
(): IAsyncSubject;
|
||||
}
|
||||
export interface Subject {
|
||||
(): ISubject<any>;
|
||||
|
||||
interface IAnonymousSubject extends IObservable {
|
||||
onNext(value: any): void;
|
||||
onError(exception: any): void;
|
||||
onCompleted(): void;
|
||||
}
|
||||
create<T>(observer?: IObserver<T>, observable?: IObservable<T>): ISubject<T>;
|
||||
}
|
||||
|
||||
interface IAsyncSubject<T> extends IObservable<T>, IObserver<T> {
|
||||
isDisposed: bool;
|
||||
value: T;
|
||||
hasValue: bool;
|
||||
observers: IObserver<T>[];
|
||||
exception: any;
|
||||
|
||||
dispose(): void;
|
||||
}
|
||||
export interface AsyncSubject<T> {
|
||||
(): IAsyncSubject<T>;
|
||||
}
|
||||
|
||||
interface IAnonymousSubject<T> extends IObservable<T> {
|
||||
onNext(value: T): void;
|
||||
onError(exception: any): void;
|
||||
onCompleted(): void;
|
||||
}
|
||||
}
|
||||
Vendored
+4
-4
@@ -1,8 +1,8 @@
|
||||
///<reference path="rx.js.d.ts"/>
|
||||
///<reference path="rx.js.d.ts"/>
|
||||
|
||||
declare module Rx {
|
||||
export module Observable {
|
||||
function fromEvent(element: HTMLElement, eventName: string) : IObservable;
|
||||
function fromEvent(document: HTMLDocument, eventName: string): IObservable;
|
||||
interface Observable {
|
||||
fromEvent<TEvent>(element: HTMLElement, eventName: string): IObservable<TEvent>;
|
||||
fromEvent<TEvent>(document: HTMLDocument, eventName: string): IObservable<TEvent>;
|
||||
}
|
||||
}
|
||||
Vendored
+83
-39
@@ -1,46 +1,90 @@
|
||||
///<reference path="../jquery/jquery.d.ts"/>
|
||||
///<reference path="../jquery/jquery.d.ts"/>
|
||||
///<reference path="rx.js.d.ts"/>
|
||||
|
||||
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<T>(settings: JQueryAjaxSettings): Rx.IObservable<T>;
|
||||
getAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
|
||||
getJSONAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
|
||||
getScriptAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
|
||||
postAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
|
||||
}
|
||||
|
||||
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<JQueryResults.eventBase>;
|
||||
clickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
dblclickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
focusAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
focusinAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
focusoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
keydownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
|
||||
keyupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
|
||||
loadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.uiEvent>;
|
||||
mousedownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseenterAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseleaveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mousemoveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseoverAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
mouseupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
|
||||
resizeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
scrollAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
selectAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
submitAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
unloadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
|
||||
hideAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
|
||||
showAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
|
||||
readyAsObservable(): Rx.IObservable<any>;
|
||||
animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeInAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
|
||||
fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
|
||||
slideDownAsObservable(duration: number): Rx.IObservable<any>;
|
||||
slideUpAsObservable(duration: number): Rx.IObservable<any>;
|
||||
slideToggleAsObservable(duration: number): Rx.IObservable<any>;
|
||||
toggleAsObservable(duration: number): Rx.IObservable<any>;
|
||||
}
|
||||
Vendored
+8
-5
@@ -1,10 +1,13 @@
|
||||
///<reference path="rx.js.d.ts" />
|
||||
|
||||
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 IObservable<T> {
|
||||
ifThen(condition: () => bool, thenSource: IObservable<T>): IObservable<T>;
|
||||
ifThen(condition: () => bool, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
|
||||
ifThen(condition: () => bool, thenSource: IObservable<T>, scheduler: IScheduler): IObservable<T>;
|
||||
}
|
||||
interface Observable {
|
||||
interval(period: number, scheduler?: IScheduler): IObservable<number>;
|
||||
interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable<number>;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user