cope is ment as a replacement to co for environments where you can't or don't want yet to use generator functions, but it comes with a bonus of progress reporting what co won't be able to do cause of possibility of using loops inside of generator function.
Where co manages generator function that has to yield Promises and resumes function when these Promises are resolved, cope deals with sets of function that return Promises. Basically same things can be achieved with co and cope, but, of course, in different ways.
Let's say (for the sake of keeping this example very simple) that getting two requires three and operation of addition is worth separating.
var three = Promise.resolve(3);
three
.then(three => {
return Promise.resolve(three - 1)
.then( two => {
return {three,two};
});
})
.then(five => console.log(five); /* 5 */);
co(function *(){
var three = yield Promise.resolve(3);
var two = yield Promise.resolve(three - 1);
return three + two;
}).then(five => console.log(five); /* 5 */);
cope(()=>Promise.resolve(3))
((three) => Promise.resolve(three - 1))
((two,three) => three + two)
()
.then(five => console.log(five); /* 5 */);
npm install arturkulig/cope --save
cope
is packed with UMD, so can be used as CommonJS/AMD/global/ES6 module.
ES6 example
import cope from 'path_to_dist_folder/cope.js';
CommonJS
var cope = require('cope');
Global registration
<script src="path_to_dist_folder/cope.js"></script>
<script>
var cope = window.cope;
</script>
cope
//so like this we start we define a queue
(fetch('/api/something'))
// this will download something from some backend
(response => response.json())
// with fetch we have to transform response to an object if it's json
(json => console.log(json))
// so currently we are just previewing the response
()
// and with this will actually run the queue
You can reuse once defined queue.
setInterval(
cope
(fetch('/api/something'))
(response => response.json())
(json => console.log(json)),
1000
);
Due to lib returning enhanced Promise you can do progress reporting inside a component or a store where you hold such information.
cope
(()=>asyncTask1())
(()=>asyncTask2())
(()=>asyncTask3())
(()=>asyncTask4())
().then(
(result) => console.log("done!", result),
(reason) => console.log("oopsies!", reason),
(progress) => console.log("almost done: ", progress*100, "%")
)
..so if everything goes OK, it should output
almost done: 25%
almost done: 50%
almost done: 75%
almost done: 100%
done!
If nesting copes you still get most precise progress result. Let's change previous example a little bit.
cope
(() => cope
(()=>asyncTask1())
(()=>asyncTask2())
(() => asyncTask3())
().then(
(result) => console.log("done!", result),
(reason) => console.log("oopsies!", reason),
(progress) => console.log("almost done: ", progress*100, "%")
)
..again, if everything goes OK, it should output
almost done: 25%
almost done: 50%
almost done: 100%
done!