balle

Simple isomorphic promise implementation

Usage no npm install needed!

<script type="module">
  import balle from 'https://cdn.skypack.dev/balle';
</script>

README

Coverage Status Build Status Package Quality

 _____ _____ __    __    _____
| __  |  _  |  |  |  |  |   __|
| __ -|     |  |__|  |__|   __|
|_____|__|__|_____|_____|_____|

...  I promise

WTF ?

No... the world does not need that shit but I need to try to understand.

Just to be clear, this implementation has nothing to do with A+ promise specs


install & test

@ yarn
@ yarn test 
@ yarn cover

usage

Make a promise :

const Balle = require('balle');
const p = new Balle((resolve, reject) => {
    var before = +new Date;
    setTimeout(() => {
        Math.random() > .5
        ? resolve([before, +new Date])
        : reject('that`s the cause');
    }, 2000);
})

// deal with success using then
.then((result) => {
    console.log(result);
})

// deal with rejection | thrown error using catch
.catch((whatever) => {
    console.log('Failure:');
    console.log(whatever);
})

// do something anyway
.finally((result_cause_error) => {
    // get the result in case on resolution or the cause
    // in case of rejection|error
    console.log('Executed regardless the resolution or rejection')
});

reject a promise:

const p = new Balle((resolve, reject) => {
    var err = 'Ups... something went wrong';
    setTimeout(() => {
        reject(err);
    }, 1000);
})
.then(() => {
    throw 'never thrown';
})
.catch((cause) => {
    // this will in any case here
    console.log(cause);
});

late launch:

const resolvingPromise = new Balle();

resolvingPromise
.then(() => {
    throw 'Never executed';
})
.catch((cause) => {
    console.log('catched: ' + cause);
}).finally(function (cause) {
    console.log('finally : ' + cause);
});

resolvingPromise
.launch((resolve, reject) => {
    setTimeout(function () {
        reject('a problem occurred');
    }, 100);
});

resolve:

const resolvingPromise = new Balle();
resolvingPromise.resolve('the value');
resolvingPromise.then(function (v){
    console.log(v === 'the value')
});

reject:

const rejectingPromise = new Balle();
rejectingPromise.reject('the cause');
rejectingPromise.catch(function (v){
    console.log(v === 'the cause')
});

Balle.one

// wraps the constructor call
const p1 = new Balle(/* executor func */);
// can be written
const p1 = Balle.one(/* executor func */);

Balle.all

const init = +new Date;
const p = Balle.all([
    Balle.one((resolve, reject) => {
        setTimeout(() => { resolve(500) }, 1000);
    }),
    Balle.one((resolve, reject) => {
        setTimeout(() => { resolve(200) }, 2000); // +++
    }),
    Balle.one((resolve, reject) => {
        setTimeout(() => { resolve(300) }, 1500);
    }),
])
.then((result) => {
    console.log((+new Date - init)+ ' ≈ 2000');
    console.log(result); // ---> [500, 200, 300]
})
.catch((cause) => {
    throw 'never thrown';
});

Balle.race

const init = +new Date;
const p = Balle.race([
    Balle.one((resolve, reject) => {
        setTimeout(() => { resolve(500) }, 1000); // +++ 
    }),
    Balle.one((resolve, reject) => {
        setTimeout(() => { resolve(200) }, 1500);
    }),
    Balle.one((resolve, reject) => {
        setTimeout(() => { resolve(300) }, 2000);
    }),
])
.then((result) => {
    console.log((+new Date - init) + ' ≈ 1000');
    console.log(result + ' == 500'); 
})
.catch((cause) => {
    throw 'never thrown';
});

Balle.chain

Balle.chain([
    () => Balle.one((resolve, reject) => 
        setTimeout(() => 
            Math.random() > .5
                ? reject('a problem occurred at #1')
                : resolve(100)
        , 100)
    ),
    r => Balle.one((resolve, reject) => 
        setTimeout(() => 
            Math.random() > .5
                ? reject('a problem occurred at #2')
                : resolve(101 + r)
        , 200)
    ),
    r => Balle.one((resolve, reject) => 
        setTimeout(() => 
            Math.random() > .5
                ? reject('a problem occurred at #3')
                : resolve(102 + r)
        , 300)
    )
])
.then(r => console.log('result : '+ r))
.catch(cause => console.log('cause : '+ cause))
.finally(() => console.log('----- finally -----'));

Balle.all async errors

Balle.all([
    Balle.one((res, rej) => {
        setTimeout(() => {
            res(3)
        }, 1300);
    }),
    Balle.one((res, rej) => {
        setTimeout(() => {
            try{
                throw 'Error occurred';
                // OR throw new Error('Error occurred')
            } catch(e) { rej(e); }
        }, 200);
    })
]).then((r) => {
    console.log('The result is', r)
}).catch((err) => {
    console.log('The error is', err)
})