Trait/Object

io.scalajs.npm.rx

Observable

Related Docs: object Observable | package rx

Permalink

trait Observable[T] extends Object

Represents an RxJs observable

Annotations
@RawJSType() @native()
Linear Supertypes
Object, Any, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Observable
  2. Object
  3. Any
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. def all(predicate: Function, thisArg: Function = js.native): Observable[T]

    Permalink

    Determines whether all elements of an observable sequence satisfy a condition.

    Determines whether all elements of an observable sequence satisfy a condition.

    predicate

    (Function): A function to test each element for a condition.

    thisArg

    (Function): Object to use as this when executing callback.

    returns

    An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.

    Example:
    1. Rx.Observable.prototype.every(predicate, [thisArg])

    See also

    Observable.every()

  5. def amb(rightSource: Observable[T]): Observable[T]

    Permalink

    Propagates the observable sequence that reacts first.

    Propagates the observable sequence that reacts first.

    rightSource

    (Observable): Second observable sequence.

    returns

    An observable sequence that surfaces either of the given sequences, whichever reacted first.

    Example:
    1. Rx.Observable.prototype.amb(rightSource)

  6. def and(rightSource: Observable[T]): Pattern[T]

    Permalink

    Propagates the observable sequence that reacts first.

    Propagates the observable sequence that reacts first.

    rightSource

    (Observable): Observable sequence to match with the current sequence.

    returns

    (Pattern): Pattern object that matches when both observable sequences have an available value.

    Example:
    1. Rx.Observable.prototype.and(rightSource)

  7. def any(predicate: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.

    Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.

    predicate

    (Function): A function to test each element for a condition.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): An observable sequence containing a single element determining whether one of the elements in the source sequence pass the test in the specified predicate.

    Example:
    1. Rx.Observable.prototype.any([predicate], [thisArg])

    See also

    Observable.some()

  8. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  9. def asObservable(): Observable[T]

    Permalink

    Hides the identity of an observable sequence.

    Hides the identity of an observable sequence.

    returns

    (Observable): An observable sequence that hides the identity of the source sequence.

    Example:
    1. Rx.Observable.asObservable()

  10. def average(selector: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Computes the average of an observable sequence of values that are in the sequence or obtained by invoking a transform function on each element of the input sequence if present.

    Computes the average of an observable sequence of values that are in the sequence or obtained by invoking a transform function on each element of the input sequence if present.

    selector

    (Function): A transform function to apply to each element.

    thisArg

    (Any): Object to use as this when executing selector.

    returns

    (Observable): An observable sequence containing a single element with the average of the sequence of values.

    Example:
    1. Rx.Observable.prototype.average([selector], [thisArg])

  11. def buffer(bufferClosingSelector: Function = js.native): Observable[T]

    Permalink

    The buffer method periodically gathers items emitted by a source Observable into buffers, and emits these buffers as its own emissions.

    The buffer method periodically gathers items emitted by a source Observable into buffers, and emits these buffers as its own emissions.

    Note that if the source Observable issues an onError notification, buffer will pass on this notification immediately without first emitting the buffer it is in the process of assembling, even if that buffer contains items that were emitted by the source Observable before it issued the error notification.

    returns

    (Observable): An observable sequence of windows.

    Example:
    1. Rx.Observable.prototype.buffer([bufferClosingSelector])

  12. def bufferWithCount(count: Function, skip: Function = js.native): Observable[T]

    Permalink

    Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.

    Projects each element of an observable sequence into zero or more buffers which are produced based on element count information.

    count

    (Function): Length of each buffer.

    skip

    (Function): Number of elements to skip between creation of consecutive buffers. If not provided, defaults to the count.

    returns

    (Observable): An observable sequence of buffers.

    Example:
    1. Rx.Observable.prototype.bufferWithCount(count, [skip])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/bufferwithcount.md

  13. def catch(args: |[Array[Observable[T]], Observable[T]]*): Observable[T]

    Permalink

    Continues an observable sequence that is terminated by an exception with the next observable sequence.

    Continues an observable sequence that is terminated by an exception with the next observable sequence.

    args

    (Array | arguments): Observable sequences to catch exceptions for.

    returns

    (Observable): An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.

    Example:
    1. Rx.Observable.catch(...args)

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/catch.md

  14. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  15. def combineLatest(args: |[Array[Observable[T]], Observable[T]]*): Observable[T]

    Permalink

    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. This can be in the form of an argument list of observables or an array. If the result selector is omitted, a list with the elements will be yielded.

    args

    (arguments | Array): An array or arguments of Observable sequences.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.

    Example:
    1. Rx.Observable.combineLatest(...args, [resultSelector])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/combinelatest.md

  16. def combineLatest(args: Array[Observable[T]], resultSelector: Function = js.native): Observable[T]

    Permalink

    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element.

    Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. This can be in the form of an argument list of observables or an array. If the result selector is omitted, a list with the elements will be yielded.

    args

    (arguments | Array): An array or arguments of Observable sequences.

    resultSelector

    (Function): Function to invoke whenever either of the sources produces an element. If omitted, a list with the elements will be yielded.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.

    Example:
    1. Rx.Observable.combineLatest(...args, [resultSelector])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/combinelatest.md

  17. def concat(args: |[Array[Observable[T]], Observable[T]]*): Observable[T]

    Permalink

    Concatenates all the observable sequences.

    Concatenates all the observable sequences. This takes in either an array or variable arguments to concatenate.

    args

    (arguments | Array): An array or arguments of Observable sequences.

    returns

    (Observable): An observable sequence that contains the elements of each given sequence, in sequential order.

    Example:
    1. Rx.Observable.prototype.concat(...args)

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/concatproto.md

  18. def concatAll(): Observable[T]

    Permalink

    Concatenates a sequence of observable sequences or promises into a single observable sequence.

    Concatenates a sequence of observable sequences or promises into a single observable sequence.

    returns

    (Observable): The observable sequence that merges the elements of the inner sequences.

    Example:
    1. Rx.Observable.prototype.concatAll()

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/concatall.md

  19. def concatMap(selector: |[|[Function, Iterator[_]], Promise[_]], resultSelector: Function = js.native, thisArg: Any = js.native): Observable[T]

    Permalink

    This is an alias for the selectConcat method.

    This is an alias for the selectConcat method. This can be one of the following:

    Projects each element of an observable sequence to an observable sequence and concatenates the resulting observable sequences or Promises or array/iterable into one observable sequence.

    source.concatMap(function (x, i) { return Rx.Observable.range(0, x); });
    source.concatMap(function (x, i) { return Promise.resolve(x + 1); });
    source.concatMap(function (x, i) { return [x, i]; });

    Projects each element of an observable sequence or Promise to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and concatenates the results into one observable sequence.

    source.concatMap(function (x, i) { return Rx.Observable.range(0, x); }, function (x, y, ix, iy) { return x + y + ix + iy; });
    source.concatMap(function (x, i) { return Promise.resolve(x + i); }, function (x, y, ix, iy) { return x + y + ix + iy; });
    source.concatMap(function (x, i) { return [x, i];  }, function (x, y, ix, iy) { return x + y + ix + iy; });

    Projects each element of the source observable sequence to the other observable sequence or Promise or array/iterable and merges the resulting observable sequences into one observable sequence.

    source.concatMap(Rx.Observable.of(1,2,3));
    source.concatMap(Promise.resolve(42));
    source.concatMap([1,2,3]);
    selector

    (Function | Iterable | Promise): An Object to project to the sequence or a transform function to apply to each element or an observable sequence to project each element from the source sequence onto. The selector is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    resultSelector

    [resultSelector] (Function): A transform function to apply to each element of the intermediate sequence. The resultSelector is called with the following information:

    • the value of the outer element
    • the value of the inner element
    • the index of the outer element
    • the index of the inner element
    thisArg

    (Any): If resultSelector is not Function, Object to use as this when executing selector.

    returns

    (Observable): An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.

    Example:
    1. Rx.Observable.prototype.concatMap(selector, [resultSelector], [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/concatmap.md

  20. def defaultIfEmpty(defaultValue: Any = js.native): Observable[T]

    Permalink

    Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty.

    Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty.

    defaultValue

    [defaultValue=null] (Any): The value to return if the sequence is empty. If not provided, this defaults to null.

    returns

    (Observable): An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself.

    Example:
    1. Rx.Observable.prototype.defaultIfEmpty([defaultValue])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/defaultifempty.md

  21. def distinct(keySelector: Function = js.native, comparer: Function = js.native): Observable[T]

    Permalink

    Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer.

    Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large.

    keySelector

    (Function): A function to compute the comparison key for each element.

    comparer

    (Function): Used to compare objects for equality. If not provided, defaults to an equality comparer function.

    returns

    (Observable): An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence.

    Example:
    1. Rx.Observable.prototype.distinct([keySelector], [comparer])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/distinct.md

  22. def distinctUntilChanged(keySelector: Function = js.native, comparer: Function = js.native): Observable[T]

    Permalink

    Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.

    Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.

    keySelector

    (Function): A function to compute the comparison key for each element. If not provided, it projects the value.

    comparer

    (Function): Equality comparer for computed key values. If not provided, defaults to an equality comparer function.

    returns

    (Observable): An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence.

    Example:
    1. Rx.Observable.prototype.distinctUntilChanged([keySelector], [comparer])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/distinctuntilchanged.md

  23. def do(observer: Observer = js.native, onNext: Function = js.native, onError: Function = js.native, onCompleted: Function = js.native): Observable[T]

    Permalink

    Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.

    Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    There is an alias to this method doAction for browsers < IE9 and tap as well.

    observer

    (Observer): An observer to invoke for each element in the observable sequence.

    onNext

    (Function): Function to invoke for each element in the observable sequence.

    onError

    (Function): Function to invoke upon exceptional termination of the observable sequence. Used if only the first parameter is also a function.

    onCompleted

    (Function): Function to invoke upon graceful termination of the observable sequence. Used if only the first parameter is also a function.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.do([observer] | [onNext], [onError], [onCompleted])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/do.md

  24. def doOnCompleted(onCompleted: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Invokes an action upon graceful termination of the observable sequence.

    Invokes an action upon graceful termination of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    onCompleted

    (Function): Function to invoke upon graceful termination of the observable sequence.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.doOnCompleted(onCompleted, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/dooncompleted.md

  25. def doOnError(onError: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Invokes an action upon exceptional termination of the observable sequence.

    Invokes an action upon exceptional termination of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    onError

    (Function): Function to invoke upon exceptional termination of the observable sequence.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.doOnError(onError, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/doonerror.md

  26. def doOnNext(onNext: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Invokes an action for each element of the observable sequence.

    Invokes an action for each element of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    onNext

    (Function): Function to invoke for each element in the observable sequence.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.doOnNext(onNext, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/doonnext.md

  27. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  28. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  29. def every(predicate: Function, thisArg: Function = js.native): Observable[T]

    Permalink

    Determines whether all elements of an observable sequence satisfy a condition.

    Determines whether all elements of an observable sequence satisfy a condition.

    predicate

    (Function): A function to test each element for a condition.

    thisArg

    (Function): Object to use as this when executing callback.

    returns

    An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.

    Example:
    1. Rx.Observable.prototype.every(predicate, [thisArg])

  30. def filter(predicate: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Filters the elements of an observable sequence based on a predicate.

    Filters the elements of an observable sequence based on a predicate.

    predicate

    predicate (Function): A function to test each source element for a condition. The callback is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    thisArg

    (Any): Object to use as this when executing the predicate.

    returns

    An observable sequence that contains elements from the input sequence that satisfy the condition.

    Example:
    1. Rx.Observable.prototype.filter(predicate, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/where.md

  31. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  32. def finally(action: Function): Observable[T]

    Permalink

    Invokes a specified action after the source observable sequence terminates gracefully or exceptionally.

    Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. There is an alias called finallyAction for browsers < IE9

    action

    (Function): A function to invoke after the source observable sequence terminates.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.finally(action)

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/finally.md

  33. def flatMap[A, B](selector: Function, resultSelector: Function4[A, A, Int, Int, B] = js.native): Observable[B]

    Permalink

    Aliases: Rx.Observable.prototype.flatMap and Rx.Observable.prototype.selectMany are equivalent.

    Aliases: Rx.Observable.prototype.flatMap and Rx.Observable.prototype.selectMany are equivalent.

    selector

    selector (Function | Iterable | Promise): An Object to project to the sequence or a transform function to apply to each element or an observable sequence to project each element from the source sequence onto. The selector is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    resultSelector

    (Function): A transform function to apply to each element of the intermediate sequence. The resultSelector is called with the following information:

    • the value of the outer element
    • the value of the inner element
    • the index of the outer element
    • the index of the inner element
    returns

    An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.

    Example:
    1. Rx.Observable.prototype.flatMap(selector, [resultSelector])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/selectmany.md

  34. def flatMapLatest(selector: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable.

    Transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable.

    The flatMapLatest operator is similar to the flatMap and concatMap methods described above, however, rather than emitting all of the items emitted by all of the Observables that the operator generates by transforming items from the source Observable, flatMapLatest instead emits items from each such transformed Observable only until the next such Observable is emitted, then it ignores the previous one and begins emitting items emitted by the new one.

    selector

    (Function): A transform function to apply to each source element. The callback has the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    thisArg

    (Any): Object to use as this when executing the predicate.

    returns

    (Observable): An observable sequence which transforms the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable.

    Example:
    1. Rx.Observable.prototype.flatMapLatest(selector, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/flatmaplatest.md

  35. def flatMapObserver(onNext: Function, onError: Function, onCompleted: Function, thisArg: Any): Observable[T]

    Permalink

    Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

    Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

    onNext

    (Function): A transform function to apply to each element. The selector is called with the following information:

    • the value of the element
    • the index of the element
    onError

    (Function): A transform function to apply when an error occurs in the source sequence.

    onCompleted

    (Function): A transform function to apply when the end of the source sequence is reached.

    thisArg

    (Any): Object to use as this when executing the transform functions.

    returns

    (Observable): An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.

    Example:
    1. Rx.Observable.prototype.flatMapObserver(onNext, onError, onCompleted, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/flatmapobserver.md

  36. def forEach(onNext: |[Function, Observable[T]], onError: Function = js.native, onCompleted: Function = js.native): Disposable

    Permalink

    Subscribes an observer to the observable sequence.

    Subscribes an observer to the observable sequence.

    onNext

    (Function | Observable): Function to invoke for each element in the observable sequence.

    onError

    (Function): Function to invoke upon exceptional termination of the observable sequence.

    onCompleted

    (Function): Function to invoke upon graceful termination of the observable sequence.

    returns

    (Disposable): The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler.

    Example:
    1. Rx.Observable.prototype.forEach([observer] | [onNext], [onError], [onCompleted])

  37. def forkJoin(args: |[Array[Observable[T]], Observable[T]]*): Observable[T]

    Permalink

    Runs all observable sequences in parallel and collect their last elements.

    Runs all observable sequences in parallel and collect their last elements.

    args

    (Arguments | Array): An array or arguments of Observable sequences or Promises to collect the last elements for.

    returns

    (Observable): An observable sequence with an array collecting the last elements of all the input sequences or the result of the result selector if specified.

  38. def forkJoin(args: Array[Observable[T]], resultSelector: Function): Observable[T]

    Permalink

    Runs all observable sequences in parallel and collect their last elements.

    Runs all observable sequences in parallel and collect their last elements.

    args

    (Arguments | Array): An array or arguments of Observable sequences or Promises to collect the last elements for.

    resultSelector

    (Function): The result selector from all the values produced. If not specified, forkJoin will return the results as an array.

    returns

    (Observable): An observable sequence with an array collecting the last elements of all the input sequences or the result of the result selector if specified.

  39. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  40. def hasOwnProperty(v: String): Boolean

    Permalink
    Definition Classes
    Object
  41. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  42. def ignoreElements(): Observable[T]

    Permalink

    Ignores all elements in an observable sequence leaving only the termination messages.

    Ignores all elements in an observable sequence leaving only the termination messages.

    returns

    (Observable): An empty observable sequence that signals termination, successful or exceptional, of the source sequence.

    Example:
    1. Rx.Observable.prototype.ignoreElements()

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/ignoreelements.md

  43. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  44. def isPrototypeOf(v: Object): Boolean

    Permalink
    Definition Classes
    Object
  45. def map[S](selector: |[Function, Any], thisArg: Any = js.native): Observable[S]

    Permalink

    Projects each element of an observable sequence into a new form by incorporating the element's index.

    Projects each element of an observable sequence into a new form by incorporating the element's index. There is an alias for this method called map.

    selector

    (Function | Object): Transform function to apply to each source element or an element to yield. If selector is a function, it is called with the following information:

    thisArg

    (Any): Object to use as this when executing the predicate.

    returns

    An observable sequence which results from the co-monadic bind operation.

    Example:
    1. Rx.Observable.prototype.map(selector, [thisArg])

  46. def merge(other: Observable[T]): Observable[T]

    Permalink

    Merges an observable sequence of observable sequences into an observable sequence, limiting the number of concurrent subscriptions to inner sequences.

    Merges an observable sequence of observable sequences into an observable sequence, limiting the number of concurrent subscriptions to inner sequences. Or merges two observable sequences into a single observable sequence.

    other

    (Observable): The second observable sequence to merge into the first.

    returns

    (Observable): The observable sequence that merges the elements of the inner sequences.

    Example:
    1. Rx.Observable.prototype.merge(maxConcurrent | other)

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/mergeproto.md

  47. def merge(maxConcurrent: Int): Observable[T]

    Permalink

    Merges an observable sequence of observable sequences into an observable sequence, limiting the number of concurrent subscriptions to inner sequences.

    Merges an observable sequence of observable sequences into an observable sequence, limiting the number of concurrent subscriptions to inner sequences. Or merges two observable sequences into a single observable sequence.

    maxConcurrent

    (Number): Maximum number of inner observable sequences being subscribed to concurrently.

    returns

    (Observable): The observable sequence that merges the elements of the inner sequences.

    Example:
    1. Rx.Observable.prototype.merge(maxConcurrent | other)

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/mergeproto.md

  48. def mergeAll(): T

    Permalink

    Merges an observable sequence of observable sequences into an observable sequence.

    Merges an observable sequence of observable sequences into an observable sequence.

    returns

    (Observable): The observable sequence that merges the elements of the inner sequences.

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/mergeall.md

  49. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  50. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  51. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  52. def partition(predicate: Function, thisArg: Any = js.native): Array[Observable[T]]

    Permalink

    Returns two observables which partition the observations of the source by the given function.

    Returns two observables which partition the observations of the source by the given function. The first will trigger observations for those values for which the predicate returns true. The second will trigger observations for those values where the predicate returns false. The predicate is executed once for each subscribed observer. Both also propagate all error observations arising from the source and each completes when the source completes.

    predicate

    (Function): Selector function to invoke for each produced element, resulting in another sequence to which the selector will be invoked recursively again. The callback is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    thisArg

    (Any): Object to use as this when executing the predicate.

    returns

    (Array): An array of observables. The first triggers when the predicate returns true, and the second triggers when the predicate returns false.

    Example:
    1. Rx.Observable.prototype.partition(predicate, [thisArg])

  53. def pausable(pauser: Observable[T]): Observable[T]

    Permalink

    Pauses the underlying observable sequence based upon the observable sequence which yields true/false.

    Pauses the underlying observable sequence based upon the observable sequence which yields true/false. Note that this only works on hot observables.

    pauser

    (Observable): The observable sequence used to pause the underlying sequence.

    returns

    (Observable): The observable sequence which is paused based upon the pauser.

    Example:
    1. Rx.Observable.prototype.pausable(pauser)

  54. def pausableBuffered(pauser: Observable[T]): Observable[T]

    Permalink

    Pauses the underlying observable sequence based upon the observable sequence which yields true/false, and yields the values that were buffered while paused.

    Pauses the underlying observable sequence based upon the observable sequence which yields true/false, and yields the values that were buffered while paused. Note that this only works on hot observables.

    pauser

    (Observable): The observable sequence used to pause the underlying sequence.

    returns

    (Observable): The observable sequence which is paused based upon the pauser.

    Example:
    1. Rx.Observable.prototype.pausableBuffered(pauser)

  55. def pluck(property: String): Observable[T]

    Permalink

    Returns an Observable containing the value of a specified nested property from all elements in the Observable sequence.

    Returns an Observable containing the value of a specified nested property from all elements in the Observable sequence. If a property can't be resolved, it will return undefined for that value.

    property

    (String): The property or properties to pluck. pluck accepts an unlimited number of nested property parameters.

    returns

    (Observable): Returns a new Observable sequence of property values.

    Example:
    1. Rx.Observable.prototype.pluck(property)

  56. def propertyIsEnumerable(v: String): Boolean

    Permalink
    Definition Classes
    Object
  57. def publish(selector: Function = js.native): ConnectableObservable[T]

    Permalink

    Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.

    Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.

    selector

    (Function): Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on.

    returns

    (ConnectableObservable): An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.

    Example:
    1. Rx.Observable.prototype.publish([selector])

  58. def reduce(accumulator: Function, seed: Any = js.native): Observable[T]

    Permalink

    Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence.

    Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.

    For aggregation behavior with incremental intermediate results, see the scan method.

    accumulator

    (Function): An accumulator function to be invoked on each element with the following arguments:

    • acc: Any - the accumulated value.
    • currentValue: Any - the current value
    • index: Number - the current index
    • source: Observable - the current observable instance
    seed

    (Any): The initial accumulator value.

    returns

    An observable sequence containing a single element with the final accumulator value.

    Example:
    1. Rx.Observable.prototype.reduce(accumulator, [seed])

  59. def repeat(value: Any, repeatCount: Int = js.native, scheduler: Scheduler = js.native): Observable[T]

    Permalink

    Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages.

    Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages.

    value

    (Any): Element to repeat.

    repeatCount

    (Number):Number of times to repeat the element. If not specified, repeats indefinitely.

    scheduler

    [scheduler=Rx.Scheduler.immediate] (Scheduler): Scheduler to run the producer loop on. If not specified, defaults to Scheduler.immediate.

    returns

    (Observable): An observable sequence that repeats the given element the specified number of times.

    Example:
    1. Rx.Observable.repeat(value, [repeatCount], [scheduler])

  60. def scan(accumulator: Function, seed: Any = js.native): Observable[T]

    Permalink

    Applies an accumulator function over an observable sequence and returns each intermediate result.

    Applies an accumulator function over an observable sequence and returns each intermediate result. The optional seed value is used as the initial accumulator value.

    accumulator

    accumulator (Function): An accumulator function to be invoked on each element with the following arguments:

    • acc: Any - the accumulated value.
    • currentValue: Any - the current value
    • index: Number - the current index
    • source: Observable - the current observable instance
    seed

    (Any): The initial accumulator value.

    returns

    An observable sequence which results from the comonadic bind operation.

    Example:
    1. Rx.Observable.prototype.scan(accumulator, [seed])

  61. def select(selector: |[Function, Any], thisArg: Function = js.native): Observable[T]

    Permalink

    Projects each element of an observable sequence into a new form by incorporating the element's index.

    Projects each element of an observable sequence into a new form by incorporating the element's index. There is an alias for this method called map.

    selector

    (Function | Object): Transform function to apply to each source element or an element to yield. If selector is a function, it is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    thisArg

    (Any): Object to use as this when executing the predicate.

    returns

    An observable sequence which results from the co-monadic bind operation.

    Example:
    1. Rx.Observable.prototype.select(selector, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/select.md

  62. def selectConcat(selector: |[|[Function, Iterator[_]], Promise[_]], resultSelector: Function = js.native, thisArg: Any = js.native): Observable[T]

    Permalink

    This is an alias for the selectConcat method.

    This is an alias for the selectConcat method. This can be one of the following:

    Projects each element of an observable sequence to an observable sequence and concatenates the resulting observable sequences or Promises or array/iterable into one observable sequence.

    source.concatMap(function (x, i) { return Rx.Observable.range(0, x); });
    source.concatMap(function (x, i) { return Promise.resolve(x + 1); });
    source.concatMap(function (x, i) { return [x, i]; });

    Projects each element of an observable sequence or Promise to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and concatenates the results into one observable sequence.

    source.concatMap(function (x, i) { return Rx.Observable.range(0, x); }, function (x, y, ix, iy) { return x + y + ix + iy; });
    source.concatMap(function (x, i) { return Promise.resolve(x + i); }, function (x, y, ix, iy) { return x + y + ix + iy; });
    source.concatMap(function (x, i) { return [x, i];  }, function (x, y, ix, iy) { return x + y + ix + iy; });

    Projects each element of the source observable sequence to the other observable sequence or Promise or array/iterable and merges the resulting observable sequences into one observable sequence.

    source.concatMap(Rx.Observable.of(1,2,3));
    source.concatMap(Promise.resolve(42));
    source.concatMap([1,2,3]);
    selector

    (Function | Iterable | Promise): An Object to project to the sequence or a transform function to apply to each element or an observable sequence to project each element from the source sequence onto. The selector is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    resultSelector

    [resultSelector] (Function): A transform function to apply to each element of the intermediate sequence. The resultSelector is called with the following information:

    • the value of the outer element
    • the value of the inner element
    • the index of the outer element
    • the index of the inner element
    thisArg

    (Any): If resultSelector is not Function, Object to use as this when executing selector.

    returns

    (Observable): An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.

    Example:
    1. Rx.Observable.prototype.selectConcat(selector, [resultSelector], [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/concatmap.md

  63. def selectMany(selector: Function, resultSelector: Any = js.native): Observable[T]

    Permalink

    Aliases: Rx.Observable.prototype.flatMap and Rx.Observable.prototype.selectMany are equivalent.

    Aliases: Rx.Observable.prototype.flatMap and Rx.Observable.prototype.selectMany are equivalent.

    selector

    selector (Function | Iterable | Promise): An Object to project to the sequence or a transform function to apply to each element or an observable sequence to project each element from the source sequence onto. The selector is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    resultSelector

    (Function): A transform function to apply to each element of the intermediate sequence. The resultSelector is called with the following information:

    • the value of the outer element
    • the value of the inner element
    • the index of the outer element
    • the index of the inner element
    returns

    An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.

    Example:
    1. Rx.Observable.prototype.selectMany(selector, [resultSelector])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/selectmany.md

  64. def selectManyObserver(onNext: Function, onError: Function, onCompleted: Function, thisArg: Any): Observable[T]

    Permalink

    Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

    Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.

    onNext

    (Function): A transform function to apply to each element. The selector is called with the following information:

    • the value of the element
    • the index of the element
    onError

    (Function): A transform function to apply when an error occurs in the source sequence.

    onCompleted

    (Function): A transform function to apply when the end of the source sequence is reached.

    thisArg

    (Any): Object to use as this when executing the transform functions.

    returns

    (Observable): An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.

    Example:
    1. Rx.Observable.prototype.selectManyObserver(onNext, onError, onCompleted, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/flatmapobserver.md

  65. def single(settings: SingleSettings): Observable[T]

    Permalink

    Returns a single element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.

    Returns a single element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. If no default value is given, then onError will be called. If there are more than one element that matches, then onError will be called.

    settings

    (Object): An object with the following fields:

    1. [predicate] (Function): A predicate function to evaluate for elements in the source sequence. The callback is called with the following information:
      1. the value of the element ii. the index of the element iii. the Observable object being subscribed 2. [thisArg] (Any): Object to use as this when executing the predicate. 3. [defaultValue] (Any): Default value if no such element exists.
    returns

    (Observable): An observable sequence that contains elements from the input sequence that satisfy the condition.

    Example:
    1. Rx.Observable.prototype.single([settings])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/single.md

  66. def single(predicate: Function = js.native, thisArg: Any = js.native, defaultValue: T = js.native): Observable[T]

    Permalink

    Returns a single element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.

    Returns a single element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. If no default value is given, then onError will be called. If there are more than one element that matches, then onError will be called.

    predicate

    (Function): A predicate function to evaluate for elements in the source sequence. The callback is called with the following information:

    1. the value of the element ii. the index of the element iii. the Observable object being subscribed
    thisArg

    (Any): Object to use as this when executing the predicate.

    defaultValue

    (Any): Default value if no such element exists.

    returns

    (Observable): An observable sequence that contains elements from the input sequence that satisfy the condition.

    Example:
    1. Rx.Observable.prototype.single([predicate], [thisArg], [defaultValue])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/single.md

  67. def skip(count: Int): Observable[T]

    Permalink

    Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.

    Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.

    count

    (Number): The number of elements to skip before returning the remaining elements.

    returns

    (Observable): An observable sequence that contains the elements that occur after the specified index in the input sequence.

    Example:
    1. Rx.Observable.prototype.skip(count)

  68. def slice(begin: Int = 0, end: Int = js.native): Observable[T]

    Permalink

    The slice method returns a shallow copy of a portion of an Observable into a new Observable object.

    The slice method returns a shallow copy of a portion of an Observable into a new Observable object. Unlike the Array version, this does not support negative numbers for being or end.

    begin

    (Any): Zero-based index at which to begin extraction. If omitted, this will default to zero.

    end

    (Number): Zero-based index at which to end extraction. slice extracts up to but not including end.

    returns

    (Observable): A shallow copy of a portion of an Observable into a new Observable object.

    Example:
    1. Rx.Observable.prototype.slice([begin], [end])

  69. def some(predicate: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.

    Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.

    predicate

    (Function): A function to test each element for a condition.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): An observable sequence containing a single element determining whether one of the elements in the source sequence pass the test in the specified predicate.

    Example:
    1. Rx.Observable.prototype.some([predicate], [thisArg])

  70. def subscribe(onNext: |[Function, Observable[T]] = js.native, onError: Function = js.native, onCompleted: Function = js.native): Disposable

    Permalink

    Subscribes an observer to the observable sequence.

    Subscribes an observer to the observable sequence.

    onNext

    (Observer/Function): The object that is to receive notifications.

    onError

    (Function): Function to invoke upon exceptional termination of the observable sequence.

    onCompleted

    (Function): Function to invoke upon graceful termination of the observable sequence.

    returns

    (Disposable): The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler.

    Example:
    1. Rx.Observable.prototype.subscribe([observer] | [onNext], [onError], [onCompleted])

  71. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  72. def take(count: Int, scheduler: Scheduler = js.native): Observable[T]

    Permalink

    Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of take(0).

    Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of take(0).

    count

    (Number): The number of elements to return.

    scheduler

    (Scheduler): Scheduler used to produce an onCompleted message in case count is set to 0.

    returns

    (Observable): An observable sequence that contains the elements before and including the specified index in the input sequence.

    Example:
    1. Rx.Observable.prototype.take(count, [scheduler])

  73. def takeLast(count: Int): Observable[T]

    Permalink

    Returns a specified number of contiguous elements from the end of an observable sequence, using an optional scheduler to drain the queue.

    Returns a specified number of contiguous elements from the end of an observable sequence, using an optional scheduler to drain the queue. * This operator accumulates a buffer with a length enough to store elements count elements. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed.

    count

    (Number): Number of elements to bypass at the end of the source sequence.

    returns

    (Observable): An observable sequence containing the source sequence elements except for the bypassed ones at the end.

    Example:
    1. Rx.Observable.prototype.takeLast(count)

  74. def takeLastBuffer(count: Int): Observable[T]

    Permalink

    Returns an array with the specified number of contiguous elements from the end of an observable sequence.

    Returns an array with the specified number of contiguous elements from the end of an observable sequence.

    count

    (Number): Number of elements to bypass at the end of the source sequence.

    returns

    (Observable): An observable sequence containing a single array with the specified number of elements from the end of the source sequence.

    Example:
    1. Rx.Observable.prototype.takeLastBuffer(count)

  75. def takeLastBufferWithTime(duration: Int, scheduler: Scheduler = js.native): Observable[T]

    Permalink

    Returns an array with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.

    Returns an array with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers.

    This operator accumulates a queue with a length enough to store elements received during the initial duration window. As more elements are received, elements older than the specified duration are taken from the queue and produced on the result sequence. This causes elements to be delayed with duration.

    duration

    (Number): Duration for taking elements from the end of the sequence.

    scheduler

    [scheduler=Rx.Scheduler.timeout] (Scheduler): Scheduler to run the timer on. If not specified, defaults to timeout scheduler.

    returns

    (Observable): An observable sequence containing a single array with the elements taken during the specified duration from the end of the source sequence.

    Example:
    1. Rx.Observable.prototype.takeLastBufferWithTime(duration, [scheduler])

  76. def takeLastWithTime(duration: Int, timeScheduler: Scheduler, loopScheduler: Scheduler = js.native): Observable[T]

    Permalink

    Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements.

    Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements.

    duration

    (Number): Duration for taking elements from the end of the sequence.

    timeScheduler

    [timeScheduler=Rx.Scheduler.timeout] (Scheduler): Scheduler to run the timer on. If not specified, defaults to timeout scheduler.

    loopScheduler

    [loopScheduler=Rx.Scheduler.currentThread] (Scheduler): Scheduler to drain the collected elements. If not specified, defaults to current thread scheduler.

    returns

    (Observable): An observable sequence with the elements taken during the specified duration from the end of the source sequence.

    Example:
    1. Rx.Observable.prototype.takeLastWithTime(duration, [timeScheduler], [loopScheduler])

  77. def takeUntil(other: |[Observable[T], Promise[T]]): Observable[T]

    Permalink

    Returns the values from the source observable sequence until the other observable sequence or Promise produces a value.

    Returns the values from the source observable sequence until the other observable sequence or Promise produces a value.

    other

    (Observable | Promise): Observable sequence or Promise that terminates propagation of elements of the source sequence.

    returns

    (Observable): An observable sequence containing the elements of the source sequence up to the point the other sequence or Promise interrupted further propagation.

    Example:
    1. Rx.Observable.prototype.takeUntil([other])

  78. def takeWhile(predicate: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Returns elements from an observable sequence as long as a specified condition is true.

    Returns elements from an observable sequence as long as a specified condition is true.

    predicate

    (Function): A function to test each source element for a condition. The callback is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed.
    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.

    Example:
    1. Rx.Observable.prototype.takeWhile(predicate, [thisArg])

  79. def tap(observer: Observer = js.native, onNext: Function = js.native, onError: Function = js.native, onCompleted: Function = js.native): Observable[T]

    Permalink

    Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.

    Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    There is an alias to this method doAction for browsers < IE9 and tap as well.

    observer

    (Observer): An observer to invoke for each element in the observable sequence.

    onNext

    (Function): Function to invoke for each element in the observable sequence.

    onError

    (Function): Function to invoke upon exceptional termination of the observable sequence. Used if only the first parameter is also a function.

    onCompleted

    (Function): Function to invoke upon graceful termination of the observable sequence. Used if only the first parameter is also a function.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.tap([observer] | [onNext], [onError], [onCompleted])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/do.md

  80. def tapOnCompleted(onCompleted: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Invokes an action upon graceful termination of the observable sequence.

    Invokes an action upon graceful termination of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    onCompleted

    (Function): Function to invoke upon graceful termination of the observable sequence.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.tapOnCompleted(onCompleted, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/dooncompleted.md

  81. def tapOnError(onError: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Invokes an action upon exceptional termination of the observable sequence.

    Invokes an action upon exceptional termination of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    onError

    (Function): Function to invoke upon exceptional termination of the observable sequence.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.tapOnError(onError, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/doonerror.md

  82. def tapOnNext(onNext: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Invokes an action for each element of the observable sequence.

    Invokes an action for each element of the observable sequence.

    This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.

    onNext

    (Function): Function to invoke for each element in the observable sequence.

    thisArg

    (Any): Object to use as this when executing callback.

    returns

    (Observable): The source sequence with the side-effecting behavior applied.

    Example:
    1. Rx.Observable.prototype.tapOnNext(onNext, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/doonnext.md

  83. def toArray(): Observable[Array[T]]

    Permalink

    Creates a list from an observable sequence.

    Creates a list from an observable sequence.

    returns

    (Observable): An observable sequence containing a single element with a list containing all the elements of the source sequence.

    Example:
    1. Rx.Observable.prototype.toArray()

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/toarray.md

  84. def toLocaleString(): String

    Permalink
    Definition Classes
    Object
  85. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  86. def transduce(transducer: |[Transducer, Function]): Observable[T]

    Permalink

    Executes a transducer to transform the observable sequence.

    Executes a transducer to transform the observable sequence.

    Transducers are composable algorithmic transformations. They are independent from the context of their input and output sources and specify only the essence of the transformation in terms of an individual element. Because transducers are decoupled from input or output sources, they can be used in many different processes such as Observable sequences. Transducers compose directly, without awareness of input or creation of intermediate aggregates.

    Such examples of transducers libraries are transducers-js from Cognitect and transducers.js from James Long.

    transducer

    (Transducer): A transducer to execute.

    returns

    (Observable): An observable sequence that results from the transducer execution.

  87. def valueOf(): Any

    Permalink
    Definition Classes
    Object
  88. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  89. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  90. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  91. def where(predicate: Function, thisArg: Any = js.native): Observable[T]

    Permalink

    Filters the elements of an observable sequence based on a predicate.

    Filters the elements of an observable sequence based on a predicate.

    predicate

    predicate (Function): A function to test each source element for a condition. The callback is called with the following information:

    • the value of the element
    • the index of the element
    • the Observable object being subscribed
    thisArg

    (Any): Object to use as this when executing the predicate.

    returns

    An observable sequence that contains elements from the input sequence that satisfy the condition.

    Example:
    1. Rx.Observable.prototype.where(predicate, [thisArg])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/where.md

  92. def windowWithCount(count: Int, skip: Int = js.native): Observable[T]

    Permalink

    Projects each element of an observable sequence into zero or more windows which are produced based on element count information.

    Projects each element of an observable sequence into zero or more windows which are produced based on element count information.

    count

    (Number): Length of each buffer.

    skip

    (Number): Number of elements to skip between creation of consecutive windows. If not provided, defaults to the count.

    returns

    (Observable): An observable sequence of windows.

    Example:
    1. Rx.Observable.prototype.windowWithCount(count, [skip])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/windowwithcount.md

  93. def withLatestFrom(args: Observable[T]*): Observable[T]

    Permalink

    Merges the specified observable sequences into one observable sequence by using the selector function only when the source observable sequence (the instance) produces an element.

    Merges the specified observable sequences into one observable sequence by using the selector function only when the source observable sequence (the instance) produces an element. The other observables can be in the form of an argument list of observables or an array. If the result selector is omitted, a list with the elements will be yielded.

    args

    (arguments | Array): An array or arguments of Observable sequences.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.

    Example:
    1. Rx.Observable.prototype.withLatestFrom(...args, [resultSelector])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/withlatestfrom.md

  94. def withLatestFrom(args: Array[Observable[T]], resultSelector: Function = js.native): Observable[T]

    Permalink

    Merges the specified observable sequences into one observable sequence by using the selector function only when the source observable sequence (the instance) produces an element.

    Merges the specified observable sequences into one observable sequence by using the selector function only when the source observable sequence (the instance) produces an element. The other observables can be in the form of an argument list of observables or an array. If the result selector is omitted, a list with the elements will be yielded.

    args

    (arguments | Array): An array or arguments of Observable sequences.

    resultSelector

    (Function): Function to invoke when the instance source observable produces an element. If omitted, a list with the elements will be yielded.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.

    Example:
    1. Rx.Observable.prototype.withLatestFrom(...args, [resultSelector])

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/withlatestfrom.md

  95. def zip(args: Any*): Observable[T]

    Permalink

    Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    args

    (Arguments | Array): Arguments or an array of observable sequences.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.

    Example:
    1. Rx.Observable.prototype.zip(...args, [resultSelector])

  96. def zip(args: Array[Observer], resultSelector: Function = js.native): Observable[T]

    Permalink

    Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    Merges the specified observable sequences or Promises into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    args

    (Arguments | Array): Arguments or an array of observable sequences.

    resultSelector

    (Function): A function which takes the inputs at the specified index and combines them together. If omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function.

    Example:
    1. Rx.Observable.prototype.zip(...args, [resultSelector])

  97. def zipIterable(args: Any*): Observable[T]

    Permalink

    Merges the current observable sequence with iterables such as Map, Array, Set into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    Merges the current observable sequence with iterables such as Map, Array, Set into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    args

    (Arguments): Arguments of Arrays, Maps, Sets or other iterables.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function. If omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.

    Example:
    1. Rx.Observable.prototype.zipIterable(...args, [resultSelector])

  98. def zipIterable(args: Array[Observer], resultSelector: Function = js.native): Observable[T]

    Permalink

    Merges the current observable sequence with iterables such as Map, Array, Set into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    Merges the current observable sequence with iterables such as Map, Array, Set into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.

    args

    (Arguments): Arguments of Arrays, Maps, Sets or other iterables.

    resultSelector

    (Function): A function which takes the inputs at the specified index and combines them together. If omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.

    returns

    (Observable): An observable sequence containing the result of combining elements of the sources using the specified result selector function. If omitted, a list with the elements of the observable sequences at corresponding indexes will be yielded.

    Example:
    1. Rx.Observable.prototype.zipIterable(...args, [resultSelector])

Deprecated Value Members

  1. def concatObservable(): Observable[T]

    Permalink

    Concatenates a sequence of observable sequences or promises into a single observable sequence.

    Concatenates a sequence of observable sequences or promises into a single observable sequence.

    returns

    (Observable): The observable sequence that merges the elements of the inner sequences.

    Annotations
    @deprecated
    Deprecated

    (Since version 4.0) Use concatAll()

    Example:
    1. Rx.Observable.prototype.concatObservable()

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/concatall.md

  2. def mergeObservable(): T

    Permalink

    Merges an observable sequence of observable sequences into an observable sequence.

    Merges an observable sequence of observable sequences into an observable sequence.

    returns

    (Observable): The observable sequence that merges the elements of the inner sequences.

    Annotations
    @deprecated
    Deprecated

    (Since version 4.0) Use Rx.Observable.mergeAll() instead

    See also

    https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/mergeall.md

Inherited from Object

Inherited from Any

Inherited from AnyRef

Inherited from Any

Ungrouped