@aws-solutions-constructs/core 2.50.0 → 2.52.0

package/node_modules/gauge/README.md

@@ -8,14 +8,17 @@ var Gauge = require("gauge")
 
 var gauge = new Gauge()
 
-gauge.show("test", 0.20)
-
-gauge.pulse("this")
-
-gauge.hide()
+gauge.show("working…", 0)
+setTimeout(() => { gauge.pulse(); gauge.show("working…", 0.25) }, 500)
+setTimeout(() => { gauge.pulse(); gauge.show("working…", 0.50) }, 1000)
+setTimeout(() => { gauge.pulse(); gauge.show("working…", 0.75) }, 1500)
+setTimeout(() => { gauge.pulse(); gauge.show("working…", 0.99) }, 2000)
+setTimeout(() => gauge.hide(), 2300)
 ```
 
-![](gauge-demo.gif)
+See also the [demos](docs/demo.js):
+
+![](./docs/gauge-demo.gif)
 
 
 ### CHANGES FROM 1.x
@@ -46,12 +49,12 @@ if **stream** isn't a tty and a tty isn't explicitly provided.
 
 If **stream** is a terminal or if you pass in **tty** to **options** then we
 will detect terminal resizes and redraw to fit.  We do this by watching for
-`resize` events on the tty.  (To work around a bug in verisons of Node prior
+`resize` events on the tty.  (To work around a bug in versions of Node prior
 to 2.5.0, we watch for them on stdout if the tty is stderr.) Resizes to
 larger window sizes will be clean, but shrinking the window will always
 result in some cruft.
 
-**IMPORTANT:** If you prevously were passing in a non-tty stream but you still
+**IMPORTANT:** If you previously were passing in a non-tty stream but you still
 want output (for example, a stream wrapped by the `ansi` module) then you
 need to pass in the **tty** option below, as `gauge` needs access to
 the underlying tty in order to do things like terminal resizes and terminal
@@ -60,7 +63,7 @@ width detection.
 The **options** object can have the following properties, all of which are
 optional:
 
-* **updateInterval**: How often gauge updates should be drawn, in miliseconds.
+* **updateInterval**: How often gauge updates should be drawn, in milliseconds.
 * **fixedFramerate**: Defaults to false on node 0.8, true on everything
   else.  When this is true a timer is created to trigger once every
   `updateInterval` ms, when false, updates are printed as soon as they come
@@ -76,7 +79,7 @@ optional:
   * The name of a theme, which will be looked up in the current *themes*
     object.
   * A configuration object with any of `hasUnicode`, `hasColor` or
-    `platform` keys, which if wlll be used to override our guesses when making
+    `platform` keys, which if will be used to override our guesses when making
     a default theme selection.
 
   If no theme is selected then a default is picked using a combination of our
@@ -94,7 +97,7 @@ optional:
   the gauge starts enabled.  If disabled then all update commands are
   ignored and no gauge will be printed until you call `.enable()`.
 * **Plumbing**: The class to use to actually generate the gauge for
-  printing.  This defaults to `require('gauge/plumbing')` and ordinarly you
+  printing.  This defaults to `require('gauge/plumbing')` and ordinarily you
   shouldn't need to override this.
 * **cleanupOnExit**: Defaults to true. Ordinarily we register an exit
   handler to make sure your cursor is turned back on and the progress bar
@@ -162,7 +165,7 @@ Change the active theme, will be displayed with the next show or pulse. This can
 * The name of a theme, which will be looked up in the current *themes*
   object.
 * A configuration object with any of `hasUnicode`, `hasColor` or
-  `platform` keys, which if wlll be used to override our guesses when making
+  `platform` keys, which if will be used to override our guesses when making
   a default theme selection.
 
 If no theme is selected then a default is picked using a combination of our
@@ -194,7 +197,7 @@ var ourTheme = themes({hasUnicode: true, hasColor: false, platform: 'darwin'})
 
 // create a new theme based on the color ascii theme for this platform
 // that brackets the progress bar with arrows
-var ourTheme = themes.newTheme(theme(hasUnicode: false, hasColor: true}), {
+var ourTheme = themes.newTheme(themes({hasUnicode: false, hasColor: true}), {
   preProgressbar: '→',
   postProgressbar: '←'
 })
@@ -207,7 +210,7 @@ var ThemeSet = require('gauge/theme-set')
 var themes = new ThemeSet()
 // or
 var themes = require('gauge/themes')
-var mythemes = themes.newThemeset() // creates a new themeset based on the default themes
+var mythemes = themes.newThemeSet() // creates a new themeset based on the default themes
 ```
 
 #### themes(opts)
@@ -311,7 +314,7 @@ This *mixes-in* `theme` into all themes currently defined. It also adds it
 to the default parent theme for this themeset, so future themes added to
 this themeset will get the values from `theme` by default.
 
-#### themes.newThemeset()
+#### themes.newThemeSet()
 
 Copy the current themeset into a new one.  This allows you to easily inherit
 one themeset from another.
@@ -350,7 +353,7 @@ be be included verbatum in the output, or objects with the following properties:
 * *align* – (Default: left) Possible values "left", "right" and "center". Works
   as you'd expect from word processors.
 * *length* – Provides a single value for both *minLength* and *maxLength*. If both
-  *length* and *minLength or *maxLength* are specifed then the latter take precedence.
+  *length* and *minLength or *maxLength* are specified then the latter take precedence.
 * *value* – A literal value to use for this template item.
 * *default* – A default value to use for this template item if a value
   wasn't otherwise passed in.

package/node_modules/gauge/{base-theme.js → lib/base-theme.js}

@@ -4,11 +4,15 @@ var progressBar = require('./progress-bar.js')
 
 module.exports = {
   activityIndicator: function (values, theme, width) {
-    if (values.spun == null) return
+    if (values.spun == null) {
+      return
+    }
     return spin(theme, values.spun)
   },
   progressbar: function (values, theme, width) {
-    if (values.completed == null) return
+    if (values.completed == null) {
+      return
+    }
     return progressBar(theme, width, values.completed)
-  }
+  },
 }

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

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

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

@@ -2,7 +2,7 @@
 var Plumbing = require('./plumbing.js')
 var hasUnicode = require('has-unicode')
 var hasColor = require('./has-color.js')
-var onExit = require('signal-exit')
+var onExit = require('signal-exit').onExit
 var defaultThemes = require('./themes')
 var setInterval = require('./set-interval.js')
 var process = require('./process.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,27 @@ 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 (
+    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 +111,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 +130,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 +170,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 +182,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 +221,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 +248,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 +266,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 +276,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/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/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/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/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
 }
-