HN Explorer

24 comments

[ 4.7 ms ] story [ 59.2 ms ] thread
pythonistah
It uses Proxy and Promise classes.
izym
The point is to take APIs that don't and wrap them with said classes, not to provide an alternative.
pythonistah
What percentage of browsers in use implement Proxy and Promise classes? 40 percent?
JonathonW
Per Can I Use [1], promises are in 74% of browsers (only current major browser not supporting them is IE11) and proxies are in 57% of browsers.

Promise is pretty easily polyfilled for older browsers; proxies are more problematic and I don't know whether or not any of the existing proxy polyfills will work with Allora.

[1] http://caniuse.com/

pythonistah
The data behind their world wide browser stats is questionable. - their combined IE and Edge market share totals to only 8%.

On https://www.netmarketshare.com combined IE market share is 31% and Edge is 5%.

nilliams
What about IE8-10? I agree with pythonistah, that can-i-use data doesn't really map to real-world usage.
pythonistah
Perhaps they only collect data from browsers hitting their web site?
gianlucaguarini
you got it, there are many libraries on npm doing the same but none was build with less than 50 lines of code
jagger27
I love the name.
[deleted]
(comment deleted)
c-smile
It is not possible to fulfill promise more than once.

Thus promisifying of window.setInterval() and window.requestAnimationFrame() is very questionable.

The same applies to possibly repeatable .onXXXX() methods.

   2.2.2 If onFulfilled is a function:
   ...
   2.2.2.3 it must not be called more than once.
https://promisesaplus.com/
foota
requestAnimationFrame doesn't repeat, it only triggers the function once, you have to request an animation frame on each render to have it run again. Valid point however regarding the other things. Might be a neat api to have like a generator for these kinds of things, something like: for click in window.document.body: // do something with click and then stick this in an async function?
throwanem
It's not possible to fulfill a promise more than once, no.

But a Promise.all method, while outside the A+ spec, conventionally returns a promise for the resolution of all promises in the array passed as an argument; if all those promises are fulfilled, so will be the promise returned by .all, while if any of them is rejected, so will be the etc., etc.

So the browser example given in the Allora Github readme is perfectly reasonable. It's the exact same kind of thing you do when, for example, you need to await the completion of multiple separate HTTP requests in order to do something with all of their results. While, again, .all isn't part of the A+ standard, this is perfectly conventional and unremarkable behavior; not only is it unsurprising to see in a library like this one, it would be exceptional in its absence if it weren't there.

That said, I would be curious to see Allora compared with, for example, Bluebird's "promisifyAll" method, which appears to do much the same thing.

c-smile
So what does this

   thatWindow.setInterval(100).then( foo )
mean exactly? How many times the foo() will be called? And how to stop that interval?
gianlucaguarini
foo will be called only once (see my answer above). I am working on another script to achieve event streams using es6 generators let's keep in touch
egeozcan 

    promisifiedWindow.setInterval(200).then(x => console.log("res:", x));
    -> Promise {[[PromiseStatus]]: "pending", [[PromiseValue]]: undefined}
    >> VM310:1 res: undefined
How do you cancel the interval?
gianlucaguarini
At moment it's not possible and it does not make any sense to use a setInterval with a promise in return. But I will think about a simple solution to clear the timer functions
gianlucaguarini
Yes you are right, mine was just a proof of concept and it works properly for callbacks that must be triggered only once. I am working on another script to make an event streams api from native functions a bit like Bacon.js or fx.js already do but with less code
k__
Is there an equivalent for RxJS?
nippur72
nice small lib as you'd expect from @gianlucaguarini (of Riot.js fame).

Also, it's async/await ready:

  const allora = require('allora')
  const myGlobal = allora(global)
  
  async function foo() {
     console.log("start")
     await myGlobal.setTimeout(2000)
     console.log("end")
  }  

  foo()