findhit-promise

Promise

javascript promise built on top of findhit-class

Instalation

npm install findhit-promise --save

Usage

 
var Promise = require('findhit-promise');
 
// Implementing on your async function
    
    function async( a1, b1, cb ) {
        // ...
 
        process.nextTick(function () {
            cb( null, a2, b2)
        })
    };
 
    async( a1, b1, function ( err, a2, b2 ) {
        // ...
    })
 
    // Will be
 
    function async( a1, b1 ) {
 
        var self = {
            abc: function () {},
            def: function () {},
            fgh: function () {},
        }
 
        return new Promise(function ( done ) {
 
            // ...
            if( somethingGoesWrong )
                // You can throw Error, Promise will catch it...
                throw new Error();
                // Or you can send it to done
                // return done( new Error () );
 
                // Then promise will redirect to right method
 
            // Otherwise
            done( a2, b2 );
        })
            // If you have more actions on the same environment
            // you can configure them to be chained to this promise by:
 
                // specifying function
                // .extend( name, fn, context )
 
                .extend( 'yey', function ( a, b ) {
                    return a + b;
                }, self)
 
                // giving an object with some functions
                // .extend( { name: fn, ... }, context )
 
                .extend({
                    someaction: function ( z ) {
                        return new Promise(function () {
                            return new Error();
                        });
                    },
                    anotheraction: function ( a ) {
                        return new Promise(function () {
                            return !! a;
                        });
                    },
                }, self)
 
                // Or give an existent instance and the list of keys you want to use
                // This will run thoose functions with the first object as context
                // .extend( context, [ 'methodName', ... ] )
 
                .extend( self, [ 'abc', 'def' ] )
 
                .ready()
    };
 
    // You can:
 
        // Receive error on a separate function
            
            async( a1, b1 )
                .then(function ( a2, b2 ) {
                    // ...
                })
                .error(function ( err ){
                    // ...
                })
 
            // or
 
            async( a1, b1 )
                .then(function ( a2, b2 ) {
                    // ...
                }, function ( err ){
                    // ...
                })
 
        // Always receive err
            
            async( a1, b1 )
                .done(function ( err, a2, b2 ) {
                    // ...
                })
 
        // Chain multiple thens
 
            async( a1, b1 )
                .then(function ( a2, b2 ) {
                    return async( a2, b2 );
                })
                .then(function ( a3, b3 ) {
                    return a3 + b3;
                })
                .then(function ( z ) {
                    return z;
                })
 
        // Chain multiple actions
 
            Promise.all(
            
                async( a1, b1 ),
                async( a2, b2 ),
                async( a3, b3 )
            
            ).then(function ( arrayOfResults ) {
                // ...
            })
 
            Promise.all([
            
                async( a1, b1 ),
                async( a2, b2 ),
                async( a3, b3 ),
 
            ]).then(function ( arrayOfResults ) {
                // ...
            })
 
        // Or if they provide some action context
 
            async( a1, b1 ).
            async( a2, b2 ).
            async( a3, b3 ).
                then(function ( arrayOfResults ) {
                    // ...
                })
 
 
        // since .error catches current promise error, you can also configure a catch all errors
            async( a1, b1 )
                .catch(function ( err ) {
                    // ...
                })
 

Thanks

Huge thanks to Forbes Lindesay.