104 lines
7.5 KiB
TypeScript
104 lines
7.5 KiB
TypeScript
import { Observable } from './Observable';
|
|
import { Scheduler } from './Scheduler';
|
|
import { ConnectableObservable } from './observable/ConnectableObservable';
|
|
import { Subject } from './Subject';
|
|
import { GroupedObservable } from './operator/groupBy';
|
|
import { Notification } from './Notification';
|
|
import { CombineLatestSignature } from './operator/combineLatest';
|
|
import { WithLatestFromSignature } from './operator/withLatestFrom';
|
|
import { ZipSignature } from './operator/zip';
|
|
import { BufferSignature } from './operator/buffer';
|
|
import { BufferCountSignature } from './operator/bufferCount';
|
|
import { BufferTimeSignature } from './operator/bufferTime';
|
|
import { BufferToggleSignature } from './operator/bufferToggle';
|
|
import { BufferWhenSignature } from './operator/bufferWhen';
|
|
import { WindowSignature } from './operator/window';
|
|
import { WindowCountSignature } from './operator/windowCount';
|
|
import { WindowTimeSignature } from './operator/windowTime';
|
|
import { WindowToggleSignature } from './operator/windowToggle';
|
|
import { WindowWhenSignature } from './operator/windowWhen';
|
|
export interface CoreOperators<T> {
|
|
buffer: BufferSignature<T>;
|
|
bufferCount: BufferCountSignature<T>;
|
|
bufferTime: BufferTimeSignature<T>;
|
|
bufferToggle: BufferToggleSignature<T>;
|
|
bufferWhen: BufferWhenSignature<T>;
|
|
catch?: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
|
|
combineAll?: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
|
|
combineLatest: CombineLatestSignature<T>;
|
|
concat?: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
|
|
concatAll?: () => Observable<T>;
|
|
concatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
|
|
concatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
|
|
count?: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
|
|
dematerialize?: () => Observable<any>;
|
|
debounce?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
|
|
debounceTime?: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
|
|
defaultIfEmpty?: <R>(defaultValue?: T | R) => Observable<T> | Observable<R>;
|
|
delay?: (delay: number, scheduler?: Scheduler) => Observable<T>;
|
|
delayWhen?: (delayDurationSelector: (value: T) => Observable<any>, subscriptionDelay?: Observable<any>) => Observable<T>;
|
|
distinctUntilChanged?: (compare?: (x: T, y: T) => boolean) => Observable<T>;
|
|
do?: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
|
|
expand?: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
|
|
filter?: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;
|
|
finally?: (finallySelector: () => void) => Observable<T>;
|
|
first?: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
|
|
flatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
|
|
flatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
|
|
groupBy?: <K, R>(keySelector: (value: T) => string, elementSelector?: (value: T) => R, durationSelector?: (group: GroupedObservable<K, R>) => Observable<any>) => Observable<GroupedObservable<K, R>>;
|
|
ignoreElements?: () => Observable<T>;
|
|
inspect?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
|
|
inspectTime?: (delay: number, scheduler?: Scheduler) => Observable<T>;
|
|
last?: <R>(predicate?: (value: T, index: number) => boolean, resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
|
|
every?: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
|
|
map?: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
|
|
mapTo?: <R>(value: R) => Observable<R>;
|
|
materialize?: () => Observable<Notification<T>>;
|
|
merge?: (...observables: any[]) => Observable<any>;
|
|
mergeAll?: (concurrent?: number) => Observable<T>;
|
|
mergeMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
|
|
mergeMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
|
|
multicast?: (subjectOrSubjectFactory: Subject<T> | (() => Subject<T>)) => ConnectableObservable<T>;
|
|
observeOn?: (scheduler: Scheduler, delay?: number) => Observable<T>;
|
|
partition?: (predicate: (x: T) => boolean) => Observable<T>[];
|
|
publish?: () => ConnectableObservable<T>;
|
|
publishBehavior?: (value: any) => ConnectableObservable<T>;
|
|
publishReplay?: (bufferSize?: number, windowTime?: number, scheduler?: Scheduler) => ConnectableObservable<T>;
|
|
publishLast?: () => ConnectableObservable<T>;
|
|
reduce?: <R>(project: (acc: R, x: T) => R, seed?: R) => Observable<R>;
|
|
repeat?: (count?: number) => Observable<T>;
|
|
retry?: (count?: number) => Observable<T>;
|
|
retryWhen?: (notifier: (errors: Observable<any>) => Observable<any>) => Observable<T>;
|
|
sample?: (notifier: Observable<any>) => Observable<T>;
|
|
sampleTime?: (delay: number, scheduler?: Scheduler) => Observable<T>;
|
|
scan?: <R>(project: (acc: R, x: T) => R, acc?: R) => Observable<R>;
|
|
share?: () => Observable<T>;
|
|
single?: (predicate?: (value: T, index: number) => boolean) => Observable<T>;
|
|
skip?: (count: number) => Observable<T>;
|
|
skipUntil?: (notifier: Observable<any>) => Observable<T>;
|
|
skipWhile?: (predicate: (x: T, index: number) => boolean) => Observable<T>;
|
|
startWith?: (x: T) => Observable<T>;
|
|
subscribeOn?: (scheduler: Scheduler, delay?: number) => Observable<T>;
|
|
switch?: () => Observable<T>;
|
|
switchMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
|
|
switchMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
|
|
take?: (count: number) => Observable<T>;
|
|
takeLast?: (count: number) => Observable<T>;
|
|
takeUntil?: (notifier: Observable<any>) => Observable<T>;
|
|
takeWhile?: (predicate: (value: T, index: number) => boolean) => Observable<T>;
|
|
throttle?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
|
|
throttleTime?: (delay: number, scheduler?: Scheduler) => Observable<T>;
|
|
timeout?: (due: number | Date, errorToSend?: any, scheduler?: Scheduler) => Observable<T>;
|
|
timeoutWith?: <R>(due: number | Date, withObservable: Observable<R>, scheduler?: Scheduler) => Observable<T> | Observable<R>;
|
|
toArray?: () => Observable<T[]>;
|
|
toPromise?: (PromiseCtor: typeof Promise) => Promise<T>;
|
|
window: WindowSignature<T>;
|
|
windowCount: WindowCountSignature<T>;
|
|
windowTime: WindowTimeSignature<T>;
|
|
windowToggle: WindowToggleSignature<T>;
|
|
windowWhen: WindowWhenSignature<T>;
|
|
withLatestFrom: WithLatestFromSignature<T>;
|
|
zip: ZipSignature<T>;
|
|
zipAll?: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
|
|
}
|