| import { Observable } from './Observable'; |
| import { Subscription } from './Subscription'; |
| |
| /** OPERATOR INTERFACES */ |
| |
| export interface UnaryFunction<T, R> { (source: T): R; } |
| |
| export interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {} |
| |
| export type FactoryOrValue<T> = T | (() => T); |
| |
| export interface MonoTypeOperatorFunction<T> extends OperatorFunction<T, T> {} |
| |
| export interface Timestamp<T> { |
| value: T; |
| timestamp: number; |
| } |
| |
| export interface TimeInterval<T> { |
| value: T; |
| interval: number; |
| } |
| |
| /** SUBSCRIPTION INTERFACES */ |
| |
| export interface Unsubscribable { |
| unsubscribe(): void; |
| } |
| |
| export type TeardownLogic = Unsubscribable | Function | void; |
| |
| export interface SubscriptionLike extends Unsubscribable { |
| unsubscribe(): void; |
| readonly closed: boolean; |
| } |
| |
| export type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>; |
| |
| /** OBSERVABLE INTERFACES */ |
| |
| export interface Subscribable<T> { |
| subscribe(observer?: PartialObserver<T>): Unsubscribable; |
| /** @deprecated Use an observer instead of a complete callback */ |
| subscribe(next: null | undefined, error: null | undefined, complete: () => void): Unsubscribable; |
| /** @deprecated Use an observer instead of an error callback */ |
| subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Unsubscribable; |
| /** @deprecated Use an observer instead of a complete callback */ |
| subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Unsubscribable; |
| subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Unsubscribable; |
| } |
| |
| export type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T> | Iterable<T>; |
| |
| /** @deprecated use {@link InteropObservable } */ |
| export type ObservableLike<T> = InteropObservable<T>; |
| |
| export type InteropObservable<T> = { [Symbol.observable]: () => Subscribable<T>; }; |
| |
| /** OBSERVER INTERFACES */ |
| |
| export interface NextObserver<T> { |
| closed?: boolean; |
| next: (value: T) => void; |
| error?: (err: any) => void; |
| complete?: () => void; |
| } |
| |
| export interface ErrorObserver<T> { |
| closed?: boolean; |
| next?: (value: T) => void; |
| error: (err: any) => void; |
| complete?: () => void; |
| } |
| |
| export interface CompletionObserver<T> { |
| closed?: boolean; |
| next?: (value: T) => void; |
| error?: (err: any) => void; |
| complete: () => void; |
| } |
| |
| export type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>; |
| |
| export interface Observer<T> { |
| closed?: boolean; |
| next: (value: T) => void; |
| error: (err: any) => void; |
| complete: () => void; |
| } |
| |
| /** SCHEDULER INTERFACES */ |
| |
| export interface SchedulerLike { |
| now(): number; |
| schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription; |
| } |
| export interface SchedulerAction<T> extends Subscription { |
| schedule(state?: T, delay?: number): Subscription; |
| } |
| |
| export type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never; |
| |
| export type ObservedValuesFromArray<X> = X extends Array<ObservableInput<infer T>> ? T : never; |