Opal-Estate-Pro/node_modules/rxjs/_esm2015/operators/mergeMapTo.js
2019-09-13 11:27:52 +07:00

140 lines
5.3 KiB
JavaScript
Executable File

import { OuterSubscriber } from '../OuterSubscriber';
import { subscribeToResult } from '../util/subscribeToResult';
/* tslint:enable:max-line-length */
/**
* Projects each source value to the same Observable which is merged multiple
* times in the output Observable.
*
* <span class="informal">It's like {@link mergeMap}, but maps each value always
* to the same inner Observable.</span>
*
* <img src="./img/mergeMapTo.png" width="100%">
*
* Maps each source value to the given Observable `innerObservable` regardless
* of the source value, and then merges those resulting Observables into one
* single Observable, which is the output Observable.
*
* @example <caption>For each click event, start an interval Observable ticking every 1 second</caption>
* var clicks = Rx.Observable.fromEvent(document, 'click');
* var result = clicks.mergeMapTo(Rx.Observable.interval(1000));
* result.subscribe(x => console.log(x));
*
* @see {@link concatMapTo}
* @see {@link merge}
* @see {@link mergeAll}
* @see {@link mergeMap}
* @see {@link mergeScan}
* @see {@link switchMapTo}
*
* @param {ObservableInput} innerObservable An Observable to replace each value from
* the source Observable.
* @param {function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any} [resultSelector]
* A function to produce the value on the output Observable based on the values
* and the indices of the source (outer) emission and the inner Observable
* emission. The arguments passed to this function are:
* - `outerValue`: the value that came from the source
* - `innerValue`: the value that came from the projected Observable
* - `outerIndex`: the "index" of the value that came from the source
* - `innerIndex`: the "index" of the value from the projected Observable
* @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
* Observables being subscribed to concurrently.
* @return {Observable} An Observable that emits items from the given
* `innerObservable` (and optionally transformed through `resultSelector`) every
* time a value is emitted on the source Observable.
* @method mergeMapTo
* @owner Observable
*/
export function mergeMapTo(innerObservable, resultSelector, concurrent = Number.POSITIVE_INFINITY) {
if (typeof resultSelector === 'number') {
concurrent = resultSelector;
resultSelector = null;
}
return (source) => source.lift(new MergeMapToOperator(innerObservable, resultSelector, concurrent));
}
// TODO: Figure out correct signature here: an Operator<Observable<T>, R>
// needs to implement call(observer: Subscriber<R>): Subscriber<Observable<T>>
export class MergeMapToOperator {
constructor(ish, resultSelector, concurrent = Number.POSITIVE_INFINITY) {
this.ish = ish;
this.resultSelector = resultSelector;
this.concurrent = concurrent;
}
call(observer, source) {
return source.subscribe(new MergeMapToSubscriber(observer, this.ish, this.resultSelector, this.concurrent));
}
}
/**
* We need this JSDoc comment for affecting ESDoc.
* @ignore
* @extends {Ignored}
*/
export class MergeMapToSubscriber extends OuterSubscriber {
constructor(destination, ish, resultSelector, concurrent = Number.POSITIVE_INFINITY) {
super(destination);
this.ish = ish;
this.resultSelector = resultSelector;
this.concurrent = concurrent;
this.hasCompleted = false;
this.buffer = [];
this.active = 0;
this.index = 0;
}
_next(value) {
if (this.active < this.concurrent) {
const resultSelector = this.resultSelector;
const index = this.index++;
const ish = this.ish;
const destination = this.destination;
this.active++;
this._innerSub(ish, destination, resultSelector, value, index);
}
else {
this.buffer.push(value);
}
}
_innerSub(ish, destination, resultSelector, value, index) {
this.add(subscribeToResult(this, ish, value, index));
}
_complete() {
this.hasCompleted = true;
if (this.active === 0 && this.buffer.length === 0) {
this.destination.complete();
}
}
notifyNext(outerValue, innerValue, outerIndex, innerIndex, innerSub) {
const { resultSelector, destination } = this;
if (resultSelector) {
this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex);
}
else {
destination.next(innerValue);
}
}
trySelectResult(outerValue, innerValue, outerIndex, innerIndex) {
const { resultSelector, destination } = this;
let result;
try {
result = resultSelector(outerValue, innerValue, outerIndex, innerIndex);
}
catch (err) {
destination.error(err);
return;
}
destination.next(result);
}
notifyError(err) {
this.destination.error(err);
}
notifyComplete(innerSub) {
const buffer = this.buffer;
this.remove(innerSub);
this.active--;
if (buffer.length > 0) {
this._next(buffer.shift());
}
else if (this.active === 0 && this.hasCompleted) {
this.destination.complete();
}
}
}
//# sourceMappingURL=mergeMapTo.js.map