????
Your IP : 3.141.40.192
import { Observable } from '../Observable';
import { EmptyError } from '../util/EmptyError';
import { MonoTypeOperatorFunction, OperatorFunction, TruthyTypesOf } from '../types';
import { SequenceError } from '../util/SequenceError';
import { NotFoundError } from '../util/NotFoundError';
import { operate } from '../util/lift';
import { createOperatorSubscriber } from './OperatorSubscriber';
export function single<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
export function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T>;
/**
* Returns an observable that asserts that only one value is
* emitted from the observable that matches the predicate. If no
* predicate is provided, then it will assert that the observable
* only emits one value.
*
* In the event that the observable is empty, it will throw an
* {@link EmptyError}.
*
* In the event that two values are found that match the predicate,
* or when there are two values emitted and no predicate, it will
* throw a {@link SequenceError}
*
* In the event that no values match the predicate, if one is provided,
* it will throw a {@link NotFoundError}
*
* ## Example
*
* Expect only `name` beginning with `'B'`
*
* ```ts
* import { of, single } from 'rxjs';
*
* const source1 = of(
* { name: 'Ben' },
* { name: 'Tracy' },
* { name: 'Laney' },
* { name: 'Lily' }
* );
*
* source1
* .pipe(single(x => x.name.startsWith('B')))
* .subscribe(x => console.log(x));
* // Emits 'Ben'
*
*
* const source2 = of(
* { name: 'Ben' },
* { name: 'Tracy' },
* { name: 'Bradley' },
* { name: 'Lincoln' }
* );
*
* source2
* .pipe(single(x => x.name.startsWith('B')))
* .subscribe({ error: err => console.error(err) });
* // Error emitted: SequenceError('Too many values match')
*
*
* const source3 = of(
* { name: 'Laney' },
* { name: 'Tracy' },
* { name: 'Lily' },
* { name: 'Lincoln' }
* );
*
* source3
* .pipe(single(x => x.name.startsWith('B')))
* .subscribe({ error: err => console.error(err) });
* // Error emitted: NotFoundError('No values match')
* ```
*
* @see {@link first}
* @see {@link find}
* @see {@link findIndex}
* @see {@link elementAt}
*
* @throws {NotFoundError} Delivers an NotFoundError to the Observer's `error`
* callback if the Observable completes before any `next` notification was sent.
* @throws {SequenceError} Delivers a SequenceError if more than one value is emitted that matches the
* provided predicate. If no predicate is provided, will deliver a SequenceError if more
* than one value comes from the source
* @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.
* @return A function that returns an Observable that emits the single item
* emitted by the source Observable that matches the predicate.
*/
export function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T> {
return operate((source, subscriber) => {
let hasValue = false;
let singleValue: T;
let seenValue = false;
let index = 0;
source.subscribe(
createOperatorSubscriber(
subscriber,
(value) => {
seenValue = true;
if (!predicate || predicate(value, index++, source)) {
hasValue && subscriber.error(new SequenceError('Too many matching values'));
hasValue = true;
singleValue = value;
}
},
() => {
if (hasValue) {
subscriber.next(singleValue);
subscriber.complete();
} else {
subscriber.error(seenValue ? new NotFoundError('No matching values') : new EmptyError());
}
}
)
);
});
}