????
Your IP : 18.117.180.237
import { concat } from '../observable/concat';
import { OperatorFunction, SchedulerLike, ValueFromArray } from '../types';
import { popScheduler } from '../util/args';
import { operate } from '../util/lift';
// Devs are more likely to pass null or undefined than they are a scheduler
// without accompanying values. To make things easier for (naughty) devs who
// use the `strictNullChecks: false` TypeScript compiler option, these
// overloads with explicit null and undefined values are included.
export function startWith<T>(value: null): OperatorFunction<T, T | null>;
export function startWith<T>(value: undefined): OperatorFunction<T, T | undefined>;
/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
export function startWith<T, A extends readonly unknown[] = T[]>(
...valuesAndScheduler: [...A, SchedulerLike]
): OperatorFunction<T, T | ValueFromArray<A>>;
export function startWith<T, A extends readonly unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>;
/**
* Returns an observable that, at the moment of subscription, will synchronously emit all
* values provided to this operator, then subscribe to the source and mirror all of its emissions
* to subscribers.
*
* This is a useful way to know when subscription has occurred on an existing observable.
*
* <span class="informal">First emits its arguments in order, and then any
* emissions from the source.</span>
*
* 
*
* ## Examples
*
* Emit a value when a timer starts.
*
* ```ts
* import { timer, map, startWith } from 'rxjs';
*
* timer(1000)
* .pipe(
* map(() => 'timer emit'),
* startWith('timer start')
* )
* .subscribe(x => console.log(x));
*
* // results:
* // 'timer start'
* // 'timer emit'
* ```
*
* @param values Items you want the modified Observable to emit first.
* @return A function that returns an Observable that synchronously emits
* provided values before subscribing to the source Observable.
*
* @see {@link endWith}
* @see {@link finalize}
* @see {@link concat}
*/
export function startWith<T, D>(...values: D[]): OperatorFunction<T, T | D> {
const scheduler = popScheduler(values);
return operate((source, subscriber) => {
// Here we can't pass `undefined` as a scheduler, because if we did, the
// code inside of `concat` would be confused by the `undefined`, and treat it
// like an invalid observable. So we have to split it two different ways.
(scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
});
}