From d55b767039605256c736166a942a9138e3eacfd7 Mon Sep 17 00:00:00 2001 From: Pinapelz Date: Sun, 29 Jun 2025 11:49:28 -0700 Subject: remove dev node_modules (oops) --- .../rxjs/src/internal/observable/combineLatest.ts | 300 --------------------- 1 file changed, 300 deletions(-) delete mode 100644 node_modules/rxjs/src/internal/observable/combineLatest.ts (limited to 'node_modules/rxjs/src/internal/observable/combineLatest.ts') diff --git a/node_modules/rxjs/src/internal/observable/combineLatest.ts b/node_modules/rxjs/src/internal/observable/combineLatest.ts deleted file mode 100644 index 9044060..0000000 --- a/node_modules/rxjs/src/internal/observable/combineLatest.ts +++ /dev/null @@ -1,300 +0,0 @@ -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(arg: T): Observable; - -// combineLatest([a, b, c]) -export function combineLatest(sources: []): Observable; -export function combineLatest(sources: readonly [...ObservableInputTuple]): Observable; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function combineLatest( - sources: readonly [...ObservableInputTuple], - resultSelector: (...values: A) => R, - scheduler: SchedulerLike -): Observable; -export function combineLatest( - sources: readonly [...ObservableInputTuple], - resultSelector: (...values: A) => R -): Observable; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function combineLatest( - sources: readonly [...ObservableInputTuple], - scheduler: SchedulerLike -): Observable; - -// 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(...sources: [...ObservableInputTuple]): Observable; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function combineLatest( - ...sourcesAndResultSelectorAndScheduler: [...ObservableInputTuple, (...values: A) => R, SchedulerLike] -): Observable; -/** @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( - ...sourcesAndResultSelector: [...ObservableInputTuple, (...values: A) => R] -): Observable; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function combineLatest( - ...sourcesAndScheduler: [...ObservableInputTuple, SchedulerLike] -): Observable; - -// combineLatest({a, b, c}) -export function combineLatest(sourcesObject: { [K in any]: never }): Observable; -export function combineLatest>>( - sourcesObject: T -): Observable<{ [K in keyof T]: ObservedValueOf }>; - -/** - * Combines multiple Observables to create an Observable whose values are - * calculated from the latest values of each of its input Observables. - * - * 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. - * - * ![](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, R>(...args: any[]): Observable | Observable[]> { - 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[]>( - combineLatestInit( - observables as ObservableInput>[], - 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) : result; -} - -export function combineLatestInit( - observables: ObservableInput[], - scheduler?: SchedulerLike, - valueTransform: (values: any[]) => any = identity -) { - return (subscriber: Subscriber) => { - // 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(); - } -} -- cgit v1.2.3