npm i @most/adapter --save
https://mostcore.readthedocs.io/en/latest/api.html#stream
doc is hard to digest without some examples :(
run that adheres to the contract described in the docs: https://mostcore.readthedocs.io/en/latest/api.html#stream
Hi @briancavalier ! it looks like a lot has changed. I am still not quite sure how I can simple write a nodejs callback API in most stream.
Thanks for writing @most/adapter ! I do not understand how it works underneath, but I really needed something like that.
How would I write this bit in ES5 (taken from link) ?
class DomEvent {
constructor (event, node, capture) {
this.event = event
this.node = node
this.capture = capture
}
run (sink, scheduler) {
const send = e => tryEvent(currentTime(scheduler), e, sink)
const dispose = () => this.node.removeEventListener(this.event, send, this.capture)
this.node.addEventListener(this.event, send, this.capture)
return { dispose }
}
}is it possible to show the example taken from @most/create, using the run interface ?
import create from '@most/create'
// Add events and then end
const stream = create((add, end, error) => {
setTimeout(add, 1000, 'event 1')
setTimeout(add, 3000, 'event 2')
setTimeout(() => {
add('event 3')
end()
}, 10000)
// OPTIONAL: Return a dispose function to clean up
// resources when the stream ends
return () => console.log('dispose')
})Do we need to have a hard dependency on Babel ? or ES6 ?
currentTime = require('@most/scheduler').currentTime
var $setTimeout = {
constructor:function(userTime)
{
this.userTime = userTime
}
//----------------------------------------------------------//
run:function(sink,scheduler)
{
var send = function(e)
{
tryEvent(currentTime(scheduler),e,sink)
}
var dispose = function(e) {return 0;}
setTimeout(send,this.userTime);
return dispose;
}
}
function tryEvent (t, x, sink) {
try {
sink.event(t, x)
} catch (e) {
sink.error(t, e)
}
}@galileopy sorry if I was unclear.
I do not understand why promises even exist but to bamboozle some folks.
You do not get a say when the function CAN run. It runs in point of declaration which creates HUGE problems ( especially with error handlind and controling timing ).
it should be pretty easy to make a fromPromiseLazy(function)
I dont know if that is feasible, I do not even understand the inner working of mostjs.
You have a declaration that you want to start at .run / .observe / .drain point of declaration, it should also be chainable.
If I could figure out HOW to glue mostjs component with APIs in the wild it would save some lives.
I tried writing something like @most/adapter a while ago, and I wasn't able to, so I abandoned that idea and used flyd.
But for nodejs style callbacks mostjs is much nicer due to its laziness.
const { Stream } = require('most')
function LazyPromiseStream (promiseFn, args){
return {
run(sink, scheduler){
promiseFn(...args)
.then(
result => sink.event(scheduler.now(), result),
error => sink.error(scheduler.now(), error))
.then(() => sink.end(scheduler.now()))
return { dispose() { return null } }
}
}
}
module.exports = function fromLayzPromise(fn, args) {
return new Stream( new LazyPromiseStream(fn, args))
}fromPromise and awaitPromises are the basic promise-related operations, and those can be combined with map or chain, switch, mergeConcurrently, etc. to do a wide variety of things
i still have no idea how to use @most/types.
https://github.com/galileopy/most-mutation/blob/master/index.js
most/core's philosophy is to provide a useful set of combinators and a very minimal set of sources. We very much encourage the community to create sources based on dom-specific things, or node-specific things, or whatever they need. Your most-mutation package fits perfectly into that philosophy :)
skipAfter on my ending event and force an end that way