zen-observable-ts

What is zen-observable-ts?

The zen-observable-ts package is a TypeScript implementation of the Observable pattern, which is used for handling asynchronous data streams. It provides a way to create, transform, and consume sequences of values over time, making it useful for scenarios such as event handling, data fetching, and reactive programming.

What are zen-observable-ts's main functionalities?

Creating an Observable

This feature allows you to create an Observable that emits a sequence of values. In this example, the Observable emits 'Hello' and 'World' before completing.

const { Observable } = require('zen-observable-ts');

const observable = new Observable(observer => {
  observer.next('Hello');
  observer.next('World');
  observer.complete();
});

observable.subscribe({
  next(value) { console.log(value); },
  complete() { console.log('Done'); }
});

Transforming Observables with map

This feature allows you to transform the values emitted by an Observable using the map operator. In this example, each value emitted by the original Observable is multiplied by 2.

const { Observable } = require('zen-observable-ts');

const observable = new Observable(observer => {
  observer.next(1);
  observer.next(2);
  observer.next(3);
  observer.complete();
});

const mappedObservable = observable.map(value => value * 2);

mappedObservable.subscribe({
  next(value) { console.log(value); },
  complete() { console.log('Done'); }
});

Filtering Observables with filter

This feature allows you to filter the values emitted by an Observable using the filter operator. In this example, only values greater than 1 are emitted.

const { Observable } = require('zen-observable-ts');

const observable = new Observable(observer => {
  observer.next(1);
  observer.next(2);
  observer.next(3);
  observer.complete();
});

const filteredObservable = observable.filter(value => value > 1);

filteredObservable.subscribe({
  next(value) { console.log(value); },
  complete() { console.log('Done'); }
});

Combining Observables with merge

This feature allows you to combine multiple Observables into a single Observable using the merge operator. In this example, the values from both observables are emitted in sequence.

const { Observable } = require('zen-observable-ts');

const observable1 = new Observable(observer => {
  observer.next('A');
  observer.complete();
});

const observable2 = new Observable(observer => {
  observer.next('B');
  observer.complete();
});

const mergedObservable = Observable.merge(observable1, observable2);

mergedObservable.subscribe({
  next(value) { console.log(value); },
  complete() { console.log('Done'); }
});

Other packages similar to zen-observable-ts

rxjs

RxJS is a library for reactive programming using Observables, to make it easier to compose asynchronous or callback-based code. It is more feature-rich and widely used compared to zen-observable-ts, offering a comprehensive set of operators and utilities for working with Observables.

baconjs

Bacon.js is a functional reactive programming library for JavaScript. It provides a way to work with events and asynchronous data streams. Compared to zen-observable-ts, Bacon.js offers a different API and focuses more on functional programming paradigms.

most

Most.js is a high-performance reactive programming library that focuses on speed and efficiency. It provides a minimalistic API for working with streams. Compared to zen-observable-ts, Most.js is designed to be highly performant and is suitable for applications where performance is critical.

README

zen-observable-ts

Thin wrapper around zen-observable and @types/zen-observable, to support ESM exports as well as CommonJS exports.

Usage

After installing zen-observable-ts using a tool like npm or yarn, you can import the Observable class by name:

import { Observable } from "zen-observable-ts";

Note that this package does not currently have a default export, so the {} braces are mandatory.