77 lines
5.0 KiB
TypeScript
77 lines
5.0 KiB
TypeScript
|
import { PartialObserver } from './Observer';
|
||
|
|
import { Operator } from './Operator';
|
||
|
|
import { Subscriber } from './Subscriber';
|
||
|
|
import { Subscription, AnonymousSubscription, TeardownLogic } from './Subscription';
|
||
|
|
import { IfObservable } from './observable/IfObservable';
|
||
|
|
import { ErrorObservable } from './observable/ErrorObservable';
|
||
|
|
import { OperatorFunction } from './interfaces';
|
||
|
|
export interface Subscribable<T> {
|
||
|
|
subscribe(observerOrNext?: PartialObserver<T> | ((value: T) => void), error?: (error: any) => void, complete?: () => void): AnonymousSubscription;
|
||
|
|
}
|
||
|
|
export declare type SubscribableOrPromise<T> = Subscribable<T> | PromiseLike<T>;
|
||
|
|
export declare type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T>;
|
||
|
|
/**
|
||
|
|
* A representation of any set of values over any amount of time. This is the most basic building block
|
||
|
|
* of RxJS.
|
||
|
|
*
|
||
|
|
* @class Observable<T>
|
||
|
|
*/
|
||
|
|
export declare class Observable<T> implements Subscribable<T> {
|
||
|
|
_isScalar: boolean;
|
||
|
|
/** @deprecated internal use only */ source: Observable<any>;
|
||
|
|
protected operator: Operator<any, T>;
|
||
|
|
/**
|
||
|
|
* @constructor
|
||
|
|
* @param {Function} subscribe the function that is called when the Observable is
|
||
|
|
* initially subscribed to. This function is given a Subscriber, to which new values
|
||
|
|
* can be `next`ed, or an `error` method can be called to raise an error, or
|
||
|
|
* `complete` can be called to notify of a successful completion.
|
||
|
|
*/
|
||
|
|
constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
|
||
|
|
/**
|
||
|
|
* Creates a new cold Observable by calling the Observable constructor
|
||
|
|
* @static true
|
||
|
|
* @owner Observable
|
||
|
|
* @method create
|
||
|
|
* @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
|
||
|
|
* @return {Observable} a new cold observable
|
||
|
|
*/
|
||
|
|
static create: Function;
|
||
|
|
/**
|
||
|
|
* Creates a new Observable, with this Observable as the source, and the passed
|
||
|
|
* operator defined as the new observable's operator.
|
||
|
|
* @method lift
|
||
|
|
* @param {Operator} operator the operator defining the operation to take on the observable
|
||
|
|
* @return {Observable} a new observable with the Operator applied
|
||
|
|
*/
|
||
|
|
lift<R>(operator: Operator<T, R>): Observable<R>;
|
||
|
|
subscribe(observer?: PartialObserver<T>): Subscription;
|
||
|
|
subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
|
||
|
|
protected _trySubscribe(sink: Subscriber<T>): TeardownLogic;
|
||
|
|
/**
|
||
|
|
* @method forEach
|
||
|
|
* @param {Function} next a handler for each value emitted by the observable
|
||
|
|
* @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise
|
||
|
|
* @return {Promise} a promise that either resolves on observable completion or
|
||
|
|
* rejects with the handled error
|
||
|
|
*/
|
||
|
|
forEach(next: (value: T) => void, PromiseCtor?: typeof Promise): Promise<void>;
|
||
|
|
/** @deprecated internal use only */ _subscribe(subscriber: Subscriber<any>): TeardownLogic;
|
||
|
|
static if: typeof IfObservable.create;
|
||
|
|
static throw: typeof ErrorObservable.create;
|
||
|
|
pipe(): Observable<T>;
|
||
|
|
pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
|
||
|
|
pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
|
||
|
|
pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
|
||
|
|
pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
|
||
|
|
pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
|
||
|
|
pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
|
||
|
|
pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
|
||
|
|
pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
|
||
|
|
pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
|
||
|
|
pipe<R>(...operations: OperatorFunction<T, R>[]): Observable<R>;
|
||
|
|
toPromise<T>(this: Observable<T>): Promise<T>;
|
||
|
|
toPromise<T>(this: Observable<T>, PromiseCtor: typeof Promise): Promise<T>;
|
||
|
|
toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructorLike): Promise<T>;
|
||
|
|
}
|