v0.1.2 | Switched the default export to on

Author: json2d

README.md

@@ -11,14 +11,13 @@ really simple error handling with await/async
 inspired by [`await-to-js`](https://github.com/scopsy/await-to-js) whose creator [Dima Grossman](http://blog.grossman.io/how-to-write-async-await-without-try-catch-blocks-in-javascript/) originally blogged about using destructuring array assignment
 
 ## Overview
-This package basically provides 3 syntactical paths to choose from:
+This package basically provides 2 main syntaxes to choose from:
 ```javascript
-const {on, handler} = require('await-on');
+const on = require('await-on');
 
 const fetchData = () => new Promise(/*...*/);
 
 const [err, data] = await on(fetchData());
-const [err, data] = await handler(fetchData)(); //decorator
 const [err, data] = await fetchData().handle(); //prototype extension
 ```
 
@@ -47,20 +46,7 @@ async function foo(req,res) {
 }
 ```
 
-Using the decorator pattern with `handler` yields some cleaner high level code:
-
-```javascript
-const {handler} = require('await-on');
-let fetchData = () => new Promise(/*...*/);
-fetchData = handler(fetchData);
-
-async function foo(req,res) {
-	const [err, data] = await fetchData();
-	!err ? res.send(data) : res.send(err);
-}
-```
-
-Finally, using the prototype extension `handle` on Promise types is also clean and is arguably even more readable because it also uses the chaining pattern already standard when working with Promises 🌟 :
+using the prototype extension `handle` on Promise types is a bit cleaner, and its potentially more readable because its also using the same chaining pattern already standard for working with Promises 🌟 :
 
 ```javascript
 require('await-on');
@@ -71,6 +57,7 @@ async function foo(req,res) {
 }
 ```
 
+
 ## Type fuzziness
 Non-promises will passthrough same as the behavior of the native `await`
 
@@ -79,5 +66,20 @@ const [err,answer] = await on(42); //not a promise but ok no big deal
 console.log(answer) //> 42
 ```
 
+
+## Decorator approach
+A decorator `on.handler` is also provided to wrap promise bearing functions with the handling functionalities:
+
+```javascript
+const {handler} = require('await-on');
+let fetchData = () => new Promise(/*...*/);
+fetchDataAndHandle = handler(fetchData);
+
+async function foo(req,res) {
+	const [err, data] = await fetchDataAndHandle();
+	!err ? res.send(data) : res.send(err);
+}
+```
+
 ## License
 MIT License. See [License](https://github.com/bitstrider/await-on/blob/master/LICENSE) in the repository.

lib/await-on.js

@@ -22,11 +22,11 @@ function on(promise) {
  * @param  {Function} wrapped    Function to be decorated
  * @return {Function}            Function decorated
  */
-const handler = (wrapped) => () => on(wrapped())
+on.handler = (wrapped) => () => on(wrapped())
 
 //Promise type extension
 global.Promise.prototype.handle = function() {
   return on(this)
 }
 
-module.exports = {handler,on}
+module.exports = on

package.json

@@ -1,6 +1,6 @@
 {
   "name": "await-on",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "really simple error handling with await/async",
   "main": "lib/await-on.js",
   "directories": {

test/core.js

@@ -1,6 +1,5 @@
 const tap = require('tap')
-const {handler,on} = require('../lib/await-on')
-
+const on = require('../lib/await-on')
 const ANSWER = 42
 const ERROR = new Error('Need more time to figure that out')
 
@@ -19,7 +18,7 @@ tap.test("on", async function (t) {
 tap.test("@handler", async function (t) {
   t.plan(2)
 
-	const waitOneHandle = handler(waitOne)
+	const waitOneHandle = on.handler(waitOne)
 
 	const [err,res] = await waitOneHandle()