@aws-solutions-constructs/core 2.51.0 → 2.52.0

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
 }
-

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

@@ -1,5 +1,4 @@
 'use strict'
-var objectAssign = require('object-assign')
 
 module.exports = function () {
   return ThemeSetProto.newThemeSet()
@@ -14,7 +13,7 @@ ThemeSetProto.newTheme = function (parent, theme) {
     theme = parent
     parent = this.baseTheme
   }
-  return objectAssign({}, parent, theme)
+  return Object.assign({}, parent, theme)
 }
 
 ThemeSetProto.getThemeNames = function () {
@@ -28,13 +27,15 @@ ThemeSetProto.addTheme = function (name, parent, theme) {
 ThemeSetProto.addToAllThemes = function (theme) {
   var themes = this.themes
   Object.keys(themes).forEach(function (name) {
-    objectAssign(themes[name], theme)
+    Object.assign(themes[name], theme)
   })
-  objectAssign(this.baseTheme, theme)
+  Object.assign(this.baseTheme, theme)
 }
 
 ThemeSetProto.getTheme = function (name) {
-  if (!this.themes[name]) throw this.newMissingThemeError(name)
+  if (!this.themes[name]) {
+    throw this.newMissingThemeError(name)
+  }
   return this.themes[name]
 }
 
@@ -46,17 +47,23 @@ ThemeSetProto.setDefault = function (opts, name) {
   var platform = opts.platform == null ? 'fallback' : opts.platform
   var hasUnicode = !!opts.hasUnicode
   var hasColor = !!opts.hasColor
-  if (!this.defaults[platform]) this.defaults[platform] = {true: {}, false: {}}
+  if (!this.defaults[platform]) {
+    this.defaults[platform] = { true: {}, false: {} }
+  }
   this.defaults[platform][hasUnicode][hasColor] = name
 }
 
 ThemeSetProto.getDefault = function (opts) {
-  if (!opts) opts = {}
+  if (!opts) {
+    opts = {}
+  }
   var platformName = opts.platform || process.platform
   var platform = this.defaults[platformName] || this.defaults.fallback
   var hasUnicode = !!opts.hasUnicode
   var hasColor = !!opts.hasColor
-  if (!platform) throw this.newMissingDefaultThemeError(platformName, hasUnicode, hasColor)
+  if (!platform) {
+    throw this.newMissingDefaultThemeError(platformName, hasUnicode, hasColor)
+  }
   if (!platform[hasUnicode][hasColor]) {
     if (hasUnicode && hasColor && platform[!hasUnicode][hasColor]) {
       hasUnicode = false
@@ -76,7 +83,7 @@ ThemeSetProto.getDefault = function (opts) {
   if (platform[hasUnicode][hasColor]) {
     return this.getTheme(platform[hasUnicode][hasColor])
   } else {
-    return this.getDefault(objectAssign({}, opts, {platform: 'fallback'}))
+    return this.getDefault(Object.assign({}, opts, { platform: 'fallback' }))
   }
 }
 
@@ -88,28 +95,28 @@ ThemeSetProto.newMissingThemeError = function newMissingThemeError (name) {
   return err
 }
 
-ThemeSetProto.newMissingDefaultThemeError = function newMissingDefaultThemeError (platformName, hasUnicode, hasColor) {
-  var err = new Error(
-    'Could not find a gauge theme for your platform/unicode/color use combo:\n' +
+ThemeSetProto.newMissingDefaultThemeError =
+  function newMissingDefaultThemeError (platformName, hasUnicode, hasColor) {
+    var err = new Error(
+      'Could not find a gauge theme for your platform/unicode/color use combo:\n' +
     '    platform = ' + platformName + '\n' +
     '    hasUnicode = ' + hasUnicode + '\n' +
     '    hasColor = ' + hasColor)
-  Error.captureStackTrace.call(err, newMissingDefaultThemeError)
-  err.platform = platformName
-  err.hasUnicode = hasUnicode
-  err.hasColor = hasColor
-  err.code = 'EMISSINGTHEME'
-  return err
-}
+    Error.captureStackTrace.call(err, newMissingDefaultThemeError)
+    err.platform = platformName
+    err.hasUnicode = hasUnicode
+    err.hasColor = hasColor
+    err.code = 'EMISSINGTHEME'
+    return err
+  }
 
 ThemeSetProto.newThemeSet = function () {
   var themeset = function (opts) {
     return themeset.getDefault(opts)
   }
-  return objectAssign(themeset, ThemeSetProto, {
-    themes: objectAssign({}, this.themes),
-    baseTheme: objectAssign({}, this.baseTheme),
-    defaults: JSON.parse(JSON.stringify(this.defaults || {}))
+  return Object.assign(themeset, ThemeSetProto, {
+    themes: Object.assign({}, this.themes),
+    baseTheme: Object.assign({}, this.baseTheme),
+    defaults: JSON.parse(JSON.stringify(this.defaults || {})),
   })
 }
-