pnpm 6.22.1 → 6.23.2

package/dist/node_modules/gauge/lib/demo.js

@@ -0,0 +1,45 @@
+var Gauge = require('./')
+var gaugeDefault = require('./themes.js')
+var onExit = require('signal-exit')
+
+var activeGauge
+
+onExit(function () {
+  activeGauge.disable()
+})
+
+var themes = gaugeDefault.getThemeNames()
+
+nextBar()
+function nextBar () {
+  var themeName = themes.shift()
+
+  console.log('Demoing output for ' + themeName)
+
+  var gt = new Gauge(process.stderr, {
+    updateInterval: 50,
+    theme: themeName,
+    cleanupOnExit: false,
+  })
+  activeGauge = gt
+
+  var progress = 0
+
+  var cnt = 0
+  var pulse = setInterval(function () {
+    gt.pulse('this is a thing that happened ' + (++cnt))
+  }, 110)
+  var prog = setInterval(function () {
+    progress += 0.04
+    gt.show(themeName + ':' + Math.round(progress * 1000), progress)
+    if (progress >= 1) {
+      clearInterval(prog)
+      clearInterval(pulse)
+      gt.disable()
+      if (themes.length) {
+        nextBar()
+      }
+    }
+  }, 100)
+  gt.show()
+}

package/dist/node_modules/gauge/lib/has-color.js

@@ -0,0 +1,4 @@
+'use strict'
+var colorSupport = require('color-support')
+
+module.exports = colorSupport().hasBasic

package/dist/node_modules/gauge/{index.js → lib/index.js}

@@ -32,7 +32,7 @@ function Gauge (arg1, arg2) {
   this._status = {
     spun: 0,
     section: '',
-    subsection: ''
+    subsection: '',
   }
   this._paused = false // are we paused for back pressure?
   this._disabled = true // are all progress bar updates disabled?
@@ -50,10 +50,10 @@ function Gauge (arg1, arg2) {
   this._theme = options.theme
   var theme = this._computeTheme(options.theme)
   var template = options.template || [
-    {type: 'progressbar', length: 20},
-    {type: 'activityIndicator', kerning: 1, length: 1},
-    {type: 'section', kerning: 1, default: ''},
-    {type: 'subsection', kerning: 1, default: ''}
+    { type: 'progressbar', length: 20 },
+    { type: 'activityIndicator', kerning: 1, length: 1 },
+    { type: 'section', kerning: 1, default: '' },
+    { type: 'subsection', kerning: 1, default: '' },
   ]
   this.setWriteTo(writeTo, options.tty)
   var PlumbingClass = options.Plumbing || Plumbing
@@ -79,17 +79,28 @@ Gauge.prototype.isEnabled = function () {
 
 Gauge.prototype.setTemplate = function (template) {
   this._gauge.setTemplate(template)
-  if (this._showing) this._requestRedraw()
+  if (this._showing) {
+    this._requestRedraw()
+  }
 }
 
 Gauge.prototype._computeTheme = function (theme) {
-  if (!theme) theme = {}
+  if (!theme) {
+    theme = {}
+  }
   if (typeof theme === 'string') {
     theme = this._themes.getTheme(theme)
-  } else if (theme && (Object.keys(theme).length === 0 || theme.hasUnicode != null || theme.hasColor != null)) {
+  } else if (
+    theme &&
+    (Object.keys(theme).length === 0 || theme.hasUnicode != null || theme.hasColor != null)
+  ) {
     var useUnicode = theme.hasUnicode == null ? hasUnicode() : theme.hasUnicode
     var useColor = theme.hasColor == null ? hasColor : theme.hasColor
-    theme = this._themes.getDefault({hasUnicode: useUnicode, hasColor: useColor, platform: theme.platform})
+    theme = this._themes.getDefault({
+      hasUnicode: useUnicode,
+      hasColor: useColor,
+      platform: theme.platform,
+    })
   }
   return theme
 }
@@ -101,13 +112,17 @@ Gauge.prototype.setThemeset = function (themes) {
 
 Gauge.prototype.setTheme = function (theme) {
   this._gauge.setTheme(this._computeTheme(theme))
-  if (this._showing) this._requestRedraw()
+  if (this._showing) {
+    this._requestRedraw()
+  }
   this._theme = theme
 }
 
 Gauge.prototype._requestRedraw = function () {
   this._needsRedraw = true
-  if (!this._fixedFramerate) this._doRedraw()
+  if (!this._fixedFramerate) {
+    this._doRedraw()
+  }
 }
 
 Gauge.prototype.getWidth = function () {
@@ -116,25 +131,39 @@ Gauge.prototype.getWidth = function () {
 
 Gauge.prototype.setWriteTo = function (writeTo, tty) {
   var enabled = !this._disabled
-  if (enabled) this.disable()
+  if (enabled) {
+    this.disable()
+  }
   this._writeTo = writeTo
   this._tty = tty ||
     (writeTo === process.stderr && process.stdout.isTTY && process.stdout) ||
     (writeTo.isTTY && writeTo) ||
     this._tty
-  if (this._gauge) this._gauge.setWidth(this.getWidth())
-  if (enabled) this.enable()
+  if (this._gauge) {
+    this._gauge.setWidth(this.getWidth())
+  }
+  if (enabled) {
+    this.enable()
+  }
 }
 
 Gauge.prototype.enable = function () {
-  if (!this._disabled) return
+  if (!this._disabled) {
+    return
+  }
   this._disabled = false
-  if (this._tty) this._enableEvents()
-  if (this._showing) this.show()
+  if (this._tty) {
+    this._enableEvents()
+  }
+  if (this._showing) {
+    this.show()
+  }
 }
 
 Gauge.prototype.disable = function () {
-  if (this._disabled) return
+  if (this._disabled) {
+    return
+  }
   if (this._showing) {
     this._lastUpdateAt = null
     this._showing = false
@@ -142,7 +171,9 @@ Gauge.prototype.disable = function () {
     this._showing = true
   }
   this._disabled = true
-  if (this._tty) this._disableEvents()
+  if (this._tty) {
+    this._disableEvents()
+  }
 }
 
 Gauge.prototype._enableEvents = function () {
@@ -152,19 +183,29 @@ Gauge.prototype._enableEvents = function () {
   this._tty.on('resize', this._$$handleSizeChange)
   if (this._fixedFramerate) {
     this.redrawTracker = setInterval(this._$$doRedraw, this._updateInterval)
-    if (this.redrawTracker.unref) this.redrawTracker.unref()
+    if (this.redrawTracker.unref) {
+      this.redrawTracker.unref()
+    }
   }
 }
 
 Gauge.prototype._disableEvents = function () {
   this._tty.removeListener('resize', this._$$handleSizeChange)
-  if (this._fixedFramerate) clearInterval(this.redrawTracker)
-  if (this._removeOnExit) this._removeOnExit()
+  if (this._fixedFramerate) {
+    clearInterval(this.redrawTracker)
+  }
+  if (this._removeOnExit) {
+    this._removeOnExit()
+  }
 }
 
 Gauge.prototype.hide = function (cb) {
-  if (this._disabled) return cb && process.nextTick(cb)
-  if (!this._showing) return cb && process.nextTick(cb)
+  if (this._disabled) {
+    return cb && process.nextTick(cb)
+  }
+  if (!this._showing) {
+    return cb && process.nextTick(cb)
+  }
   this._showing = false
   this._doRedraw()
   cb && setImmediate(cb)
@@ -181,16 +222,24 @@ Gauge.prototype.show = function (section, completed) {
       this._status[key] = section[key]
     }
   }
-  if (completed != null) this._status.completed = completed
-  if (this._disabled) return
+  if (completed != null) {
+    this._status.completed = completed
+  }
+  if (this._disabled) {
+    return
+  }
   this._requestRedraw()
 }
 
 Gauge.prototype.pulse = function (subsection) {
   this._status.subsection = subsection || ''
-  this._status.spun ++
-  if (this._disabled) return
-  if (!this._showing) return
+  this._status.spun++
+  if (this._disabled) {
+    return
+  }
+  if (!this._showing) {
+    return
+  }
   this._requestRedraw()
 }
 
@@ -200,10 +249,14 @@ Gauge.prototype._handleSizeChange = function () {
 }
 
 Gauge.prototype._doRedraw = function () {
-  if (this._disabled || this._paused) return
+  if (this._disabled || this._paused) {
+    return
+  }
   if (!this._fixedFramerate) {
     var now = Date.now()
-    if (this._lastUpdateAt && now - this._lastUpdateAt < this._updateInterval) return
+    if (this._lastUpdateAt && now - this._lastUpdateAt < this._updateInterval) {
+      return
+    }
     this._lastUpdateAt = now
   }
   if (!this._showing && this._onScreen) {
@@ -214,7 +267,9 @@ Gauge.prototype._doRedraw = function () {
     }
     return this._writeTo.write(result)
   }
-  if (!this._showing && !this._onScreen) return
+  if (!this._showing && !this._onScreen) {
+    return
+  }
   if (this._showing && !this._onScreen) {
     this._onScreen = true
     this._needsRedraw = true
@@ -222,7 +277,9 @@ Gauge.prototype._doRedraw = function () {
       this._writeTo.write(this._gauge.hideCursor())
     }
   }
-  if (!this._needsRedraw) return
+  if (!this._needsRedraw) {
+    return
+  }
   if (!this._writeTo.write(this._gauge.show(this._status))) {
     this._paused = true
     this._writeTo.on('drain', callWith(this, function () {

package/dist/node_modules/gauge/{plumbing.js → lib/plumbing.js}

@@ -4,7 +4,9 @@ var renderTemplate = require('./render-template.js')
 var validate = require('aproba')
 
 var Plumbing = module.exports = function (theme, template, width) {
-  if (!width) width = 80
+  if (!width) {
+    width = 80
+  }
   validate('OAN', [theme, template, width])
   this.showing = false
   this.theme = theme

package/dist/node_modules/gauge/{progress-bar.js → lib/progress-bar.js}

@@ -6,14 +6,20 @@ var stringWidth = require('string-width')
 
 module.exports = function (theme, width, completed) {
   validate('ONN', [theme, width, completed])
-  if (completed < 0) completed = 0
-  if (completed > 1) completed = 1
-  if (width <= 0) return ''
+  if (completed < 0) {
+    completed = 0
+  }
+  if (completed > 1) {
+    completed = 1
+  }
+  if (width <= 0) {
+    return ''
+  }
   var sofar = Math.round(width * completed)
   var rest = width - sofar
   var template = [
-    {type: 'complete', value: repeat(theme.complete, sofar), length: sofar},
-    {type: 'remaining', value: repeat(theme.remaining, rest), length: rest}
+    { type: 'complete', value: repeat(theme.complete, sofar), length: sofar },
+    { type: 'remaining', value: repeat(theme.remaining, rest), length: rest },
   ]
   return renderTemplate(width, template, theme)
 }
@@ -27,7 +33,7 @@ function repeat (string, width) {
       result += string
     }
     n = Math.floor(n / 2)
-    /*eslint no-self-assign: 0*/
+    /* eslint no-self-assign: 0 */
     string += string
   } while (n && stringWidth(result) < width)
 

package/dist/node_modules/gauge/{render-template.js → lib/render-template.js}

@@ -1,7 +1,6 @@
 'use strict'
 var align = require('wide-align')
 var validate = require('aproba')
-var objectAssign = require('object-assign')
 var wideTruncate = require('./wide-truncate')
 var error = require('./error')
 var TemplateItem = require('./template-item')
@@ -29,18 +28,20 @@ function postType (item) {
 }
 
 function hasPreOrPost (item, values) {
-  if (!item.type) return
+  if (!item.type) {
+    return
+  }
   return values[preType(item)] || values[postType(item)]
 }
 
 function generatePreAndPost (baseItem, parentValues) {
-  var item = objectAssign({}, baseItem)
+  var item = Object.assign({}, baseItem)
   var values = Object.create(parentValues)
   var template = []
   var pre = preType(item)
   var post = postType(item)
   if (values[pre]) {
-    template.push({value: values[pre]})
+    template.push({ value: values[pre] })
     values[pre] = null
   }
   item.minLength = null
@@ -49,7 +50,7 @@ function generatePreAndPost (baseItem, parentValues) {
   template.push(item)
   values[item.type] = values[item.type]
   if (values[post]) {
-    template.push({value: values[post]})
+    template.push({ value: values[post] })
     values[post] = null
   }
   return function ($1, $2, length) {
@@ -72,49 +73,73 @@ function prepareItems (width, template, values) {
         cloned.value = values[type]
       }
     }
-    if (cloned.value == null || cloned.value === '') return null
+    if (cloned.value == null || cloned.value === '') {
+      return null
+    }
     cloned.index = index
     cloned.first = index === 0
     cloned.last = index === arr.length - 1
-    if (hasPreOrPost(cloned, values)) cloned.value = generatePreAndPost(cloned, values)
+    if (hasPreOrPost(cloned, values)) {
+      cloned.value = generatePreAndPost(cloned, values)
+    }
     return cloned
   }
 
-  var output = template.map(cloneAndObjectify).filter(function (item) { return item != null })
+  var output = template.map(cloneAndObjectify).filter(function (item) {
+    return item != null
+  })
 
-  var outputLength = 0
   var remainingSpace = width
   var variableCount = output.length
 
   function consumeSpace (length) {
-    if (length > remainingSpace) length = remainingSpace
-    outputLength += length
+    if (length > remainingSpace) {
+      length = remainingSpace
+    }
     remainingSpace -= length
   }
 
   function finishSizing (item, length) {
-    if (item.finished) throw new error.Internal('Tried to finish template item that was already finished')
-    if (length === Infinity) throw new error.Internal('Length of template item cannot be infinity')
-    if (length != null) item.length = length
+    if (item.finished) {
+      throw new error.Internal('Tried to finish template item that was already finished')
+    }
+    if (length === Infinity) {
+      throw new error.Internal('Length of template item cannot be infinity')
+    }
+    if (length != null) {
+      item.length = length
+    }
     item.minLength = null
     item.maxLength = null
     --variableCount
     item.finished = true
-    if (item.length == null) item.length = item.getBaseLength()
-    if (item.length == null) throw new error.Internal('Finished template items must have a length')
+    if (item.length == null) {
+      item.length = item.getBaseLength()
+    }
+    if (item.length == null) {
+      throw new error.Internal('Finished template items must have a length')
+    }
     consumeSpace(item.getLength())
   }
 
   output.forEach(function (item) {
-    if (!item.kerning) return
+    if (!item.kerning) {
+      return
+    }
     var prevPadRight = item.first ? 0 : output[item.index - 1].padRight
-    if (!item.first && prevPadRight < item.kerning) item.padLeft = item.kerning - prevPadRight
-    if (!item.last) item.padRight = item.kerning
+    if (!item.first && prevPadRight < item.kerning) {
+      item.padLeft = item.kerning - prevPadRight
+    }
+    if (!item.last) {
+      item.padRight = item.kerning
+    }
   })
 
   // Finish any that have a fixed (literal or intuited) length
   output.forEach(function (item) {
-    if (item.getBaseLength() == null) return
+    if (item.getBaseLength() == null) {
+      return
+    }
     finishSizing(item)
   })
 
@@ -125,34 +150,48 @@ function prepareItems (width, template, values) {
     resizing = false
     hunkSize = Math.round(remainingSpace / variableCount)
     output.forEach(function (item) {
-      if (item.finished) return
-      if (!item.maxLength) return
+      if (item.finished) {
+        return
+      }
+      if (!item.maxLength) {
+        return
+      }
       if (item.getMaxLength() < hunkSize) {
         finishSizing(item, item.maxLength)
         resizing = true
       }
     })
   } while (resizing && resized++ < output.length)
-  if (resizing) throw new error.Internal('Resize loop iterated too many times while determining maxLength')
+  if (resizing) {
+    throw new error.Internal('Resize loop iterated too many times while determining maxLength')
+  }
 
   resized = 0
   do {
     resizing = false
     hunkSize = Math.round(remainingSpace / variableCount)
     output.forEach(function (item) {
-      if (item.finished) return
-      if (!item.minLength) return
+      if (item.finished) {
+        return
+      }
+      if (!item.minLength) {
+        return
+      }
       if (item.getMinLength() >= hunkSize) {
         finishSizing(item, item.minLength)
         resizing = true
       }
     })
   } while (resizing && resized++ < output.length)
-  if (resizing) throw new error.Internal('Resize loop iterated too many times while determining minLength')
+  if (resizing) {
+    throw new error.Internal('Resize loop iterated too many times while determining minLength')
+  }
 
   hunkSize = Math.round(remainingSpace / variableCount)
   output.forEach(function (item) {
-    if (item.finished) return
+    if (item.finished) {
+      return
+    }
     finishSizing(item, hunkSize)
   })
 
@@ -171,7 +210,9 @@ function renderFunction (item, values, length) {
 function renderValue (item, values) {
   var length = item.getBaseLength()
   var value = typeof item.value === 'function' ? renderFunction(item, values, length) : item.value
-  if (value == null || value === '') return ''
+  if (value == null || value === '') {
+    return ''
+  }
   var alignWith = align[item.align] || align.left
   var leftPadding = item.padLeft ? align.left('', item.padLeft) : ''
   var rightPadding = item.padRight ? align.right('', item.padRight) : ''

package/dist/node_modules/gauge/{template-item.js → lib/template-item.js}

@@ -4,7 +4,9 @@ var stringWidth = require('string-width')
 module.exports = TemplateItem
 
 function isPercent (num) {
-  if (typeof num !== 'string') return false
+  if (typeof num !== 'string') {
+    return false
+  }
   return num.slice(-1) === '%'
 }
 
@@ -30,7 +32,9 @@ function TemplateItem (values, outputLength) {
   if (typeof values === 'string') {
     this.value = values
   } else {
-    for (var prop in values) this[prop] = values[prop]
+    for (var prop in values) {
+      this[prop] = values[prop]
+    }
   }
   // Realize percents
   if (isPercent(this.length)) {
@@ -49,7 +53,12 @@ TemplateItem.prototype = {}
 
 TemplateItem.prototype.getBaseLength = function () {
   var length = this.length
-  if (length == null && typeof this.value === 'string' && this.maxLength == null && this.minLength == null) {
+  if (
+    length == null &&
+    typeof this.value === 'string' &&
+    this.maxLength == null &&
+    this.minLength == null
+  ) {
     length = stringWidth(this.value)
   }
   return length
@@ -57,17 +66,22 @@ TemplateItem.prototype.getBaseLength = function () {
 
 TemplateItem.prototype.getLength = function () {
   var length = this.getBaseLength()
-  if (length == null) return null
+  if (length == null) {
+    return null
+  }
   return length + this.padLeft + this.padRight
 }
 
 TemplateItem.prototype.getMaxLength = function () {
-  if (this.maxLength == null) return null
+  if (this.maxLength == null) {
+    return null
+  }
   return this.maxLength + this.padLeft + this.padRight
 }
 
 TemplateItem.prototype.getMinLength = function () {
-  if (this.minLength == null) return null
+  if (this.minLength == null) {
+    return null
+  }
   return this.minLength + this.padLeft + this.padRight
 }
-