import { isScheduler } from '../util/isScheduler'; import { of } from './of'; import { from } from './from'; import { concatAll } from '../operators/concatAll'; /* tslint:enable:max-line-length */ /** * Creates an output Observable which sequentially emits all values from given * Observable and then moves on to the next. * * Concatenates multiple Observables together by * sequentially emitting their values, one Observable after the other. * * * * `concat` joins multiple Observables together, by subscribing to them one at a time and * merging their results into the output Observable. You can pass either an array of * Observables, or put them directly as arguments. Passing an empty array will result * in Observable that completes immediately. * * `concat` will subscribe to first input Observable and emit all its values, without * changing or affecting them in any way. When that Observable completes, it will * subscribe to then next Observable passed and, again, emit its values. This will be * repeated, until the operator runs out of Observables. When last input Observable completes, * `concat` will complete as well. At any given moment only one Observable passed to operator * emits values. If you would like to emit values from passed Observables concurrently, check out * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact, * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`. * * Note that if some input Observable never completes, `concat` will also never complete * and Observables following the one that did not complete will never be subscribed. On the other * hand, if some Observable simply completes immediately after it is subscribed, it will be * invisible for `concat`, which will just move on to the next Observable. * * If any Observable in chain errors, instead of passing control to the next Observable, * `concat` will error immediately as well. Observables that would be subscribed after * the one that emitted error, never will. * * If you pass to `concat` the same Observable many times, its stream of values * will be "replayed" on every subscription, which means you can repeat given Observable * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious, * you can always use {@link repeat}. * * @example Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10 * var timer = Rx.Observable.interval(1000).take(4); * var sequence = Rx.Observable.range(1, 10); * var result = Rx.Observable.concat(timer, sequence); * result.subscribe(x => console.log(x)); * * // results in: * // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10 * * * @example Concatenate an array of 3 Observables * var timer1 = Rx.Observable.interval(1000).take(10); * var timer2 = Rx.Observable.interval(2000).take(6); * var timer3 = Rx.Observable.interval(500).take(10); * var result = Rx.Observable.concat([timer1, timer2, timer3]); // note that array is passed * result.subscribe(x => console.log(x)); * * // results in the following: * // (Prints to console sequentially) * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9 * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5 * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9 * * * @example Concatenate the same Observable to repeat it * const timer = Rx.Observable.interval(1000).take(2); * * Rx.Observable.concat(timer, timer) // concating the same Observable! * .subscribe( * value => console.log(value), * err => {}, * () => console.log('...and it is done!') * ); * * // Logs: * // 0 after 1s * // 1 after 2s * // 0 after 3s * // 1 after 4s * // "...and it is done!" also after 4s * * @see {@link concatAll} * @see {@link concatMap} * @see {@link concatMapTo} * * @param {ObservableInput} input1 An input Observable to concatenate with others. * @param {ObservableInput} input2 An input Observable to concatenate with others. * More than one input Observables may be given as argument. * @param {Scheduler} [scheduler=null] An optional IScheduler to schedule each * Observable subscription on. * @return {Observable} All values of each passed Observable merged into a * single Observable, in order, in serial fashion. * @static true * @name concat * @owner Observable */ export function concat(...observables) { if (observables.length === 1 || (observables.length === 2 && isScheduler(observables[1]))) { return from(observables[0]); } return concatAll()(of(...observables)); } //# sourceMappingURL=concat.js.map