Interop with Native Observables?

[dariomannu]

Now that we have a standards proposal for Observables that's already working in Chome, we have a polyfill, we have libraries such as rimmel.js designed all around Observables with some experimental support for the native ones, is Eventkit considering any interoperability with native observables?

RxJS should support them in V9, but it's probably going to take some time.
This could be an opportunity for Eventkit to come first and I'd be happy to help it get there, in case.

[hntrl]

Probably not -- the underlying AsyncObservable primitive has a lot of functional differences than the WICG/rxjs observables. Namely, the fact that AsyncObservable is designed around async/await instead of as something that runs sequentially in the main thread which I imagine breaks a lot of the existing assumption of what an observable is doing.

What does interoperability look like to you? Just the APIs looking the same? Are you looking to make a bunch of observable implementations compliant with rimmel?

[dariomannu]

The way I imagine interoperability is by connecting other observables with Eventkit. Something like this, for instance, could be a start:

const stop = new Stream;

const coords = document
  .when('click')
  .map(e=>e.clientX)
  .takeUntil(stop)  // interop between a native observable and and Eventkit Stream
;

Rimmel's integration with native Observables comes with a few challenges, especially for application developers.

Natives don't have .pipe(), don't have neither Subject nor BehaviorSubject... yet. The last two are pretty much central in stream-oriented programming (the paradigm used in Rimmel), but they can be considered an anti-pattern in mixed paradigms/imperative-leaning environments such as Angular or React.

The lack of .pipe is also a bit of an issue, because you write components, you reference observables that don't exist yet (they will only exist on mount, after calling .when(), so we had to come up with creative workarounds.

Then there is a lack of key operators, like scan, so one would be tempted to jump to RxJS for the operators and hope they would work, but... no. RxJS (7 and 8) won't like most other Observable implementations, including the native one, as it checks if they implement Symbol.observable and .lift... and if yes, it starts assuming those are RxJS streams and will try to refer to internal implementation details. This is probably going to be sorted in version 9, but as far I know work hasn't started on that yet.

Another way I could think of integration with the natives is the creation of some hybrid primitives that extend the natives and add something to it. Say a class Magic extends Observable { pipe, scan, ... and some Eventkit specific method) }

[hntrl]

This pattern makes a lot of sense to me:

const coords = document
  .when('click')
  .map(e=>e.clientX)
  .takeUntil(stop)

Is this just as simple as adding Symbol.observable (or '@@observable' or whatever it is these days) to eventkit observables?

[dariomannu]

Can't remember on top of my head what's needed, but it doesn't seem to be just that, we'll need to find out...