This repository has been archived on 2024-07-27. You can view files and clone it, but cannot push or open issues or pull requests.
keksAccountGUI/node_modulesOLD/rxjs/internal/operators/refCount.d.ts
2019-08-11 20:48:02 +02:00

55 lines
2.1 KiB
TypeScript

import { MonoTypeOperatorFunction } from '../types';
/**
* Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way
* you can connect to it.
*
* Internally it counts the subscriptions to the observable and subscribes (only once) to the source if
* the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it
* unsubscribes from the source. This way you can make sure that everything before the *published*
* refCount has only a single subscription independently of the number of subscribers to the target
* observable.
*
* Note that using the {@link share} operator is exactly the same as using the *publish* operator
* (making the observable hot) and the *refCount* operator in a sequence.
*
* ![](refCount.png)
*
* ## Example
*
* In the following example there are two intervals turned into connectable observables
* by using the *publish* operator. The first one uses the *refCount* operator, the
* second one does not use it. You will notice that a connectable observable does nothing
* until you call its connect function.
*
* ```ts
* import { interval } from 'rxjs';
* import { tap, publish, refCount } from 'rxjs/operators';
*
* // Turn the interval observable into a ConnectableObservable (hot)
* const refCountInterval = interval(400).pipe(
* tap((num) => console.log(`refCount ${num}`)),
* publish(),
* refCount()
* );
*
* const publishedInterval = interval(400).pipe(
* tap((num) => console.log(`publish ${num}`)),
* publish()
* );
*
* refCountInterval.subscribe();
* refCountInterval.subscribe();
* // 'refCount 0' -----> 'refCount 1' -----> etc
* // All subscriptions will receive the same value and the tap (and
* // every other operator) before the publish operator will be executed
* // only once per event independently of the number of subscriptions.
*
* publishedInterval.subscribe();
* // Nothing happens until you call .connect() on the observable.
* ```
*
* @see {@link ConnectableObservable}
* @see {@link share}
* @see {@link publish}
*/
export declare function refCount<T>(): MonoTypeOperatorFunction<T>;