A bunch of observables and operators for RxJS.
I created this package as a place to put additional RxJS observables, operators and methods. If you are looking for something that's not in the RxJS distribution, there might be something suitable in here - if you're lucky.
Install the package using NPM:
npm install rxjs-etc --save
Observable factoriescombineLatestArray, concatArray, forkJoinArray, mergeArray, zipArray
A bunch of static methods that behave in a predictable manner when passed empty arrays. Some of these are now redundant, but some aren't.
To see how these methods behave, consult their tests.
combineLatestHigherOrderArray, combineLatestHigherOrderObject
Higher-order variants of combineLatestArray - that takes Observable<Observable<T>[]> and returns Observable<T[]> - and combineLatestObject.
combineLatestObject, forkJoinObject
Like the array versions, but these take objects. Observable properties are combined using either combineLatest or forkJoin.
Like forkJoin but only runs the specified number of observables concurrently.
Higher-order variant of mergeArray - that takes Observable<Observable<T>[]> and returns Observable<T>.
Like partition but can passed more than one predicate to return more than two observables.
Splits a notifier into two or more states and between which notifications are toggled.
Based on expand. Traverses a graph - with backpressure control - using either a notifier or a consumer.
Works like zipArray, but if some sources complete whilst others continue to emit values, those the complete are 'padded' with the specified padValue (which defaults to undefined).
pipe or letA bunch of functions that can be passed to the let operator. Use them like this:
source.let(endWith("this is the end"))
They can also be used with pipe, like this:
source.pipe(endWith("this is the end"))
Debounce the source observable, but only after the notifier emits a value.
Debounce the source observable, but don't debounce the first count notifications - only the subsequent notifications.
Like debounceTime, but with an additional duration to ensure some notifications are emitted for super-busy streams.
Like defaultIfEmpty, but it takes a default observable instead of a default value.
Like startWith, but for the other end.
Applies the specified TypeScript guard to change the source observable's type and perform a runtime check. Emits an error notification if the guard rejects a value.
Emits true when the source observable completes.
Like map((value, index) => index) when it's called without a selector. When called with a selector, it's just an alias for map.
Like finalize (which is also exported as an alias), but passes the callback the Notification that effected the teardown, or undefined if explicitly unsubscribed.
Apply the operator to the source observable, but select only the initial count notifications - don't select the subsequent notifications.
Like a combination of startWith and pairwise, but with more specific typings.
Like pluck, but it's type-safe and only lets you valid keys. And it returns the appropriate type.
When creating signals from a source observable - for use with operators that take a notifier, like buffer and window - the order in which subscriptions are made is important. prioritize can be used to ensure that the notifier subscribes to the source first.
A rate limiter with pass through when waiting is not necessary.
Can be used with a ConnectableObservable instead of refCount. When the reference count drops to zero, it waits the specified duration and then if the reference count is zero, it unsubscribes. If the reference count is incremented within the duration, no unsubscription occurs.
Somewhat like the change that was made to shareReplay in 5.5.0.beta.4. When first subscribed to, a subscription is made to the source, but the source is never explicitly unsubscribed from. Unsubscription from the source only occurs if the source completes or errors.
Like refCount, but performs connections and unsubscriptions on the specified scheduler.
Emits values using the specified scheduler.
Like startWith but only emits the starting value if the source does not emit within the specified duration.
Apply the operator to the source observable, but don't select the first count notifications - only the subsequent notifications.
Like takeWhile, but the value that fails the predicate is taken.
Like tap, but it receives a tuple that includes the emitted value and the index.
Throttle the source observable, but only after the notifier emits a value.
Like subscribeOn, but for unsubscription.
A bunch of utility functions that do what their names suggest:
Like the static pipe (which is also exported as an alias), but with an overload signature that will return a generic operator if all parameter types are the same. For example, the debounceTime and distinctUntilChanged operators don't alter the observable type, so it's possible to return a generic type:
const debounce = genericPipe(
debounceTime(400),
distinctUntilChanged()
); // <R extends {}>(source: Observable<R>) => Observable<R>
The returned, generic debounce function can then be used in pipe calls made on observables of any type. And it's type-safe.
isNullish returns true if a value is null or undefined.
FAQs
Observables and operators for RxJS
The npm package rxjs-etc receives a total of 0 weekly downloads. As such, rxjs-etc popularity was classified as not popular.
We found that rxjs-etc demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.