Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface RecipeObservable

An Observable of a Recipe.

Hierarchy

  • Observable<Recipe>
    • RecipeObservable

Implements

Index

Modules

Constructors

Properties

Methods

Constructors

constructor

  • constructor

    Parameters

    • Optional subscribe: function

      the function that is called when the Observable is initially subscribed to. This function is given a Subscriber, to which new values can be nexted, or an error method can be called to raise an error, or complete can be called to notify of a successful completion.

        • <R>(this: Observable<Recipe>, subscriber: Subscriber<R>): TeardownLogic

        • Type parameters

          • R

          Parameters

          • this: Observable<Recipe>
          • subscriber: Subscriber<R>

          Returns TeardownLogic

    Returns RecipeObservable

Properties

_catch

_catch: _catch

_do

_do: _do

_finally

_finally: _finally

_isScalar

_isScalar: boolean

_switch

_switch: _switch

audit

audit: audit

auditTime

auditTime: auditTime

buffer

buffer: buffer

bufferCount

bufferCount: bufferCount

bufferTime

bufferTime: bufferTime

bufferToggle

bufferToggle: bufferToggle

bufferWhen

bufferWhen: bufferWhen

catch

catch: _catch

combineAll

combineAll: combineAll

combineLatest

combineLatest: combineLatest

concat

concat: concat

concatAll

concatAll: concatAll

concatMap

concatMap: concatMap

concatMapTo

concatMapTo: concatMapTo

count

count: count

debounce

debounce: debounce

debounceTime

debounceTime: debounceTime

defaultIfEmpty

defaultIfEmpty: defaultIfEmpty

delay

delay: delay

delayWhen

delayWhen: delayWhen

dematerialize

dematerialize: dematerialize

distinct

distinct: distinct

distinctUntilChanged

distinctUntilChanged: distinctUntilChanged

distinctUntilKeyChanged

distinctUntilKeyChanged: distinctUntilKeyChanged

do

do: _do

elementAt

elementAt: elementAt

every

every: every

exhaust

exhaust: exhaust

exhaustMap

exhaustMap: exhaustMap

expand

expand: expand

filter

filter: filter

finally

finally: _finally

find

find: find

findIndex

findIndex: findIndex

first

first: first

flatMap

flatMap: mergeMap

flatMapTo

flatMapTo: mergeMapTo

groupBy

groupBy: groupBy

ignoreElements

ignoreElements: ignoreElements

isEmpty

isEmpty: isEmpty

last

last: last

let

let: letProto

letBind

letBind: letProto

map

map: map

mapTo

mapTo: mapTo

materialize

materialize: materialize

max

max: max

merge

merge: merge

mergeAll

mergeAll: mergeAll

mergeMap

mergeMap: mergeMap

mergeMapTo

mergeMapTo: mergeMapTo

mergeScan

mergeScan: mergeScan

min

min: min

multicast

multicast: multicast

observeOn

observeOn: observeOn

onErrorResumeNext

onErrorResumeNext: onErrorResumeNext

Protected operator

operator: Operator<any, Recipe>

pairwise

pairwise: pairwise

partition

partition: partition

pluck

pluck: pluck

publish

publish: publish

publishBehavior

publishBehavior: publishBehavior

publishLast

publishLast: publishLast

publishReplay

publishReplay: publishReplay

race

race: race

reduce

reduce: reduce

repeat

repeat: repeat

repeatWhen

repeatWhen: repeatWhen

retry

retry: retry

retryWhen

retryWhen: retryWhen

sample

sample: sample

sampleTime

sampleTime: sampleTime

scan

scan: scan

sequenceEqual

sequenceEqual: sequenceEqual

share

share: share

single

single: single

skip

skip: skip

skipUntil

skipUntil: skipUntil

skipWhile

skipWhile: skipWhile

Protected source

source: Observable<any>

startWith

startWith: startWith

subscribeOn

subscribeOn: subscribeOn

switch

switch: _switch

switchMap

switchMap: switchMap

switchMapTo

switchMapTo: switchMapTo

take

take: take

takeLast

takeLast: takeLast

takeUntil

takeUntil: takeUntil

takeWhile

takeWhile: takeWhile

throttle

throttle: throttle

throttleTime

throttleTime: throttleTime

timeInterval

timeInterval: timeInterval

timeout

timeout: timeout

timeoutWith

timeoutWith: timeoutWith

timestamp

timestamp: timestamp

toArray

toArray: toArray

toPromise

toPromise: toPromise

window

window: window

windowCount

windowCount: windowCount

windowTime

windowTime: windowTime

windowToggle

windowToggle: windowToggle

windowWhen

windowWhen: windowWhen

withLatestFrom

withLatestFrom: withLatestFrom

zip

zip: zipProto

zipAll

zipAll: zipAll

Static create

create: Function

Creates a new cold Observable by calling the Observable constructor

static

true

owner

Observable

method

create

param

the subscriber function to be passed to the Observable constructor

returns

a new cold observable

Static if

if: create

Static throw

throw: create

Methods

Protected _subscribe

  • _subscribe(subscriber: Subscriber<any>): TeardownLogic

  • Parameters

    • subscriber: Subscriber<any>

    Returns TeardownLogic

forEach

  • forEach(next: function, PromiseCtor?: PromiseConstructor): Promise<void>
  • method

    forEach

    Parameters

    • next: function

      a handler for each value emitted by the observable

        • Parameters

          Returns void

    • Optional PromiseCtor: PromiseConstructor

    Returns Promise<void>

    a promise that either resolves on observable completion or rejects with the handled error

lift

  • lift<R>(operator: Operator<Recipe, R>): Observable<R>

  • Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.

    method

    lift

    Type parameters

    • R

    Parameters

    • operator: Operator<Recipe, R>

      the operator defining the operation to take on the observable

    Returns Observable<R>

    a new observable with the Operator applied

subscribe

  • subscribe(): Subscription
  • subscribe(observer: PartialObserver): Subscription
  • subscribe(next?: function, error?: function, complete?: function): Subscription

  • Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream

    method

    subscribe

    Returns Subscription

    a subscription reference to the registered handlers

  • Parameters

    • observer: PartialObserver

    Returns Subscription

  • Parameters

    • Optional next: function

        • Parameters

          Returns void

    • Optional error: function
        • (error: any): void

        • Parameters

          • error: any

          Returns void

    • Optional complete: function
        • (): void

        • Returns void

    Returns Subscription

Generated using TypeDoc