Blazing fast Observables and Signals
npm install @lirx/core

@lirx/core is an extremely performant framework to master asynchronous data streams using Observables, Observers, and Signals.
@lirx/core (pronounced lyrics) is simply the fastest and smallest javascript library for Reactive Programming,
providing different tools to generate, consume, and pipe Observables and Observers.
It even provides powerful tools like Signals out-of-the-box.
If Reactive Programming does not tell you much or is a new concept to you, you may take a look at this tutorial.
In a few words, if you deal frequently with async programming like events, timeouts, promises or streams (ex: front-end development),
then @lirx/core is the perfect candidate for you.
Example: emulate double click
``ts
const subscribe = pipe$$(fromEventTarget(window, 'click'), [
bufferTime$$$(500),
filter$$$((events: PointerEvent[]) => events.length === 2),
map$$$((events: PointerEvent[]) => events[events.length - 1]),
]);
subscribe((event: PointerEvent) => {
console.log('double click', event);
});
`
[//]: # (TODO)
[//]: # ([Click here to see the live demo](https://stackblitz.com/edit/typescript-sfkssg?devtoolsheight=33&file=index.ts))
Example: signals !
`ts
const counter = signal(0);
const isEven = computed(() => counter() % 2 === 0);
const color = computed(() => (isEven() ? 'red' : 'blue'));
effect(() => {
console.log('counter', counter(), 'isEven', isEven(), 'color', color());
});
fromEventTarget(window, 'click')(() => {
counter.update((currentValue) => currentValue + 1);
});
`
[//]: # (TODO demo)
Give it a try, and you'll love it !
You may find the documentation of @lirx/core on the official website: https://core.lirx.org,
with a gentle introduction here
and the reference page here.
Here are the essential links:
- Signal
- Observable
- Observer
- ObservablePipe (ak: Pipeable Operator)
- pipeObservable (ak: Observable.pipe)
- pipeObservablePipes (ak: pipe function)
- Notification (ak: next, complete and error)
- MulticastSource (ak: Subject)
- ReplayLastSource (ak: BehaviorSubject)
`bash`
yarn add @lirx/coreor
npm install @lirx/core --save
Click here to read the installation manual
- no classes: this choice allows blazing fast performances and very small bundle size. Indeed, creating a class with
the new keyword is slow, and method names can't be mangled (minimized), where function calls are really well
optimized by javascript engines. However, it has a minor cost: chaining operators or method calls are done through
functions, which is a little less elegant (in terms of code readability).
- no next, complete and error: instead this lib uses notifications.interval
In reality, not all Observables require to emit a final state. For example, the RxJS complete
never reaches a state. It just sends numbers. Moreover, some Observables may want to emit moreupload-progress
than this 3 events: we may imagine an XHR Observable which emits an and download-progress` events.
- some concepts / operators / methods may have a different behaviour or name.
Take care to read the documentation before any hasty use.