Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
dom	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
ArrayLikeObservable.ts	1.89 KB	-rw-rw-r--	2022-08-30 11:49
ArrayObservable.ts	4.29 KB	-rw-rw-r--	2022-08-30 11:49
BoundCallbackObservable.ts	14.32 KB	-rw-rw-r--	2022-08-30 11:49
BoundNodeCallbackObservable.ts	12.27 KB	-rw-rw-r--	2022-08-30 11:49
ConnectableObservable.ts	5.58 KB	-rw-rw-r--	2022-08-30 11:49
DeferObservable.ts	3.3 KB	-rw-rw-r--	2022-08-30 11:49
EmptyObservable.ts	2.51 KB	-rw-rw-r--	2022-08-30 11:49
ErrorObservable.ts	2.61 KB	-rw-rw-r--	2022-08-30 11:49
ForkJoinObservable.ts	10.66 KB	-rw-rw-r--	2022-08-30 11:49
FromEventObservable.ts	10.89 KB	-rw-rw-r--	2022-08-30 11:49
FromEventPatternObservable.ts	3.71 KB	-rw-rw-r--	2022-08-30 11:49
FromObservable.ts	4.34 KB	-rw-rw-r--	2022-08-30 11:49
GenerateObservable.ts	9.73 KB	-rw-rw-r--	2022-08-30 11:49
IfObservable.ts	1.84 KB	-rw-rw-r--	2022-08-30 11:49
IntervalObservable.ts	2.67 KB	-rw-rw-r--	2022-08-30 11:49
IteratorObservable.ts	3.69 KB	-rw-rw-r--	2022-08-30 11:49
NeverObservable.ts	1.6 KB	-rw-rw-r--	2022-08-30 11:49
PairsObservable.ts	2.63 KB	-rw-rw-r--	2022-08-30 11:49
PromiseObservable.ts	3.87 KB	-rw-rw-r--	2022-08-30 11:49
RangeObservable.ts	2.87 KB	-rw-rw-r--	2022-08-30 11:49
ScalarObservable.ts	1.32 KB	-rw-rw-r--	2022-08-30 11:49
SubscribeOnObservable.ts	1.51 KB	-rw-rw-r--	2022-08-30 11:49
TimerObservable.ts	3.8 KB	-rw-rw-r--	2022-08-30 11:49
UsingObservable.ts	1.88 KB	-rw-rw-r--	2022-08-30 11:49
bindCallback.ts	131 B	-rw-rw-r--	2022-08-30 11:49
bindNodeCallback.ts	147 B	-rw-rw-r--	2022-08-30 11:49
combineLatest.ts	9.79 KB	-rw-rw-r--	2022-08-30 11:49
concat.ts	6.04 KB	-rw-rw-r--	2022-08-30 11:49
defer.ts	100 B	-rw-rw-r--	2022-08-30 11:49
empty.ts	100 B	-rw-rw-r--	2022-08-30 11:49
forkJoin.ts	112 B	-rw-rw-r--	2022-08-30 11:49
from.ts	96 B	-rw-rw-r--	2022-08-30 11:49
fromEvent.ts	116 B	-rw-rw-r--	2022-08-30 11:49
fromEventPattern.ts	144 B	-rw-rw-r--	2022-08-30 11:49
fromPromise.ts	112 B	-rw-rw-r--	2022-08-30 11:49
generate.ts	111 B	-rw-rw-r--	2022-08-30 11:49
if.ts	89 B	-rw-rw-r--	2022-08-30 11:49
interval.ts	112 B	-rw-rw-r--	2022-08-30 11:49
merge.ts	6.14 KB	-rw-rw-r--	2022-08-30 11:49
never.ts	100 B	-rw-rw-r--	2022-08-30 11:49
of.ts	93 B	-rw-rw-r--	2022-08-30 11:49
onErrorResumeNext.ts	133 B	-rw-rw-r--	2022-08-30 11:49
pairs.ts	102 B	-rw-rw-r--	2022-08-30 11:49
race.ts	3.17 KB	-rw-rw-r--	2022-08-30 11:49
range.ts	100 B	-rw-rw-r--	2022-08-30 11:49
throw.ts	101 B	-rw-rw-r--	2022-08-30 11:49
timer.ts	100 B	-rw-rw-r--	2022-08-30 11:49
using.ts	100 B	-rw-rw-r--	2022-08-30 11:49
zip.ts	79 B	-rw-rw-r--	2022-08-30 11:49

Rename

import {  Observable, ObservableInput  } from '../Observable';
import {  IScheduler  } from '../Scheduler';
import {  isScheduler  } from '../util/isScheduler';
import {  isArray  } from '../util/isArray';
import {  ArrayObservable  } from './ArrayObservable';
import {  CombineLatestOperator  } from '../operators/combineLatest';

/* tslint:disable:max-line-length */
export function combineLatest<T, R>(v1: ObservableInput<T>, project: (v1: T) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<T, T2, R>(v1: ObservableInput<T>, v2: ObservableInput<T2>, project: (v1: T, v2: T2) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<T, T2, T3, R>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, project: (v1: T, v2: T2, v3: T3) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<T, T2, T3, T4, R>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, project: (v1: T, v2: T2, v3: T3, v4: T4) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<T, T2, T3, T4, T5, R>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<T, T2, T3, T4, T5, T6, R>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, project: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6) => R, scheduler?: IScheduler): Observable<R>;

export function combineLatest<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, scheduler?: IScheduler): Observable<[T, T2]>;
export function combineLatest<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: IScheduler): Observable<[T, T2, T3]>;
export function combineLatest<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: IScheduler): Observable<[T, T2, T3, T4]>;
export function combineLatest<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: IScheduler): Observable<[T, T2, T3, T4, T5]>;
export function combineLatest<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: IScheduler): Observable<[T, T2, T3, T4, T5, T6]>;

export function combineLatest<T>(array: ObservableInput<T>[], scheduler?: IScheduler): Observable<T[]>;
export function combineLatest<R>(array: ObservableInput<any>[], scheduler?: IScheduler): Observable<R>;
export function combineLatest<T, R>(array: ObservableInput<T>[], project: (...values: Array<T>) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<R>(array: ObservableInput<any>[], project: (...values: Array<any>) => R, scheduler?: IScheduler): Observable<R>;
export function combineLatest<T>(...observables: Array<ObservableInput<T> | IScheduler>): Observable<T[]>;
export function combineLatest<T, R>(...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R) | IScheduler>): Observable<R>;
export function combineLatest<R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R) | IScheduler>): Observable<R>;
/* 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 all the Observables passed as
 * arguments. This is done by subscribing to each Observable in order and,
 * whenever any Observable emits, collecting an array of the most recent
 * values from each Observable. So if you pass `n` Observables to operator,
 * returned Observable will always emit an array of `n` values, in order
 * corresponding to order of passed Observables (value from the first Observable
 * on the first place and so on).
 *
 * Static version of `combineLatest` accepts either an array of Observables
 * or each Observable can be put directly as an argument. Note that array of
 * Observables is good choice, if you don't know beforehand how many Observables
 * you will combine. Passing empty array will result in Observable that
 * completes immediately.
 *
 * To ensure output array has always the same length, `combineLatest` will
 * actually wait for all input Observables to emit at least once,
 * before it starts emitting results. This means if some Observable emits
 * values before other Observables started emitting, all that values but last
 * will be lost. On the other hand, is some Observable does not emit value but
 * completes, resulting Observable will complete at the same moment without
 * emitting anything, since it will be now impossible to include value from
 * completed Observable in resulting array. Also, if some input Observable does
 * not emit any value and never completes, `combineLatest` will also never emit
 * and never complete, since, again, it will wait for all streams to emit some
 * value.
 *
 * If at least one Observable was passed to `combineLatest` and all passed Observables
 * emitted something, resulting Observable will complete when all combined
 * streams complete. So even if some Observable completes, result of
 * `combineLatest` will still emit values when other Observables do. In case
 * of completed Observable, its value from now on will always be the last
 * emitted value. On the other hand, if any Observable errors, `combineLatest`
 * will error immediately as well, and all other Observables will be unsubscribed.
 *
 * `combineLatest` accepts as optional parameter `project` function, which takes
 * as arguments all values that would normally be emitted by resulting Observable.
 * `project` can return any kind of value, which will be then emitted by Observable
 * instead of default array. Note that `project` does not take as argument that array
 * of values, but values themselves. That means default `project` can be imagined
 * as function that takes all its arguments and puts them into an array.
 *
 *
 * @example <caption>Combine two timer Observables</caption>
 * const firstTimer = Rx.Observable.timer(0, 1000); // emit 0, 1, 2... after every second, starting from now
 * const secondTimer = Rx.Observable.timer(500, 1000); // emit 0, 1, 2... after every second, starting 0,5s from now
 * const combinedTimers = Rx.Observable.combineLatest(firstTimer, secondTimer);
 * combinedTimers.subscribe(value => console.log(value));
 * // Logs
 * // [0, 0] after 0.5s
 * // [1, 0] after 1s
 * // [1, 1] after 1.5s
 * // [2, 1] after 2s
 *
 *
 * @example <caption>Combine an array of Observables</caption>
 * const observables = [1, 5, 10].map(
 *   n => Rx.Observable.of(n).delay(n * 1000).startWith(0) // emit 0 and then emit n after n seconds
 * );
 * const combined = Rx.Observable.combineLatest(observables);
 * combined.subscribe(value => console.log(value));
 * // Logs
 * // [0, 0, 0] immediately
 * // [1, 0, 0] after 1s
 * // [1, 5, 0] after 5s
 * // [1, 5, 10] after 10s
 *
 *
 * @example <caption>Use project function to dynamically calculate the Body-Mass Index</caption>
 * var weight = Rx.Observable.of(70, 72, 76, 79, 75);
 * var height = Rx.Observable.of(1.76, 1.77, 1.78);
 * var bmi = Rx.Observable.combineLatest(weight, 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} observable1 An input Observable to combine with other Observables.
 * @param {ObservableInput} observable2 An input Observable to combine with other Observables.
 * More than one input Observables may be given as arguments
 * or an array of Observables may be given as the first argument.
 * @param {function} [project] An optional function to project the values from
 * the combined latest values into a new value on the output Observable.
 * @param {Scheduler} [scheduler=null] The IScheduler to use for subscribing to
 * each input 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.
 * @static true
 * @name combineLatest
 * @owner Observable
 */
export function combineLatest<T, R>(...observables: Array<any | ObservableInput<any> |
                                                    Array<ObservableInput<any>> |
                                                    (((...values: Array<any>) => R)) |
                                                    IScheduler>): Observable<R> {
  let project: (...values: Array<any>) => R =  null;
  let scheduler: IScheduler = null;

if (isScheduler(observables[observables.length - 1])) {
    scheduler = <IScheduler>observables.pop();
  }

if (typeof observables[observables.length - 1] === 'function') {
    project = <(...values: Array<any>) => R>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 = <Array<Observable<any>>>observables[0];
  }

return new ArrayObservable(observables, scheduler).lift(new CombineLatestOperator<T, R>(project));
}