observable-callback

A small utility for simplified creation of callback functions that publishes the argument to an observable stream when called.

It's a small wrapper around RxJS Subjects that returns a tuple of the Subject as an observable and the subject's next() function

$3

``js
const [value$, onValue] = observableCallback()

value$.subscribe((value) => {
// will print "Hello world!"
console.log(value)
})

setTimeout(() => onValue("Hello world!"), 100)
`

$3

`js
const [greeting$, onPlanet] = observableCallback((planet$) =>
planet$.pipe(map((planet) => Hello ${planet}!))
)

greeting$.subscribe((greeting) => {
// will print "Hello world!" after 100ms
console.log(greeting)
})

setTimeout(() => onPlanet("world"), 100)
`

$3

Sometimes the only way to know when an event happens in different APIs is by providing a function that will be called at some later point.
Sometimes it makes sense represent calls to a function as an observable of its called arguments. One example of this can be event handlers in React:

`jsx
const [clicks$, onClick] = observableCallback()

clicks$.subscribe(() => {
console.log("User clicked the button")
})

render(Click me!)
`

Another use case could be to provide an action stream, and a way of dispatching actions. For example, here's a simple router that exposes the current page as an observable stream, and a function to call in order to navigate to another page:

`jsx
// page.js
const [onNavigate$, onNavigate] = observableCallback()

export const currentPage$ = onNavigate$.pipe(
switchMap((page) => {
return loadPage(page)
})
)

export const navigate = onNavigate

//... some other part of the application
function SomeComponent() {
return navigate("page2")}>Go to page 2
}
`

$3

- If you you are using node-style callback APIs. You are probably better off using bindNodeCallback instead.
- If you want resource disposal, e.g. cancellation or listener removal.

API

`ts
function observableCallback(): [Observable, (argument: T) => void]
function observableCallback(
operator: OperatorFunction
): [Observable, (argument: T) => void]
``

License

MIT