135 lines
4.9 KiB
JavaScript
135 lines
4.9 KiB
JavaScript
import { ArrayObservable } from '../observable/ArrayObservable';
|
|
import { isArray } from '../util/isArray';
|
|
import { OuterSubscriber } from '../OuterSubscriber';
|
|
import { subscribeToResult } from '../util/subscribeToResult';
|
|
const none = {};
|
|
/* tslint:enable:max-line-length */
|
|
/**
|
|
* Combines multiple Observables to create an Observable whose values are
|
|
* calculated from the latest values of each of its input Observables.
|
|
*
|
|
* <span class="informal">Whenever any input Observable emits a value, it
|
|
* computes a formula using the latest values from all the inputs, then emits
|
|
* the output of that formula.</span>
|
|
*
|
|
* <img src="./img/combineLatest.png" width="100%">
|
|
*
|
|
* `combineLatest` combines the values from this Observable with values from
|
|
* Observables passed as arguments. This is done by subscribing to each
|
|
* Observable, in order, and collecting an array of each of the most recent
|
|
* values any time any of the input Observables emits, then either taking that
|
|
* array and passing it as arguments to an optional `project` function and
|
|
* emitting the return value of that, or just emitting the array of recent
|
|
* values directly if there is no `project` function.
|
|
*
|
|
* @example <caption>Dynamically calculate the Body-Mass Index from an Observable of weight and one for height</caption>
|
|
* var weight = Rx.Observable.of(70, 72, 76, 79, 75);
|
|
* var height = Rx.Observable.of(1.76, 1.77, 1.78);
|
|
* var bmi = weight.combineLatest(height, (w, h) => w / (h * h));
|
|
* bmi.subscribe(x => console.log('BMI is ' + x));
|
|
*
|
|
* // With output to console:
|
|
* // BMI is 24.212293388429753
|
|
* // BMI is 23.93948099205209
|
|
* // BMI is 23.671253629592222
|
|
*
|
|
* @see {@link combineAll}
|
|
* @see {@link merge}
|
|
* @see {@link withLatestFrom}
|
|
*
|
|
* @param {ObservableInput} other An input Observable to combine with the source
|
|
* Observable. More than one input Observables may be given as argument.
|
|
* @param {function} [project] An optional function to project the values from
|
|
* the combined latest values into a new value on the output Observable.
|
|
* @return {Observable} An Observable of projected values from the most recent
|
|
* values from each input Observable, or an array of the most recent values from
|
|
* each input Observable.
|
|
* @method combineLatest
|
|
* @owner Observable
|
|
*/
|
|
export function combineLatest(...observables) {
|
|
let project = null;
|
|
if (typeof observables[observables.length - 1] === 'function') {
|
|
project = observables.pop();
|
|
}
|
|
// if the first and only other argument besides the resultSelector is an array
|
|
// assume it's been called with `combineLatest([obs1, obs2, obs3], project)`
|
|
if (observables.length === 1 && isArray(observables[0])) {
|
|
observables = observables[0].slice();
|
|
}
|
|
return (source) => source.lift.call(new ArrayObservable([source, ...observables]), new CombineLatestOperator(project));
|
|
}
|
|
export class CombineLatestOperator {
|
|
constructor(project) {
|
|
this.project = project;
|
|
}
|
|
call(subscriber, source) {
|
|
return source.subscribe(new CombineLatestSubscriber(subscriber, this.project));
|
|
}
|
|
}
|
|
/**
|
|
* We need this JSDoc comment for affecting ESDoc.
|
|
* @ignore
|
|
* @extends {Ignored}
|
|
*/
|
|
export class CombineLatestSubscriber extends OuterSubscriber {
|
|
constructor(destination, project) {
|
|
super(destination);
|
|
this.project = project;
|
|
this.active = 0;
|
|
this.values = [];
|
|
this.observables = [];
|
|
}
|
|
_next(observable) {
|
|
this.values.push(none);
|
|
this.observables.push(observable);
|
|
}
|
|
_complete() {
|
|
const observables = this.observables;
|
|
const len = observables.length;
|
|
if (len === 0) {
|
|
this.destination.complete();
|
|
}
|
|
else {
|
|
this.active = len;
|
|
this.toRespond = len;
|
|
for (let i = 0; i < len; i++) {
|
|
const observable = observables[i];
|
|
this.add(subscribeToResult(this, observable, observable, i));
|
|
}
|
|
}
|
|
}
|
|
notifyComplete(unused) {
|
|
if ((this.active -= 1) === 0) {
|
|
this.destination.complete();
|
|
}
|
|
}
|
|
notifyNext(outerValue, innerValue, outerIndex, innerIndex, innerSub) {
|
|
const values = this.values;
|
|
const oldVal = values[outerIndex];
|
|
const toRespond = !this.toRespond
|
|
? 0
|
|
: oldVal === none ? --this.toRespond : this.toRespond;
|
|
values[outerIndex] = innerValue;
|
|
if (toRespond === 0) {
|
|
if (this.project) {
|
|
this._tryProject(values);
|
|
}
|
|
else {
|
|
this.destination.next(values.slice());
|
|
}
|
|
}
|
|
}
|
|
_tryProject(values) {
|
|
let result;
|
|
try {
|
|
result = this.project.apply(this, values);
|
|
}
|
|
catch (err) {
|
|
this.destination.error(err);
|
|
return;
|
|
}
|
|
this.destination.next(result);
|
|
}
|
|
}
|
|
//# sourceMappingURL=combineLatest.js.map
|