@socketsecurity/cli-with-sentry 0.14.137 → 0.14.139

package/dist/blessed-contrib/lib/widget/donut.js

@@ -0,0 +1,183 @@
+'use strict'
+const Node = require('../../../blessed/lib/widgets/node'),
+  Canvas = require('./canvas')
+
+function Donut(options) {
+  if (!(this instanceof Node)) {
+    return new Donut(options)
+  }
+
+  options = options || {}
+  this.options = options
+  this.options.stroke = options.stroke || 'magenta'
+  this.options.fill = options.fill || 'white'
+  this.options.radius = options.radius || 14
+  this.options.arcWidth = options.arcWidth || 4
+  this.options.spacing = options.spacing || 2
+  this.options.yPadding = options.yPadding || 2
+  this.options.remainColor = options.remainColor || 'black'
+  this.options.data = options.data || []
+
+  Canvas.call(this, options)
+
+  const self = this
+  this.on('attach', function () {
+    this.setData(self.options.data)
+  })
+}
+
+Donut.prototype = Object.create(Canvas.prototype)
+
+Donut.prototype.calcSize = function () {
+  this.canvasSize = {
+    width: Math.round(this.width * 2 - 5),
+    height: this.height * 4 - 12
+  }
+  if (this.canvasSize.width % 2 == 1) {
+    this.canvasSize.width--
+  }
+  if (this.canvasSize.height % 4 != 1) {
+    this.canvasSize.height += this.canvasSize.height % 4
+  }
+}
+
+Donut.prototype.type = 'donut'
+
+const cos = Math.cos
+const sin = Math.sin
+const pi = 3.141592635
+Donut.prototype.setData = function (data) {
+  this.update(data)
+}
+Donut.prototype.update = function (data) {
+  if (!this.ctx) {
+    throw 'error: canvas context does not exist. setData() for line charts must be called after the chart has been added to the screen via screen.append()'
+  }
+
+  const c = this.ctx
+  c.save()
+  c.translate(0, -this.options.yPadding)
+
+  c.strokeStyle = this.options.stroke
+  c.fillStyle = this.options.fill
+
+  c.clearRect(0, 0, this.canvasSize.width, this.canvasSize.height)
+
+  const cheight = this.canvasSize.height
+  const cwidth = this.canvasSize.width
+
+  function makeRound(percent, radius, width, cx, cy, color) {
+    let s = 0
+    const points = 370
+    c.strokeStyle = color || 'green'
+    while (s < radius) {
+      if (s < radius - width) {
+        s++
+        continue
+      }
+      const slice = (2 * pi) / points
+      c.beginPath()
+      const p = parseFloat(percent * 360)
+      for (let i = 0; i <= points; i++) {
+        if (i > p) {
+          continue
+        }
+        const si = i - 90
+        const a = slice * si
+        c.lineTo(Math.round(cx + s * cos(a)), Math.round(cy + s * sin(a)))
+      }
+      c.stroke()
+      c.closePath()
+      s++
+    }
+  }
+
+  const donuts = data.length
+  const radius = this.options.radius
+  const width = this.options.arcWidth
+  const remainColor = this.options.remainColor
+
+  const middle = cheight / 2
+  const spacing = (cwidth - donuts * radius * 2) / (donuts + 1)
+
+  function drawDonut(
+    label,
+    percent,
+    radius,
+    width,
+    cxx,
+    middle,
+    color,
+    percentAltNumber
+  ) {
+    makeRound(100, radius, width, cxx, middle, remainColor)
+    makeRound(percent, radius, width, cxx, middle, color)
+    const ptext = percentAltNumber
+      ? percentAltNumber.toFixed(0)
+      : parseFloat(percent * 100).toFixed(0) + '%'
+    c.fillText(
+      ptext,
+      cxx - Math.round(parseFloat(c.measureText(ptext).width / 2)) + 3,
+      middle
+    )
+    c.fillText(
+      label,
+      cxx - Math.round(parseFloat(c.measureText(label).width / 2)) + 3,
+      middle + radius + 5
+    )
+  }
+
+  function makeDonut(stat, which) {
+    const left = radius + spacing * which + radius * 2 * (which - 1)
+    let percent = stat.percent
+    if (percent > 1.001) {
+      percent = parseFloat(percent / 100).toFixed(2)
+    }
+    const label = stat.label
+    const percentAltNumber = stat.percentAltNumber
+    const color = stat.color || 'green'
+    const cxx = left
+    drawDonut(
+      label,
+      percent,
+      radius,
+      width,
+      cxx,
+      middle,
+      color,
+      percentAltNumber
+    )
+  }
+  function makeDonuts(stats) {
+    for (let l = 0; l <= stats.length - 1; l++) {
+      makeDonut(stats[l], l + 1)
+    }
+  }
+
+  if (data.length) {
+    makeDonuts(data)
+  }
+
+  this.currentData = data
+
+  c.strokeStyle = 'magenta'
+
+  c.restore()
+  return
+}
+
+Donut.prototype.getOptionsPrototype = function () {
+  return {
+    spacing: 1,
+    yPadding: 1,
+    radius: 1,
+    arcWidth: 1,
+    data: [
+      { color: 'red', percent: '50', label: 'a' },
+      { color: 'blue', percent: '20', label: 'b' },
+      { color: 'yellow', percent: '80', label: 'c' }
+    ]
+  }
+}
+
+module.exports = Donut

package/dist/blessed-contrib/lib/widget/gauge-list.js

@@ -0,0 +1,111 @@
+'use strict'
+const Node = require('../../../blessed/lib/widgets/node'),
+  Canvas = require('./canvas')
+
+function GaugeList(options) {
+  if (!(this instanceof Node)) {
+    return new GaugeList(options)
+  }
+
+  const self = this
+
+  options = options || {}
+  self.options = options
+  self.options.stroke = options.stroke || 'magenta'
+  self.options.fill = options.fill || 'white'
+  self.options.data = options.data || []
+  self.options.showLabel = options.showLabel !== false
+  self.options.gaugeSpacing = options.gaugeSpacing || 0
+  self.options.gaugeHeight = options.gaugeHeight || 1
+
+  Canvas.call(this, options, require('ansi-term'))
+
+  this.on('attach', function () {
+    const gauges = (this.gauges = self.options.gauges)
+    this.setGauges(gauges)
+  })
+}
+
+GaugeList.prototype = Object.create(Canvas.prototype)
+
+GaugeList.prototype.calcSize = function () {
+  this.canvasSize = { width: this.width - 2, height: this.height }
+}
+
+GaugeList.prototype.type = 'gauge'
+
+GaugeList.prototype.setData = function () {}
+
+GaugeList.prototype.setGauges = function (gauges) {
+  if (!this.ctx) {
+    throw 'error: canvas context does not exist. setData() for gauges must be called after the gauge has been added to the screen via screen.append()'
+  }
+
+  const c = this.ctx
+  c.clearRect(0, 0, this.canvasSize.width, this.canvasSize.height)
+
+  for (let i = 0; i < gauges.length; i++) {
+    this.setSingleGauge(gauges[i], i)
+  }
+}
+
+GaugeList.prototype.setSingleGauge = function (gauge, offset) {
+  const colors = ['green', 'magenta', 'cyan', 'red', 'blue']
+  const stack = gauge.stack
+
+  const c = this.ctx
+  let leftStart = 3
+  let textLeft = 5
+
+  c.strokeStyle = 'normal'
+  c.fillStyle = 'white'
+  c.fillText(
+    offset.toString(),
+    0,
+    offset * (this.options.gaugeHeight + this.options.gaugeSpacing)
+  )
+
+  for (let i = 0; i < stack.length; i++) {
+    const currentStack = stack[i]
+
+    let percent
+    if (typeof currentStack == typeof {}) {
+      percent = currentStack.percent
+    } else {
+      percent = currentStack
+    }
+
+    c.strokeStyle = currentStack.stroke || colors[i % colors.length] // use specified or choose from the array of colors
+    c.fillStyle = this.options.fill //'white'
+
+    textLeft = 5
+
+    const width = (percent / 100) * (this.canvasSize.width - 5)
+
+    c.fillRect(
+      leftStart,
+      offset * (this.options.gaugeHeight + this.options.gaugeSpacing),
+      width,
+      this.options.gaugeHeight - 1
+    )
+
+    textLeft = width / 2 - 1
+    // if (textLeft)
+    const textX = leftStart + textLeft
+
+    if (leftStart + width < textX) {
+      c.strokeStyle = 'normal'
+    }
+    if (gauge.showLabel) {
+      c.fillText(percent + '%', textX, 3)
+    }
+
+    leftStart += width
+  }
+}
+
+GaugeList.prototype.getOptionsPrototype = function () {
+  return { percent: 10 }
+}
+
+module.exports = GaugeList

package/dist/blessed-contrib/lib/widget/gauge.js

@@ -0,0 +1,127 @@
+'use strict'
+const Node = require('../../../blessed/lib/widgets/node'),
+  Canvas = require('./canvas')
+
+function Gauge(options) {
+  if (!(this instanceof Node)) {
+    return new Gauge(options)
+  }
+
+  const self = this
+
+  options = options || {}
+  self.options = options
+  self.options.stroke = options.stroke || 'magenta'
+  self.options.fill = options.fill || 'white'
+  self.options.data = options.data || []
+  self.options.showLabel = options.showLabel !== false
+
+  Canvas.call(this, options, require('ansi-term'))
+
+  this.on('attach', function () {
+    if (self.options.stack) {
+      const stack = (this.stack = self.options.stack)
+      this.setStack(stack)
+    } else {
+      const percent = (this.percent = self.options.percent || 0)
+      this.setData(percent)
+    }
+  })
+}
+
+Gauge.prototype = Object.create(Canvas.prototype)
+
+Gauge.prototype.calcSize = function () {
+  this.canvasSize = { width: this.width - 2, height: this.height }
+}
+
+Gauge.prototype.type = 'gauge'
+
+Gauge.prototype.setData = function (data) {
+  if (typeof data == typeof [] && data.length > 0) {
+    this.setStack(data)
+  } else if (typeof data == typeof 1) {
+    this.setPercent(data)
+  }
+}
+
+Gauge.prototype.setPercent = function (percent) {
+  if (!this.ctx) {
+    throw 'error: canvas context does not exist. setData() for gauges must be called after the gauge has been added to the screen via screen.append()'
+  }
+
+  const c = this.ctx
+
+  c.strokeStyle = this.options.stroke //'magenta'
+  c.fillStyle = this.options.fill //'white'
+
+  c.clearRect(0, 0, this.canvasSize.width, this.canvasSize.height)
+  if (percent < 1.001) {
+    percent = percent * 100
+  }
+  const width = (percent / 100) * (this.canvasSize.width - 3)
+  c.fillRect(1, 2, width, 2)
+
+  const textX = 7
+  if (width < textX) {
+    c.strokeStyle = 'normal'
+  }
+
+  if (this.options.showLabel) {
+    c.fillText(Math.round(percent) + '%', textX, 3)
+  }
+}
+
+Gauge.prototype.setStack = function (stack) {
+  const colors = ['green', 'magenta', 'cyan', 'red', 'blue']
+
+  if (!this.ctx) {
+    throw 'error: canvas context does not exist. setData() for gauges must be called after the gauge has been added to the screen via screen.append()'
+  }
+
+  const c = this.ctx
+  let leftStart = 1
+  let textLeft = 5
+  c.clearRect(0, 0, this.canvasSize.width, this.canvasSize.height)
+
+  for (let i = 0; i < stack.length; i++) {
+    const currentStack = stack[i]
+
+    let percent
+    if (typeof currentStack == typeof {}) {
+      percent = currentStack.percent
+    } else {
+      percent = currentStack
+    }
+
+    c.strokeStyle = currentStack.stroke || colors[i % colors.length] // use specified or choose from the array of colors
+    c.fillStyle = this.options.fill //'white'
+
+    textLeft = 5
+    if (percent < 1.001) {
+      percent = percent * 100
+    }
+    const width = (percent / 100) * (this.canvasSize.width - 3)
+
+    c.fillRect(leftStart, 2, width, 2)
+
+    textLeft = width / 2 - 1
+    // if (textLeft)
+    const textX = leftStart + textLeft
+
+    if (leftStart + width < textX) {
+      c.strokeStyle = 'normal'
+    }
+    if (this.options.showLabel) {
+      c.fillText(percent + '%', textX, 3)
+    }
+
+    leftStart += width
+  }
+}
+
+Gauge.prototype.getOptionsPrototype = function () {
+  return { percent: 10 }
+}
+
+module.exports = Gauge