areq - npm Package Compare versions

Comparing version 0.0.2 to 0.0.3

index.js

 var EventEmitter = require('events');
 
-var AREQ_TIMEOUT = 30,  // seconds
+function Areq(emitter, areqTimeout) {
+    if (!emitter instanceof EventEmitter)
+        throw new TypeError('Input emitter should be an EventEmitter.');
 
-var _pendings = {}; // { evtName: { deferred, listener, timeout, pending }, ... }
+    this._emitter = emitter;
+    this._areqTimeout = areqTimeout || 30000;
+    this._pendings = {};    // { evtName: { deferred, listener }, ... }
+}
 
-var areq = {
-    emitter: null
+Areq.prototype.resolve = function (evt, value) {
+    var rec = this.getRecord(evt),
+        deferred = rec ? rec.deferred : null;
+
+    if (deferred && deferred.promise.isPending())
+        deferred.resolve(value);
+
+    this.deregister(evt);
 };
 
-areq.register = function (evt, deferred, listener) {
+Areq.prototype.reject = function (evt, err) {
+    var rec = this.getRecord(evt),
+        deferred = rec ? rec.deferred : null;
+
+    if (deferred && deferred.promise.isPending())
+        deferred.reject(err);
+
+    this.deregister(evt);
+};
+
+Areq.prototype.register = function (evt, deferred, listener, time) {
     var registered = false,
+        areqTimeout = time || this._areqTimeout,
         alarm;  // timeout controller
@@ -18,17 +40,17 @@
 
-    if (typeof deferred === 'function') {
-        listener = deferred;
-        deferred = null;
-    }
+    if (typeof listener !== 'function')
+        throw new TypeError('listener should be a function.');
 
-    if (areq.getRecord(evt)) {  // someone waiting same event
+    if (this.getRecord(evt)) {  // someone waiting same event
         registered = false;
     } else {
-        alarm = createAlarm(evt);
-        areq.emitter.once(evt, listener);
+        deferred.promise.timeout(areqTimeout).fail(function(err) {
+            deferred.reject(err);
+        }).done();
 
-        _pendings[evt] = {
+        this._emitter.once(evt, listener);
+
+        this._pendings[evt] = {
             listener: listener,
-            deferred: deferred,
-            timeout: alarm
+            deferred: deferred
         }
@@ -42,22 +64,12 @@
 
-areq.deregister = function (evt) {
+Areq.prototype.deregister = function (evt) {
     if (typeof evt !== 'string')
         throw new TypeError('evt should be a string.');
 
-    var rec = areq.getRecord(evt),
-        emitter = areq.emitter;
+    var rec = this.getRecord(evt),
+        emitter = this._emitter;
 
     if (rec) {
-        if (rec.timeout) {
-            clearTimeout(rec.timeout);
-            rec.timeout = null;
-        }
-
-        if (rec.deferred) {
-            if (rec.deferred.isPending()) {
-                rec.deferred.reject(new Error('Areq been cancelled. If this is not what you expect, please settle ' 
-                                            + 'the promise state then do the deregister.'));
-            }
+        if (rec.deferred)
             rec.deferred = null;
-        }
 
@@ -69,56 +81,18 @@ if (rec.listener) {
 
-        areq.removeRecord(evt);
+        this._pendings[evt] = null;
+        delete this._pendings[evt];
     }
 };
 
-areq.getRecord = function (evt) {
-    return _pendings[evt];
+Areq.prototype.getRecord = function (evt) {
+    return this._pendings[evt];
 };
 
-areq.removeRecord = function (evt) {
-    _pendings[evt] = null;
-    delete _pendings[evt];
+Areq.prototype.isEventPending = function (evt) {
+    return !!this._pendings[evt];
 };
 
-areq.isEventPending = function (evt) {
-    return !!_pendings[evt];
-};
-
-areq.setAreqTimeout = function (time) {
-    AREQ_TIMEOUT = time;
-};
-
 /*************************************************************************************************/
-/*** Private Functions                                                                         ***/
-/*************************************************************************************************/
-function createAlarm(evt) {
-    var alarm;
-
-    alarm = setTimeout(function () {
-        var rec = areq.getRecord(evt),
-            deferred = rec ? rec.deferred : null;
-
-        if (rec) {
-            // state should be settled
-            if (deferred)
-                deferred.reject(new Error('Request timeout.'));
-            else if (typeof rec.listener === 'function')
-                rec.listener(new Error('Request timeout.'));
-
-            areq.deregister(evt);
-        }
-    }, AREQ_TIMEOUT);
-
-    return alarm;
-}
-
-/*************************************************************************************************/
 /*** Module Exports                                                                            ***/
 /*************************************************************************************************/
-module.exports = function (emitter) {
-    if (!emitter instanceof EventEmitter)
-        throw new TypeError('Input emitter should be an EventEmitter.');
-
-    areq.emitter = emitter;
-    return areq;
-};
+module.exports = Areq;

package.json

 {
   "name": "areq",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "An asynchronous request controller",
@@ -5,0 +5,0 @@ "main": "index.js",

No alert changes

Worsened metrics

Total package byte prevSize

4765

decreased by-13%

Lines of code

71

decreased by-24.47%

No dependency changes