npm i streamlets

Streamlet is a protocol for handling streams of data / events.

• ↕️ It allows for handling pullables (i.e. iterables), listenables (i.e. observables) and anything in between.
• ⛓️ It allows for handling synchronous and asynchronous data sources.
• ⏯️ It enables pausing / resuming streams.
• 📦 It allows pretty light-weight primitives and tools.

The streamlets package includes typings and tools built around this protocol.

import { pipe, interval, tap, observe } from 'streamlets'

const obs = 
  pipe(
    interval(1000),
    tap(console.log),
    observe,
  )


setTimeout(() => obs.stop(), 2000)
setTimeout(() => obs.start(), 4000)

// > 0
// > 1
// ... paused for two seconds, no logs ...
// > 2
// > 3
// > ...

👉 Check out the wiki for installation and usage guides.

Prior Work

If you find this useful, you most probably want to use RxJS. This is an experimental work. If you are into these kinds of experiments, checkout the callbag standard as well. The main differences between streamlets and aforementioned libraries are:

• ↕️ Streamlets and callbags handle both pullables and listenables, and anything in between. RxJS does not.
• ⏯️ Streamlets support pausing / resuming by default. This can be added to callbags as well, not supported by the standard itself. RxJS does not support this.
• 🚧 Streamlets can handle backpressure in a more nuanced way, since sinks can communicate to sources their data needs, and can pause/resume them.
• 📦 Streamlets fall between Callbags and RxJS operators and utilities in terms of bundle size consumption, leaning more towards the more light-weight side. A simple app would be ~500B with Callbags, ~1KB with Streamlets and ~4KB with RxJS.
• 🚀 Streamlets are as fast (in some cases marginally faster) than Callbags, and noticably faster than RxJS. Note that performance of FRP libraries is generally not the bottle neck in apps that use them, since they are used to handle async operations which are typically way costlier.
• 🧠 Streamlets use less memory than both Callbags and RxJS.

Acknowledgement

The streamlet protocol is heavily influenced by the callbag standard. A lot of code and utilities built around callbags were directly adopted into utilities for streamlets, including (but not limited to):

• callbag-from-iter, callbag-flatten, and lots of other callbag related utilities by @staltz
• callbag-of and callbag-retry by @Andarist
• callbag-start-with by @krawaller
• callbag-debounce by @atomrc