1import { Observable } from '../Observable'; 2import { Subscriber } from '../Subscriber'; 3import { OuterSubscriber } from '../OuterSubscriber'; 4import { InnerSubscriber } from '../InnerSubscriber'; 5import { MonoTypeOperatorFunction } from '../types'; 6/** 7 * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items. 8 * 9 * If a keySelector function is provided, then it will project each value from the source observable into a new value that it will 10 * check for equality with previously projected values. If a keySelector function is not provided, it will use each value from the 11 * source observable directly with an equality check against previous values. 12 * 13 * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking. 14 * 15 * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the 16 * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct` 17 * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so 18 * that the internal `Set` can be "flushed", basically clearing it of values. 19 * 20 * ## Examples 21 * A simple example with numbers 22 * ```ts 23 * import { of } from 'rxjs'; 24 * import { distinct } from 'rxjs/operators'; 25 * 26 * of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1).pipe( 27 * distinct(), 28 * ) 29 * .subscribe(x => console.log(x)); // 1, 2, 3, 4 30 * ``` 31 * 32 * An example using a keySelector function 33 * ```typescript 34 * import { of } from 'rxjs'; 35 * import { distinct } from 'rxjs/operators'; 36 * 37 * interface Person { 38 * age: number, 39 * name: string 40 * } 41 * 42 * of<Person>( 43 * { age: 4, name: 'Foo'}, 44 * { age: 7, name: 'Bar'}, 45 * { age: 5, name: 'Foo'}, 46 * ).pipe( 47 * distinct((p: Person) => p.name), 48 * ) 49 * .subscribe(x => console.log(x)); 50 * 51 * // displays: 52 * // { age: 4, name: 'Foo' } 53 * // { age: 7, name: 'Bar' } 54 * ``` 55 * @see {@link distinctUntilChanged} 56 * @see {@link distinctUntilKeyChanged} 57 * 58 * @param {function} [keySelector] Optional function to select which value you want to check as distinct. 59 * @param {Observable} [flushes] Optional Observable for flushing the internal HashSet of the operator. 60 * @return {Observable} An Observable that emits items from the source Observable with distinct values. 61 * @method distinct 62 * @owner Observable 63 */ 64export declare function distinct<T, K>(keySelector?: (value: T) => K, flushes?: Observable<any>): MonoTypeOperatorFunction<T>; 65/** 66 * We need this JSDoc comment for affecting ESDoc. 67 * @ignore 68 * @extends {Ignored} 69 */ 70export declare class DistinctSubscriber<T, K> extends OuterSubscriber<T, T> { 71 private keySelector; 72 private values; 73 constructor(destination: Subscriber<T>, keySelector: (value: T) => K, flushes: Observable<any>); 74 notifyNext(outerValue: T, innerValue: T, outerIndex: number, innerIndex: number, innerSub: InnerSubscriber<T, T>): void; 75 notifyError(error: any, innerSub: InnerSubscriber<T, T>): void; 76 protected _next(value: T): void; 77 private _useKeySelector; 78 private _finalizeNext; 79} 80