initial commit: scaffolding

1 files changed, 300 insertions, 0 deletions

diff --git a/node_modules/rxjs/src/internal/observable/combineLatest.ts b/node_modules/rxjs/src/internal/observable/combineLatest.ts
new file mode 100644
index 0000000..9044060
--- /dev/null
+++ b/node_modules/rxjs/src/internal/observable/combineLatest.ts
@@ -0,0 +1,300 @@
+import { Observable } from '../Observable';
+import { ObservableInput, SchedulerLike, ObservedValueOf, ObservableInputTuple } from '../types';
+import { argsArgArrayOrObject } from '../util/argsArgArrayOrObject';
+import { Subscriber } from '../Subscriber';
+import { from } from './from';
+import { identity } from '../util/identity';
+import { Subscription } from '../Subscription';
+import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs';
+import { popResultSelector, popScheduler } from '../util/args';
+import { createObject } from '../util/createObject';
+import { createOperatorSubscriber } from '../operators/OperatorSubscriber';
+import { AnyCatcher } from '../AnyCatcher';
+import { executeSchedule } from '../util/executeSchedule';
+
+// combineLatest(any)
+// We put this first because we need to catch cases where the user has supplied
+// _exactly `any`_ as the argument. Since `any` literally matches _anything_,
+// we don't want it to randomly hit one of the other type signatures below,
+// as we have no idea at build-time what type we should be returning when given an any.
+
+/**
+ * You have passed `any` here, we can't figure out if it is
+ * an array or an object, so you're getting `unknown`. Use better types.
+ * @param arg Something typed as `any`
+ */
+export function combineLatest<T extends AnyCatcher>(arg: T): Observable<unknown>;
+
+// combineLatest([a, b, c])
+export function combineLatest(sources: []): Observable<never>;
+export function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export function combineLatest<A extends readonly unknown[], R>(
+  sources: readonly [...ObservableInputTuple<A>],
+  resultSelector: (...values: A) => R,
+  scheduler: SchedulerLike
+): Observable<R>;
+export function combineLatest<A extends readonly unknown[], R>(
+  sources: readonly [...ObservableInputTuple<A>],
+  resultSelector: (...values: A) => R
+): Observable<R>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export function combineLatest<A extends readonly unknown[]>(
+  sources: readonly [...ObservableInputTuple<A>],
+  scheduler: SchedulerLike
+): Observable<A>;
+
+// combineLatest(a, b, c)
+/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */
+export function combineLatest<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export function combineLatest<A extends readonly unknown[], R>(
+  ...sourcesAndResultSelectorAndScheduler: [...ObservableInputTuple<A>, (...values: A) => R, SchedulerLike]
+): Observable<R>;
+/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */
+export function combineLatest<A extends readonly unknown[], R>(
+  ...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R]
+): Observable<R>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export function combineLatest<A extends readonly unknown[]>(
+  ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike]
+): Observable<A>;
+
+// combineLatest({a, b, c})
+export function combineLatest(sourcesObject: { [K in any]: never }): Observable<never>;
+export function combineLatest<T extends Record<string, ObservableInput<any>>>(
+  sourcesObject: T
+): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>;
+
+/**
+ * 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>
+ *
+ * ![](combineLatest.png)
+ *
+ * `combineLatest` combines the values from all the Observables passed in the
+ * observables array. 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 this operator,
+ * the returned Observable will always emit an array of `n` values, in an order
+ * corresponding to the order of the passed Observables (the value from the first Observable
+ * will be at index 0 of the array and so on).
+ *
+ * Static version of `combineLatest` accepts an array of Observables. Note that an array of
+ * Observables is a good choice, if you don't know beforehand how many Observables
+ * you will combine. Passing an empty array will result in an Observable that
+ * completes immediately.
+ *
+ * To ensure the output array always has 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 these values but the last
+ * will be lost. On the other hand, if some Observable does not emit a value but
+ * completes, resulting Observable will complete at the same moment without
+ * emitting anything, since it will now be impossible to include a value from the
+ * completed Observable in the 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, the resulting Observable will complete when all combined
+ * streams complete. So even if some Observable completes, the result of
+ * `combineLatest` will still emit values when other Observables do. In case
+ * of a 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.
+ *
+ * ## Examples
+ *
+ * Combine two timer Observables
+ *
+ * ```ts
+ * import { timer, combineLatest } from 'rxjs';
+ *
+ * const firstTimer = timer(0, 1000); // emit 0, 1, 2... after every second, starting from now
+ * const secondTimer = timer(500, 1000); // emit 0, 1, 2... after every second, starting 0,5s from now
+ * const combinedTimers = 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
+ * ```
+ *
+ * Combine a dictionary of Observables
+ *
+ * ```ts
+ * import { of, delay, startWith, combineLatest } from 'rxjs';
+ *
+ * const observables = {
+ *   a: of(1).pipe(delay(1000), startWith(0)),
+ *   b: of(5).pipe(delay(5000), startWith(0)),
+ *   c: of(10).pipe(delay(10000), startWith(0))
+ * };
+ * const combined = combineLatest(observables);
+ * combined.subscribe(value => console.log(value));
+ * // Logs
+ * // { a: 0, b: 0, c: 0 } immediately
+ * // { a: 1, b: 0, c: 0 } after 1s
+ * // { a: 1, b: 5, c: 0 } after 5s
+ * // { a: 1, b: 5, c: 10 } after 10s
+ * ```
+ *
+ * Combine an array of Observables
+ *
+ * ```ts
+ * import { of, delay, startWith, combineLatest } from 'rxjs';
+ *
+ * const observables = [1, 5, 10].map(
+ *   n => of(n).pipe(
+ *     delay(n * 1000), // emit 0 and then emit n after n seconds
+ *     startWith(0)
+ *   )
+ * );
+ * const combined = 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
+ * ```
+ *
+ * Use map operator to dynamically calculate the Body-Mass Index
+ *
+ * ```ts
+ * import { of, combineLatest, map } from 'rxjs';
+ *
+ * const weight = of(70, 72, 76, 79, 75);
+ * const height = of(1.76, 1.77, 1.78);
+ * const bmi = combineLatest([weight, height]).pipe(
+ *   map(([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 combineLatestAll}
+ * @see {@link merge}
+ * @see {@link withLatestFrom}
+ *
+ * @param args Any number of `ObservableInput`s provided either as an array or as an object
+ * to combine with each other. If the last parameter is the function, it will be used to project the
+ * values from the combined latest values into a new value on the output Observable.
+ * @return An Observable of projected values from the most recent values from each `ObservableInput`,
+ * or an array of the most recent values from each `ObservableInput`.
+ */
+export function combineLatest<O extends ObservableInput<any>, R>(...args: any[]): Observable<R> | Observable<ObservedValueOf<O>[]> {
+  const scheduler = popScheduler(args);
+  const resultSelector = popResultSelector(args);
+
+  const { args: observables, keys } = argsArgArrayOrObject(args);
+
+  if (observables.length === 0) {
+    // If no observables are passed, or someone has passed an empty array
+    // of observables, or even an empty object POJO, we need to just
+    // complete (EMPTY), but we have to honor the scheduler provided if any.
+    return from([], scheduler as any);
+  }
+
+  const result = new Observable<ObservedValueOf<O>[]>(
+    combineLatestInit(
+      observables as ObservableInput<ObservedValueOf<O>>[],
+      scheduler,
+      keys
+        ? // A handler for scrubbing the array of args into a dictionary.
+          (values) => createObject(keys, values)
+        : // A passthrough to just return the array
+          identity
+    )
+  );
+
+  return resultSelector ? (result.pipe(mapOneOrManyArgs(resultSelector)) as Observable<R>) : result;
+}
+
+export function combineLatestInit(
+  observables: ObservableInput<any>[],
+  scheduler?: SchedulerLike,
+  valueTransform: (values: any[]) => any = identity
+) {
+  return (subscriber: Subscriber<any>) => {
+    // The outer subscription. We're capturing this in a function
+    // because we may have to schedule it.
+    maybeSchedule(
+      scheduler,
+      () => {
+        const { length } = observables;
+        // A store for the values each observable has emitted so far. We match observable to value on index.
+        const values = new Array(length);
+        // The number of currently active subscriptions, as they complete, we decrement this number to see if
+        // we are all done combining values, so we can complete the result.
+        let active = length;
+        // The number of inner sources that still haven't emitted the first value
+        // We need to track this because all sources need to emit one value in order
+        // to start emitting values.
+        let remainingFirstValues = length;
+        // The loop to kick off subscription. We're keying everything on index `i` to relate the observables passed
+        // in to the slot in the output array or the key in the array of keys in the output dictionary.
+        for (let i = 0; i < length; i++) {
+          maybeSchedule(
+            scheduler,
+            () => {
+              const source = from(observables[i], scheduler as any);
+              let hasFirstValue = false;
+              source.subscribe(
+                createOperatorSubscriber(
+                  subscriber,
+                  (value) => {
+                    // When we get a value, record it in our set of values.
+                    values[i] = value;
+                    if (!hasFirstValue) {
+                      // If this is our first value, record that.
+                      hasFirstValue = true;
+                      remainingFirstValues--;
+                    }
+                    if (!remainingFirstValues) {
+                      // We're not waiting for any more
+                      // first values, so we can emit!
+                      subscriber.next(valueTransform(values.slice()));
+                    }
+                  },
+                  () => {
+                    if (!--active) {
+                      // We only complete the result if we have no more active
+                      // inner observables.
+                      subscriber.complete();
+                    }
+                  }
+                )
+              );
+            },
+            subscriber
+          );
+        }
+      },
+      subscriber
+    );
+  };
+}
+
+/**
+ * A small utility to handle the couple of locations where we want to schedule if a scheduler was provided,
+ * but we don't if there was no scheduler.
+ */
+function maybeSchedule(scheduler: SchedulerLike | undefined, execute: () => void, subscription: Subscription) {
+  if (scheduler) {
+    executeSchedule(subscription, scheduler, execute);
+  } else {
+    execute();
+  }
+}