twitst4tz

index.js (10669B)

---

 /*!
  * depd
  * Copyright(c) 2014-2017 Douglas Christopher Wilson
  * MIT Licensed
  */
 
 /**
  * Module dependencies.
  */
 
 var callSiteToString = require('./lib/compat').callSiteToString
 var eventListenerCount = require('./lib/compat').eventListenerCount
 var relative = require('path').relative
 
 /**
  * Module exports.
  */
 
 module.exports = depd
 
 /**
  * Get the path to base files on.
  */
 
 var basePath = process.cwd()
 
 /**
  * Determine if namespace is contained in the string.
  */
 
 function containsNamespace (str, namespace) {
   var vals = str.split(/[ ,]+/)
   var ns = String(namespace).toLowerCase()
 
   for (var i = 0; i < vals.length; i++) {
     var val = vals[i]
 
     // namespace contained
     if (val && (val === '*' || val.toLowerCase() === ns)) {
       return true
     }
   }
 
   return false
 }
 
 /**
  * Convert a data descriptor to accessor descriptor.
  */
 
 function convertDataDescriptorToAccessor (obj, prop, message) {
   var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
   var value = descriptor.value
 
   descriptor.get = function getter () { return value }
 
   if (descriptor.writable) {
     descriptor.set = function setter (val) { return (value = val) }
   }
 
   delete descriptor.value
   delete descriptor.writable
 
   Object.defineProperty(obj, prop, descriptor)
 
   return descriptor
 }
 
 /**
  * Create arguments string to keep arity.
  */
 
 function createArgumentsString (arity) {
   var str = ''
 
   for (var i = 0; i < arity; i++) {
     str += ', arg' + i
   }
 
   return str.substr(2)
 }
 
 /**
  * Create stack string from stack.
  */
 
 function createStackString (stack) {
   var str = this.name + ': ' + this.namespace
 
   if (this.message) {
     str += ' deprecated ' + this.message
   }
 
   for (var i = 0; i < stack.length; i++) {
     str += '\n    at ' + callSiteToString(stack[i])
   }
 
   return str
 }
 
 /**
  * Create deprecate for namespace in caller.
  */
 
 function depd (namespace) {
   if (!namespace) {
     throw new TypeError('argument namespace is required')
   }
 
   var stack = getStack()
   var site = callSiteLocation(stack[1])
   var file = site[0]
 
   function deprecate (message) {
     // call to self as log
     log.call(deprecate, message)
   }
 
   deprecate._file = file
   deprecate._ignored = isignored(namespace)
   deprecate._namespace = namespace
   deprecate._traced = istraced(namespace)
   deprecate._warned = Object.create(null)
 
   deprecate.function = wrapfunction
   deprecate.property = wrapproperty
 
   return deprecate
 }
 
 /**
  * Determine if namespace is ignored.
  */
 
 function isignored (namespace) {
   /* istanbul ignore next: tested in a child processs */
   if (process.noDeprecation) {
     // --no-deprecation support
     return true
   }
 
   var str = process.env.NO_DEPRECATION || ''
 
   // namespace ignored
   return containsNamespace(str, namespace)
 }
 
 /**
  * Determine if namespace is traced.
  */
 
 function istraced (namespace) {
   /* istanbul ignore next: tested in a child processs */
   if (process.traceDeprecation) {
     // --trace-deprecation support
     return true
   }
 
   var str = process.env.TRACE_DEPRECATION || ''
 
   // namespace traced
   return containsNamespace(str, namespace)
 }
 
 /**
  * Display deprecation message.
  */
 
 function log (message, site) {
   var haslisteners = eventListenerCount(process, 'deprecation') !== 0
 
   // abort early if no destination
   if (!haslisteners && this._ignored) {
     return
   }
 
   var caller
   var callFile
   var callSite
   var depSite
   var i = 0
   var seen = false
   var stack = getStack()
   var file = this._file
 
   if (site) {
     // provided site
     depSite = site
     callSite = callSiteLocation(stack[1])
     callSite.name = depSite.name
     file = callSite[0]
   } else {
     // get call site
     i = 2
     depSite = callSiteLocation(stack[i])
     callSite = depSite
   }
 
   // get caller of deprecated thing in relation to file
   for (; i < stack.length; i++) {
     caller = callSiteLocation(stack[i])
     callFile = caller[0]
 
     if (callFile === file) {
       seen = true
     } else if (callFile === this._file) {
       file = this._file
     } else if (seen) {
       break
     }
   }
 
   var key = caller
     ? depSite.join(':') + '__' + caller.join(':')
     : undefined
 
   if (key !== undefined && key in this._warned) {
     // already warned
     return
   }
 
   this._warned[key] = true
 
   // generate automatic message from call site
   var msg = message
   if (!msg) {
     msg = callSite === depSite || !callSite.name
       ? defaultMessage(depSite)
       : defaultMessage(callSite)
   }
 
   // emit deprecation if listeners exist
   if (haslisteners) {
     var err = DeprecationError(this._namespace, msg, stack.slice(i))
     process.emit('deprecation', err)
     return
   }
 
   // format and write message
   var format = process.stderr.isTTY
     ? formatColor
     : formatPlain
   var output = format.call(this, msg, caller, stack.slice(i))
   process.stderr.write(output + '\n', 'utf8')
 }
 
 /**
  * Get call site location as array.
  */
 
 function callSiteLocation (callSite) {
   var file = callSite.getFileName() || '<anonymous>'
   var line = callSite.getLineNumber()
   var colm = callSite.getColumnNumber()
 
   if (callSite.isEval()) {
     file = callSite.getEvalOrigin() + ', ' + file
   }
 
   var site = [file, line, colm]
 
   site.callSite = callSite
   site.name = callSite.getFunctionName()
 
   return site
 }
 
 /**
  * Generate a default message from the site.
  */
 
 function defaultMessage (site) {
   var callSite = site.callSite
   var funcName = site.name
 
   // make useful anonymous name
   if (!funcName) {
     funcName = '<anonymous@' + formatLocation(site) + '>'
   }
 
   var context = callSite.getThis()
   var typeName = context && callSite.getTypeName()
 
   // ignore useless type name
   if (typeName === 'Object') {
     typeName = undefined
   }
 
   // make useful type name
   if (typeName === 'Function') {
     typeName = context.name || typeName
   }
 
   return typeName && callSite.getMethodName()
     ? typeName + '.' + funcName
     : funcName
 }
 
 /**
  * Format deprecation message without color.
  */
 
 function formatPlain (msg, caller, stack) {
   var timestamp = new Date().toUTCString()
 
   var formatted = timestamp +
     ' ' + this._namespace +
     ' deprecated ' + msg
 
   // add stack trace
   if (this._traced) {
     for (var i = 0; i < stack.length; i++) {
       formatted += '\n    at ' + callSiteToString(stack[i])
     }
 
     return formatted
   }
 
   if (caller) {
     formatted += ' at ' + formatLocation(caller)
   }
 
   return formatted
 }
 
 /**
  * Format deprecation message with color.
  */
 
 function formatColor (msg, caller, stack) {
   var formatted = '\x1b[36;1m' + this._namespace + '\x1b[22;39m' + // bold cyan
     ' \x1b[33;1mdeprecated\x1b[22;39m' + // bold yellow
     ' \x1b[0m' + msg + '\x1b[39m' // reset
 
   // add stack trace
   if (this._traced) {
     for (var i = 0; i < stack.length; i++) {
       formatted += '\n    \x1b[36mat ' + callSiteToString(stack[i]) + '\x1b[39m' // cyan
     }
 
     return formatted
   }
 
   if (caller) {
     formatted += ' \x1b[36m' + formatLocation(caller) + '\x1b[39m' // cyan
   }
 
   return formatted
 }
 
 /**
  * Format call site location.
  */
 
 function formatLocation (callSite) {
   return relative(basePath, callSite[0]) +
     ':' + callSite[1] +
     ':' + callSite[2]
 }
 
 /**
  * Get the stack as array of call sites.
  */
 
 function getStack () {
   var limit = Error.stackTraceLimit
   var obj = {}
   var prep = Error.prepareStackTrace
 
   Error.prepareStackTrace = prepareObjectStackTrace
   Error.stackTraceLimit = Math.max(10, limit)
 
   // capture the stack
   Error.captureStackTrace(obj)
 
   // slice this function off the top
   var stack = obj.stack.slice(1)
 
   Error.prepareStackTrace = prep
   Error.stackTraceLimit = limit
 
   return stack
 }
 
 /**
  * Capture call site stack from v8.
  */
 
 function prepareObjectStackTrace (obj, stack) {
   return stack
 }
 
 /**
  * Return a wrapped function in a deprecation message.
  */
 
 function wrapfunction (fn, message) {
   if (typeof fn !== 'function') {
     throw new TypeError('argument fn must be a function')
   }
 
   var args = createArgumentsString(fn.length)
   var deprecate = this // eslint-disable-line no-unused-vars
   var stack = getStack()
   var site = callSiteLocation(stack[1])
 
   site.name = fn.name
 
    // eslint-disable-next-line no-eval
   var deprecatedfn = eval('(function (' + args + ') {\n' +
     '"use strict"\n' +
     'log.call(deprecate, message, site)\n' +
     'return fn.apply(this, arguments)\n' +
     '})')
 
   return deprecatedfn
 }
 
 /**
  * Wrap property in a deprecation message.
  */
 
 function wrapproperty (obj, prop, message) {
   if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
     throw new TypeError('argument obj must be object')
   }
 
   var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
 
   if (!descriptor) {
     throw new TypeError('must call property on owner object')
   }
 
   if (!descriptor.configurable) {
     throw new TypeError('property must be configurable')
   }
 
   var deprecate = this
   var stack = getStack()
   var site = callSiteLocation(stack[1])
 
   // set site name
   site.name = prop
 
   // convert data descriptor
   if ('value' in descriptor) {
     descriptor = convertDataDescriptorToAccessor(obj, prop, message)
   }
 
   var get = descriptor.get
   var set = descriptor.set
 
   // wrap getter
   if (typeof get === 'function') {
     descriptor.get = function getter () {
       log.call(deprecate, message, site)
       return get.apply(this, arguments)
     }
   }
 
   // wrap setter
   if (typeof set === 'function') {
     descriptor.set = function setter () {
       log.call(deprecate, message, site)
       return set.apply(this, arguments)
     }
   }
 
   Object.defineProperty(obj, prop, descriptor)
 }
 
 /**
  * Create DeprecationError for deprecation
  */
 
 function DeprecationError (namespace, message, stack) {
   var error = new Error()
   var stackString
 
   Object.defineProperty(error, 'constructor', {
     value: DeprecationError
   })
 
   Object.defineProperty(error, 'message', {
     configurable: true,
     enumerable: false,
     value: message,
     writable: true
   })
 
   Object.defineProperty(error, 'name', {
     enumerable: false,
     configurable: true,
     value: 'DeprecationError',
     writable: true
   })
 
   Object.defineProperty(error, 'namespace', {
     configurable: true,
     enumerable: false,
     value: namespace,
     writable: true
   })
 
   Object.defineProperty(error, 'stack', {
     configurable: true,
     enumerable: false,
     get: function () {
       if (stackString !== undefined) {
         return stackString
       }
 
       // prepare stack trace
       return (stackString = createStackString.call(this, stack))
     },
     set: function setter (val) {
       stackString = val
     }
   })
 
   return error
 }