
Allora – Use promises on any JavaScript object - gianlucaguarini
https://github.com/GianlucaGuarini/allora
======
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/](https://promisesaplus.com/)

~~~
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
Ok with this it should be possible
[https://github.com/GianlucaGuarini/allora/pull/3](https://github.com/GianlucaGuarini/allora/pull/3)

------
ilaksh
Cool but what was wrong with all of the other modules that do this? There are
like 30 of them.
[https://npms.io/search?term=Promisify](https://npms.io/search?term=Promisify)

~~~
gianlucaguarini
the amount of code and the technology used ;)

------
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()

------
jagger27
I love the name.

------
k__
Is there an equivalent for RxJS?

------
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/](http://caniuse.com/)

~~~
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?

