| var wrappy = require('wrappy') | |
| var reqs = Object.create(null) | |
| var once = require('once') | |
| 
 | |
| module.exports = wrappy(inflight) | |
| 
 | |
| function inflight (key, cb) { | |
|   if (reqs[key]) { | |
|     reqs[key].push(cb) | |
|     return null | |
|   } else { | |
|     reqs[key] = [cb] | |
|     return makeres(key) | |
|   } | |
| } | |
| 
 | |
| function makeres (key) { | |
|   return once(function RES () { | |
|     var cbs = reqs[key] | |
|     var len = cbs.length | |
|     var args = slice(arguments) | |
| 
 | |
|     // XXX It's somewhat ambiguous whether a new callback added in this | |
|     // pass should be queued for later execution if something in the | |
|     // list of callbacks throws, or if it should just be discarded. | |
|     // However, it's such an edge case that it hardly matters, and either | |
|     // choice is likely as surprising as the other. | |
|     // As it happens, we do go ahead and schedule it for later execution. | |
|     try { | |
|       for (var i = 0; i < len; i++) { | |
|         cbs[i].apply(null, args) | |
|       } | |
|     } finally { | |
|       if (cbs.length > len) { | |
|         // added more in the interim. | |
|         // de-zalgo, just in case, but don't call again. | |
|         cbs.splice(0, len) | |
|         process.nextTick(function () { | |
|           RES.apply(null, args) | |
|         }) | |
|       } else { | |
|         delete reqs[key] | |
|       } | |
|     } | |
|   }) | |
| } | |
| 
 | |
| function slice (args) { | |
|   var length = args.length | |
|   var array = [] | |
| 
 | |
|   for (var i = 0; i < length; i++) array[i] = args[i] | |
|   return array | |
| }
 |