Options
All
  • Public
  • Public/Protected
  • All
Menu

multitude v0.0.8

Index

Type aliases

CatchesSelector

CatchesSelector<T, U>: (err: Error, observable: Observable<T>) => Convertible<U>

Type parameters

  • T

  • U

Type declaration

CombineResponse

CombineResponse<T>: { [ P in keyof T]: T[P] extends Convertible<infer U> ? U : never }

Type parameters

CompareStrategy

CompareStrategy: "strict" | "shallow" | "deep"

ConnectOptions

ConnectOptions<U>: Options<U>

Type parameters

  • U

ObservableHookResult

ObservableHookResult<T>: { data: T; done: boolean; success: true } | { data: Error; done: true; success: false }

Type parameters

  • T

OmitStrategy

OmitStrategy: "strict" | "shallow" | "deep"

OperateObserverList

OperateObserverList<T>: [NullaryFn | Empty, UnaryFn<T> | Empty, UnaryFn<Error> | Empty, NullaryFn | Empty, Teardown | Empty]

Type parameters

  • T

OperateOptions

OperateOptions: InterceptOptions

PickStrategy

PickStrategy: "strict" | "shallow" | "deep"

SharePolicy

SharePolicy: "on-demand" | "keep-open" | "keep-closed"

'on-demand': Default policy. Subscribes and re-subscribes to the original Observable once the resulting one has open subscriptions, so long as the original Observable hasn't errored or completed on previous subscriptions. Unsubscribes from the original Observable once the resulting Observable has no active subscriptions. 'keep-open': Keeps the parent subscription open even if it has no current subscriptions. 'keep-closed': Permanently unsubscribes from the original Observable once the resulting one has no active subscriptions. Subsequent subscriptions will error or complete immediately with the same signal as the original Observable if it finalized before being unsubscribed, or otherwise error.

StartStrategy

StartStrategy: "always" | "no-emit"

Functions

catches

  • Catches an error in the original observable and continues the stream by asynchronously subscribing to the Observable returned by selector. When no selector is provided, the original observable will be resubscribed.

    Type parameters

    • T

    • U = T

    Parameters

    Returns Operation<T, T | U>

combine

compare

configure

  • configure(hooks?: Empty | Hooks<any>): void

connect

debounce

defer

  • defer<T>(deferral: NullaryFn<T | PromiseLike<T>>): Observable<T>

delay

distinct

  • distinct<T>(selector?: BinaryFn<[T, number], any>): Operation<T>

extract

  • extract<T, U, V>(onEmpty?: U, onError?: V): Transformation<T, T | U | V>
  • Returns the first synchronous value of an Observable, if any, onEmpty if none is produced, or onError if the Observable errors synchronously. When onError doesn't exist, extract will synchronously throw.

    Type parameters

    • T

    • U = void

    • V = U

    Parameters

    • Optional onEmpty: U
    • Optional onError: V

    Returns Transformation<T, T | U | V>

filter

  • filter<T, U>(predicate: (value: T, index: number) => value is U): Operation<T, U>
  • filter<T>(predicate: (value: T, index: number) => boolean): Operation<T>
  • Type parameters

    • T

    • U

    Parameters

    • predicate: (value: T, index: number) => value is U
        • (value: T, index: number): value is U
        • Parameters

          • value: T
          • index: number

          Returns value is U

    Returns Operation<T, U>

  • Type parameters

    • T

    Parameters

    • predicate: (value: T, index: number) => boolean
        • (value: T, index: number): boolean
        • Parameters

          • value: T
          • index: number

          Returns boolean

    Returns Operation<T>

finalize

first

from

fromEvent

  • fromEvent<T>(source: EventEmitter, name: string | symbol): Observable<T>
  • fromEvent(source: EventTarget, name: string, capture?: boolean): Observable<Event>

fromPromise

  • fromPromise<T>(promise: PromiseLike<T>): Observable<T>

group

intercept

interval

isObservable

  • isObservable(item: any): item is Observable<unknown>

isObservableCompatible

  • isObservableCompatible(item: any): item is Compatible<unknown>

isObservableConvertible

  • isObservableConvertible(item: any): item is Convertible<unknown>

isObservableLike

  • isObservableLike(item: any): item is Like<unknown>

isPullableCompatible

  • isPullableCompatible(item: any): item is Compatible<unknown, unknown>

isPullableConvertible

  • isPullableConvertible(item: any): item is Convertible<unknown, unknown>

isPullableLike

  • isPullableLike(item: any): item is Like<unknown, unknown>

isSubscription

isSubscriptionLike

map

  • map<T, U>(projection: (value: T, index: number) => U): Operation<T, U>
  • Type parameters

    • T

    • U

    Parameters

    • projection: (value: T, index: number) => U
        • (value: T, index: number): U
        • Parameters

          • value: T
          • index: number

          Returns U

    Returns Operation<T, U>

merge

mergeMap

omit

operate

pick

share

skip

start

switchMap

take

tap

teardown

throws

timestamp

trail

transform

useObservable

usePropsMulticast

Generated using TypeDoc