Options
All
  • Public
  • Public/Protected
  • All
Menu

Class RxjsPipeline

A pipeline implemented using Rx.js

author

Thomas Minier

Hierarchy

Index

Methods

Methods

bufferCount

  • bufferCount<T>(input: Observable<T>, count: number): Observable<T[]>

catch

  • catch<T, O>(input: Observable<T>, handler?: undefined | function): Observable<T | O>

clone

  • clone<T>(stage: Observable<T>): Observable<T>

collect

  • collect<T>(input: Observable<T>): Observable<T[]>

defaultValues

  • defaultValues<T>(input: Observable<T>, ...values: T[]): Observable<T>

distinct

  • distinct<T, K>(input: Observable<T>, selector?: undefined | function): Observable<T>

empty

  • empty<T>(): Observable<T>

endWith

  • endWith<T>(input: Observable<T>, values: T[]): Observable<T>

filter

  • filter<T>(input: Observable<T>, predicate: function): Observable<T>

finalize

  • finalize<T>(input: Observable<T>, callback: function): Observable<T>

first

  • first<T>(input: Observable<T>): Observable<T>

flatMap

  • flatMap<F, T>(input: Observable<F>, mapper: function): Observable<T>

flatten

forEach

  • forEach<T>(input: Observable<T>, cb: function): void

from

  • from(x: any): Observable<any>

fromAsync

  • fromAsync<T>(cb: function): Observable<T>

groupBy

  • groupBy<T, K, R>(input: PipelineStage<T>, keySelector: function, elementSelector?: undefined | function): PipelineStage<[K, R[]]>

  • Groups the items produced by a pipeline according to a specified criterion, and emits the resulting groups

    Type parameters

    • T

    • K

    • R

    Parameters

    • input: PipelineStage<T>

      Input PipelineStage

    • keySelector: function

      A function that extracts the grouping key for each item

        • (value: T): K

        • Parameters

          • value: T

          Returns K

    • Optional elementSelector: undefined | function

      (optional) A function that transforms items before inserting them in a group

    Returns PipelineStage<[K, R[]]>

limit

  • limit<T>(input: Observable<T>, stopAfter: number): Observable<T>

map

  • map<F, T>(input: Observable<F>, mapper: function): Observable<T>

max

  • Find the smallest value produced by a pipeline of iterators. It takes a ranking function as input, which is invoked with (x, y) and must returns True if x > y and False otherwise. Warning: this function needs to materialize all values of the pipeline.

    Type parameters

    • T

    Parameters

    • input: PipelineStage<T>

      Input PipelineStage

    • Optional ranking: undefined | function

    Returns PipelineStage<T>

    A pipeline stage that emits the highest value found

merge

  • merge<T>(...inputs: Array<Observable<T>>): Observable<T>

mergeMap

  • mergeMap<F, T>(input: Observable<F>, mapper: function): Observable<T>

min

  • Find the smallest value produced by a pipeline of iterators. It takes a ranking function as input, which is invoked with (x, y) and must returns True if x < y and False otherwise. Warning: this function needs to materialize all values of the pipeline.

    Type parameters

    • T

    Parameters

    • input: PipelineStage<T>

      Input PipelineStage

    • Optional ranking: undefined | function

    Returns PipelineStage<T>

    A pipeline stage that emits the lowest value found

of

  • of<T>(...values: T[]): Observable<T>

peekIf

  • peekIf<T, O>(input: PipelineStage<T>, count: number, predicate: function, ifCase: function, elseCase: function): PipelineStage<O>

  • Peek values from the input pipeline stage, and use them to decide between two candidate pipeline stages to continue the pipeline.

    Type parameters

    • T

    • O

    Parameters

    • input: PipelineStage<T>

      Input pipeline stage

    • count: number

      How many items to peek from the input?

    • predicate: function

      Predicate function invoked with the values

        • (values: T[]): boolean

        • Parameters

          • values: T[]

          Returns boolean

    • ifCase: function

      Callback invoked if the predicate function evaluates to True

    • elseCase: function

      Callback invoked if the predicate function evaluates to False

    Returns PipelineStage<O>

    A pipeline stage

reduce

  • reduce<F, T>(input: Observable<F>, reducer: function, initial: T): Observable<T>

skip

  • skip<T>(input: Observable<T>, toSkip: number): Observable<T>

tap

  • tap<T>(input: Observable<T>, cb: function): Observable<T>

Generated using TypeDoc