@lirx/core

LiRX/core - The fastest Reactive Programming framework

@lirx/core is an extremely performant framework to master asynchronous data streams using Observables, Observers, and Signals.

DOCUMENTATION

---

@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

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);
});

Example: signals !

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);
});

Give it a try, and you'll love it !

📕 Documentation

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)

📦 Installation

yarn add @lirx/core
# or
npm install @lirx/core --save

Click here to read the installation manual

Ecosystem

Differences with RxJS:

• 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. In reality, not all Observables require to emit a final state. For example, the RxJS interval never reaches a complete state. It just sends numbers. Moreover, some Observables may want to emit more than this 3 events: we may imagine an XHR Observable which emits an upload-progress 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.