work.suroh.tk/node_modules/rxjs/_esm2015/operators/distinct.js

109 lines
3.9 KiB
JavaScript

import { OuterSubscriber } from '../OuterSubscriber';
import { subscribeToResult } from '../util/subscribeToResult';
import { Set } from '../util/Set';
/**
* Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
*
* If a keySelector function is provided, then it will project each value from the source observable into a new value that it will
* check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the
* source observable directly with an equality check against previous values.
*
* In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
*
* In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
* hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
* use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
* that the internal `Set` can be "flushed", basically clearing it of values.
*
* @example <caption>A simple example with numbers</caption>
* Observable.of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
* .distinct()
* .subscribe(x => console.log(x)); // 1, 2, 3, 4
*
* @example <caption>An example using a keySelector function</caption>
* interface Person {
* age: number,
* name: string
* }
*
* Observable.of<Person>(
* { age: 4, name: 'Foo'},
* { age: 7, name: 'Bar'},
* { age: 5, name: 'Foo'})
* .distinct((p: Person) => p.name)
* .subscribe(x => console.log(x));
*
* // displays:
* // { age: 4, name: 'Foo' }
* // { age: 7, name: 'Bar' }
*
* @see {@link distinctUntilChanged}
* @see {@link distinctUntilKeyChanged}
*
* @param {function} [keySelector] Optional function to select which value you want to check as distinct.
* @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator.
* @return {Observable} An Observable that emits items from the source Observable with distinct values.
* @method distinct
* @owner Observable
*/
export function distinct(keySelector, flushes) {
return (source) => source.lift(new DistinctOperator(keySelector, flushes));
}
class DistinctOperator {
constructor(keySelector, flushes) {
this.keySelector = keySelector;
this.flushes = flushes;
}
call(subscriber, source) {
return source.subscribe(new DistinctSubscriber(subscriber, this.keySelector, this.flushes));
}
}
/**
* We need this JSDoc comment for affecting ESDoc.
* @ignore
* @extends {Ignored}
*/
export class DistinctSubscriber extends OuterSubscriber {
constructor(destination, keySelector, flushes) {
super(destination);
this.keySelector = keySelector;
this.values = new Set();
if (flushes) {
this.add(subscribeToResult(this, flushes));
}
}
notifyNext(outerValue, innerValue, outerIndex, innerIndex, innerSub) {
this.values.clear();
}
notifyError(error, innerSub) {
this._error(error);
}
_next(value) {
if (this.keySelector) {
this._useKeySelector(value);
}
else {
this._finalizeNext(value, value);
}
}
_useKeySelector(value) {
let key;
const { destination } = this;
try {
key = this.keySelector(value);
}
catch (err) {
destination.error(err);
return;
}
this._finalizeNext(key, value);
}
_finalizeNext(key, value) {
const { values } = this;
if (!values.has(key)) {
values.add(key);
this.destination.next(value);
}
}
}
//# sourceMappingURL=distinct.js.map