time-to-botec

index.js (5708B)

---

 // Note: since nyc uses this module to output coverage, any lines
 // that are in the direct sync flow of nyc's outputCoverage are
 // ignored, since we can never get coverage for them.
 // grab a reference to node's real process object right away
 var process = global.process
 
 const processOk = function (process) {
   return process &&
     typeof process === 'object' &&
     typeof process.removeListener === 'function' &&
     typeof process.emit === 'function' &&
     typeof process.reallyExit === 'function' &&
     typeof process.listeners === 'function' &&
     typeof process.kill === 'function' &&
     typeof process.pid === 'number' &&
     typeof process.on === 'function'
 }
 
 // some kind of non-node environment, just no-op
 /* istanbul ignore if */
 if (!processOk(process)) {
   module.exports = function () {
     return function () {}
   }
 } else {
   var assert = require('assert')
   var signals = require('./signals.js')
   var isWin = /^win/i.test(process.platform)
 
   var EE = require('events')
   /* istanbul ignore if */
   if (typeof EE !== 'function') {
     EE = EE.EventEmitter
   }
 
   var emitter
   if (process.__signal_exit_emitter__) {
     emitter = process.__signal_exit_emitter__
   } else {
     emitter = process.__signal_exit_emitter__ = new EE()
     emitter.count = 0
     emitter.emitted = {}
   }
 
   // Because this emitter is a global, we have to check to see if a
   // previous version of this library failed to enable infinite listeners.
   // I know what you're about to say.  But literally everything about
   // signal-exit is a compromise with evil.  Get used to it.
   if (!emitter.infinite) {
     emitter.setMaxListeners(Infinity)
     emitter.infinite = true
   }
 
   module.exports = function (cb, opts) {
     /* istanbul ignore if */
     if (!processOk(global.process)) {
       return function () {}
     }
     assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
 
     if (loaded === false) {
       load()
     }
 
     var ev = 'exit'
     if (opts && opts.alwaysLast) {
       ev = 'afterexit'
     }
 
     var remove = function () {
       emitter.removeListener(ev, cb)
       if (emitter.listeners('exit').length === 0 &&
           emitter.listeners('afterexit').length === 0) {
         unload()
       }
     }
     emitter.on(ev, cb)
 
     return remove
   }
 
   var unload = function unload () {
     if (!loaded || !processOk(global.process)) {
       return
     }
     loaded = false
 
     signals.forEach(function (sig) {
       try {
         process.removeListener(sig, sigListeners[sig])
       } catch (er) {}
     })
     process.emit = originalProcessEmit
     process.reallyExit = originalProcessReallyExit
     emitter.count -= 1
   }
   module.exports.unload = unload
 
   var emit = function emit (event, code, signal) {
     /* istanbul ignore if */
     if (emitter.emitted[event]) {
       return
     }
     emitter.emitted[event] = true
     emitter.emit(event, code, signal)
   }
 
   // { <signal>: <listener fn>, ... }
   var sigListeners = {}
   signals.forEach(function (sig) {
     sigListeners[sig] = function listener () {
       /* istanbul ignore if */
       if (!processOk(global.process)) {
         return
       }
       // If there are no other listeners, an exit is coming!
       // Simplest way: remove us and then re-send the signal.
       // We know that this will kill the process, so we can
       // safely emit now.
       var listeners = process.listeners(sig)
       if (listeners.length === emitter.count) {
         unload()
         emit('exit', null, sig)
         /* istanbul ignore next */
         emit('afterexit', null, sig)
         /* istanbul ignore next */
         if (isWin && sig === 'SIGHUP') {
           // "SIGHUP" throws an `ENOSYS` error on Windows,
           // so use a supported signal instead
           sig = 'SIGINT'
         }
         /* istanbul ignore next */
         process.kill(process.pid, sig)
       }
     }
   })
 
   module.exports.signals = function () {
     return signals
   }
 
   var loaded = false
 
   var load = function load () {
     if (loaded || !processOk(global.process)) {
       return
     }
     loaded = true
 
     // This is the number of onSignalExit's that are in play.
     // It's important so that we can count the correct number of
     // listeners on signals, and don't wait for the other one to
     // handle it instead of us.
     emitter.count += 1
 
     signals = signals.filter(function (sig) {
       try {
         process.on(sig, sigListeners[sig])
         return true
       } catch (er) {
         return false
       }
     })
 
     process.emit = processEmit
     process.reallyExit = processReallyExit
   }
   module.exports.load = load
 
   var originalProcessReallyExit = process.reallyExit
   var processReallyExit = function processReallyExit (code) {
     /* istanbul ignore if */
     if (!processOk(global.process)) {
       return
     }
     process.exitCode = code || /* istanbul ignore next */ 0
     emit('exit', process.exitCode, null)
     /* istanbul ignore next */
     emit('afterexit', process.exitCode, null)
     /* istanbul ignore next */
     originalProcessReallyExit.call(process, process.exitCode)
   }
 
   var originalProcessEmit = process.emit
   var processEmit = function processEmit (ev, arg) {
     if (ev === 'exit' && processOk(global.process)) {
       /* istanbul ignore else */
       if (arg !== undefined) {
         process.exitCode = arg
       }
       var ret = originalProcessEmit.apply(this, arguments)
       /* istanbul ignore next */
       emit('exit', process.exitCode, null)
       /* istanbul ignore next */
       emit('afterexit', process.exitCode, null)
       /* istanbul ignore next */
       return ret
     } else {
       return originalProcessEmit.apply(this, arguments)
     }
   }
 }