@socketsecurity/cli-with-sentry 0.14.137 → 0.14.139

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

@@ -0,0 +1,497 @@
+'use strict'
+const Node = require('../../../blessed/lib/widgets/node'),
+  Canvas = require('./canvas')
+
+function LCD(options) {
+  if (!(this instanceof Node)) {
+    return new LCD(options)
+  }
+  const self = this
+
+  options = options || {}
+  self.options = options
+
+  //these options need to be modified epending on the resulting positioning/size
+  self.options.segmentWidth = options.segmentWidth || 0.06 // how wide are the segments in % so 50% = 0.5
+  self.options.segmentInterval = options.segmentInterval || 0.11 // spacing between the segments in % so 50% = 0.5
+  self.options.strokeWidth = options.strokeWidth || 0.11 // spacing between the segments in % so 50% = 0.5
+
+  //default display settings
+  self.options.elements = options.elements || 3 // how many elements in the display. or how many characters can be displayed.
+  self.options.display = options.display || 321 // what should be displayed before anything is set
+  self.options.elementSpacing = options.spacing || 4 // spacing between each element
+  self.options.elementPadding = options.padding || 2 // how far away from the edges to put the elements
+
+  //coloring
+  self.options.color = options.color || 'white'
+
+  Canvas.call(this, options)
+
+  this.segment16 = null
+
+  this.on('attach', function () {
+    const display = self.options.display || 1234
+    if (!this.segment16) {
+      this.segment16 = new SixteenSegment(
+        this.options.elements,
+        this.ctx,
+        this.canvasSize.width,
+        this.canvasSize.height,
+        0,
+        0,
+        this.options
+      )
+    }
+
+    this.setDisplay(display)
+  })
+}
+
+LCD.prototype = Object.create(Canvas.prototype)
+
+LCD.prototype.calcSize = function () {
+  this.canvasSize = { width: this.width * 2 - 8, height: this.height * 4 - 12 }
+}
+
+LCD.prototype.type = 'lcd'
+LCD.prototype.increaseWidth = function () {
+  if (this.segment16) {
+    this.segment16.SegmentWidth += 0.01
+  }
+}
+LCD.prototype.decreaseWidth = function () {
+  if (this.segment16) {
+    this.segment16.SegmentWidth -= 0.01
+  }
+}
+LCD.prototype.increaseInterval = function () {
+  if (this.segment16) {
+    this.segment16.SegmentInterval += 0.01
+  }
+}
+LCD.prototype.decreaseInterval = function () {
+  if (this.segment16) {
+    this.segment16.SegmentInterval -= 0.01
+  }
+}
+LCD.prototype.increaseStroke = function () {
+  if (this.segment16) {
+    this.segment16.StrokeWidth += 0.05
+  }
+}
+LCD.prototype.decreaseStroke = function () {
+  if (this.segment16) {
+    this.segment16.StrokeWidth -= 0.05
+  }
+}
+LCD.prototype.setOptions = function (options) {
+  if (this.segment16) {
+    this.segment16.setOptions(options)
+  }
+}
+
+LCD.prototype.setData = function (data) {
+  this.setDisplay(data.toString())
+}
+
+LCD.prototype.getOptionsPrototype = function () {
+  return {
+    label: 'LCD Test',
+    segmentWidth: 0.06,
+    segmentInterval: 0.11,
+    strokeWidth: 0.1,
+    elements: 5,
+    display: 3210,
+    elementSpacing: 4,
+    elementPadding: 2
+  }
+}
+
+LCD.prototype.setDisplay = function (display) {
+  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()'
+  }
+
+  this.ctx.clearRect(0, 0, this.canvasSize.width, this.canvasSize.height)
+
+  this.segment16.DisplayText(display)
+}
+
+function ElementArray(count) {
+  this.SetCount = SetCount
+  this.SetText = SetText
+  this.SetElementValue = SetElementValue
+  this.NullMask = 0x10
+  this.Elements = []
+  this.SetCount(count || 0)
+
+  function SetCount(count) {
+    const c = parseInt(count, 10)
+    if (isNaN(c)) {
+      throw 'Invalid element count: ' + count
+    }
+    this.Elements = [c]
+    for (let i = 0; i < c; i++) {
+      this.Elements[i] = 0
+    }
+  }
+
+  function SetText(value, charMaps) {
+    // Get the string of the value passed in
+    if (value === null) {
+      value = ''
+    }
+    value = value.toString()
+
+    // Clear the elements
+    for (let i = 0; i < this.Elements.length; i++) {
+      this.SetElementValue(i, 0)
+    }
+    if (value.length === 0) {
+      return
+    }
+    // Set the bitmask to dispay the proper character for each element
+    for (let e = 0; e < this.Elements.length && e < value.length; e++) {
+      const c = value[e]
+      let mask = charMaps[c]
+      // Use blank of there is no bitmask for this character
+      if (mask === null || mask === undefined) {
+        mask = this.NullMask
+      }
+      this.SetElementValue(e, mask)
+    }
+  }
+  function SetElementValue(i, value) {
+    if (i >= 0 && i < this.Elements.length) {
+      this.Elements[i] = parseInt(value, 10)
+    }
+  }
+}
+
+//thx to https://github.com/Enderer/sixteensegment!!!
+//although it needed HEAVY rework since it was already somewhat busted ;-(
+function SixteenSegment(count, canvas, width, height, x, y, options) {
+  this.ElementArray = new ElementArray(count)
+
+  this.SegmentWidth = options.segmentWidth //(this.ElementWidth * 0.0015) * 5 //0.1;           // Width of segments (% of Element Width)
+  this.SegmentInterval = options.segmentInterval //(this.ElementWidth * 0.0015) * 10 // 0.20;        // Spacing between segments (% of Element Width)
+  this.BevelWidth = 0.01 // Size of corner bevel (% of Element Width)
+  this.SideBevelEnabled = true // Should the sides be beveled
+  this.StrokeLight = options.color // Color of an on segment outline
+
+  this.StrokeWidth = options.strokeWidth // Width of segment outline
+  this.Padding = options.elementPadding // Padding around the display
+  this.Spacing = options.elementSpacing // Spacing between elements
+
+  this.ElementWidth = (width - this.Spacing * count) / count
+  this.ElementHeight = height - this.Padding * 2
+
+  // console.error("w %s h %s", this.ElementWidth, this.ElementHeight);
+
+  this.FillLight = 'red' // Color of an on segment
+  this.FillDark = 'cyan' // Color of an off segment
+  this.StrokeDark = 'black' // Color of an off segment outline
+
+  this.X = 0
+  this.Y = 0
+
+  this.ElementCount = count
+
+  this.CalcElementDimensions = CalcElementDimensions
+  this.FlipVertical = FlipVertical
+  this.FlipHorizontal = FlipHorizontal
+  this.CalcPoints = CalcPoints
+  this.DisplayText = DisplayText
+  this.Draw = Draw
+  this.setOptions = setOptions
+
+  this.Width = width || canvas.width
+  this.Height = height || canvas.height
+
+  this.Canvas = canvas
+  this.CalcPoints()
+  this.ElementArray.SetCount(count)
+
+  function setOptions(options) {
+    if (options.elements) {
+      this.ElementArray.SetCount(options.elements)
+    }
+
+    this.SegmentWidth = options.segmentWidth || this.SegmentWidth
+    this.SegmentInterval = options.segmentInterval || this.SegmentInterval
+    this.BevelWidth = 0.01
+    this.SideBevelEnabled = true
+    this.StrokeLight = options.color || this.StrokeLight
+
+    this.StrokeWidth = options.strokeWidth || this.StrokeWidth
+    this.Padding = options.elementPadding || this.Padding
+    this.Spacing = options.elementSpacing || this.Spacing
+
+    this.ElementWidth = (width - this.Spacing * count) / count
+    this.ElementHeight = height - this.Padding * 2
+  }
+
+  function DisplayText(value) {
+    // Recalculate points in case any settings changed
+    // console.error("si: %s, sw: %s", this.SegmentInterval, this.SegmentWidth);
+    // console.error("st: %s", this.StrokeWidth);
+    // Set the display patterns and draw the canvas
+    this.ElementArray.SetText(value, CharacterMasks)
+    this.CalcPoints()
+    this.Draw(this.Canvas, this.ElementArray.Elements)
+  }
+
+  function CalcElementDimensions() {
+    const n = this.ElementCount
+    let h = this.ElementHeight
+    h -= this.Padding * 2
+
+    let w = this.Width
+    w -= this.Spacing * (n - 1)
+    w -= this.Padding * 2
+    w /= n
+    const output = { Width: w, Height: h }
+    // console.error(output);
+    return output
+  }
+
+  function FlipVertical(points, height) {
+    const flipped = []
+    for (let i = 0; i < points.length; i++) {
+      flipped[i] = {}
+      flipped[i].x = points[i].x
+      flipped[i].y = height - points[i].y
+    }
+    return flipped
+  }
+
+  function FlipHorizontal(points, width) {
+    const flipped = []
+    for (let i = 0; i < points.length; i++) {
+      flipped[i] = {}
+      flipped[i].x = width - points[i].x
+      flipped[i].y = points[i].y
+    }
+    return flipped
+  }
+
+  function Draw(context, elements) {
+    // Get the context and clear the area
+    context.clearRect(this.X, this.Y, this.Width, this.Height)
+    context.save()
+
+    // Calculate the width and spacing of each element
+    const elementWidth = this.CalcElementDimensions().Width
+    // console.error("width: %s", elementWidth);
+    // Offset to adjust for starting point and padding
+    context.translate(this.X, this.Y)
+    context.translate(this.Padding, this.Padding)
+
+    // Draw each segment of each element
+    for (let i = 0; i < elements.length; i++) {
+      const element = elements[i]
+      for (let s = 0; s < this.Points.length; s++) {
+        // Pick the on or off color based on the bitmask
+        const color = element & (1 << s) ? this.FillLight : this.FillDark
+        const stroke = element & (1 << s) ? this.StrokeLight : this.StrokeDark
+        if (stroke == this.StrokeDark) {
+          continue
+        }
+        // console.error("c: %s, s: %s", color, stroke);
+        context.lineWidth = this.StrokeWidth
+        context.strokeStyle = stroke
+        context.fillStyle = color
+        context.moveTo(0, 0)
+        context.beginPath()
+        context.moveTo(this.Points[s][0].x, this.Points[s][0].y)
+        // Create the segment path
+        let maxX = 0
+        for (let p = 1; p < this.Points[s].length; p++) {
+          if (this.Points[s][p].x > maxX) {
+            maxX = this.Points[s][p].x
+          }
+          context.lineTo(
+            Math.round(this.Points[s][p].x),
+            Math.round(this.Points[s][p].y)
+          )
+        }
+        context.closePath()
+        context.fill()
+        context.stroke()
+        if (this.StrokeWidth > 0) {
+          context.stroke()
+        }
+      }
+      context.translate(elementWidth + this.Spacing, 0)
+    }
+    context.restore()
+  }
+
+  function CalcPoints() {
+    const w = this.ElementWidth,
+      h = this.ElementHeight,
+      sw = this.SegmentWidth * w,
+      si = this.SegmentInterval * w,
+      bw = this.BevelWidth * sw,
+      ib = this.SideBevelEnabled ? 1 : 0,
+      sf = sw * 0.8,
+      slope = h / w,
+      sqrt2 = Math.SQRT2,
+      sqrt3 = Math.sqrt(3)
+
+    // Base position of points w/out bevel and interval
+    const w0 = w / 2 - sw / 2,
+      h0 = 0,
+      w1 = w / 2,
+      h1 = sw / 2,
+      w2 = w / 2 + sw / 2,
+      h2 = sw,
+      w3 = w - sw,
+      h3 = h / 2 - sw / 2,
+      w4 = w - sw / 2,
+      h4 = h / 2,
+      w5 = w,
+      h5 = h / 2 + sw / 2
+
+    // Order of segments stored in Points[][]
+    const A1 = 0,
+      A2 = 1,
+      B = 2,
+      C = 3,
+      D1 = 4,
+      D2 = 5,
+      E = 6,
+      F = 7,
+      G1 = 8,
+      G2 = 9,
+      H = 10,
+      I = 11,
+      J = 12,
+      K = 13,
+      L = 14,
+      M = 15
+
+    // Create the points array for all segments
+    const points = []
+    points[A1] = [
+      { x: bw * 2 + si / sqrt2, y: h0 },
+      { x: w1 - si / 2 - (sw / 2) * ib, y: h0 },
+      { x: w1 - si / 2, y: h1 },
+      { x: w0 - si / 2, y: h2 },
+      { x: sw + si / sqrt2, y: h2 },
+      { x: bw + si / sqrt2, y: h0 + bw }
+    ]
+    points[G2] = [
+      { x: w2 + si / sqrt2, y: h3 },
+      { x: w3 - (si / 2) * sqrt3, y: h3 },
+      { x: w4 - (si / 2) * sqrt3, y: h4 },
+      { x: w3 - (si / 2) * sqrt3, y: h5 },
+      { x: w2 + si / sqrt2, y: h5 },
+      { x: w1 + si / sqrt2, y: h4 }
+    ]
+    points[B] = [
+      { x: w5, y: h0 + bw * 2 + si / sqrt2 },
+      { x: w5, y: h4 - si / 2 - (sw / 2) * ib },
+      { x: w4, y: h4 - si / 2 },
+      { x: w3, y: h3 - si / 2 },
+      { x: w3, y: h2 + si / sqrt2 },
+      { x: w5 - bw, y: h0 + bw + si / sqrt2 }
+    ]
+    points[I] = [
+      { x: w2, y: h2 + (si / 2) * sqrt3 },
+      { x: w2, y: h3 - si / sqrt2 },
+      { x: w1, y: h4 - si / sqrt2 },
+      { x: w0, y: h3 - si / sqrt2 },
+      { x: w0, y: h2 + (si / 2) * sqrt3 },
+      { x: w1, y: h1 + (si / 2) * sqrt3 }
+    ]
+    points[H] = [
+      { x: (sw + sf) / slope + si, y: h2 + si },
+      { x: w0 - si, y: w0 * slope - sf - si },
+      { x: w0 - si, y: h3 - si },
+      { x: (h3 - sf) / slope - si, y: h3 - si },
+      { x: sw + si, y: h2 * slope + sf + si },
+      { x: sw + si, y: h2 + si }
+    ]
+    points[A2] = this.FlipHorizontal(points[A1], w) // A2
+    points[C] = this.FlipVertical(points[2], h) // C
+    points[D1] = this.FlipVertical(points[0], h) // D1
+    points[D2] = this.FlipHorizontal(points[4], w) // D2
+    points[E] = this.FlipHorizontal(points[3], w) // E
+    points[F] = this.FlipHorizontal(points[2], w) // F
+    points[G1] = this.FlipHorizontal(points[9], w) // G1
+    points[J] = this.FlipHorizontal(points[10], w) // J
+    points[K] = this.FlipVertical(points[12], h) // K
+    points[L] = this.FlipVertical(points[11], h) // L
+    points[M] = this.FlipVertical(points[10], h) // M
+    this.Points = points
+  }
+}
+const CharacterMasks = (function () {
+  // Segment Bitmasks for individual segments.
+  // Binary Or them together to create bitmasks
+  // a1|a2|b|c|d1|d2|e|f|g1|g2|h|i|j|k|l|m
+  const a1 = 1 << 0,
+    a2 = 1 << 1,
+    b = 1 << 2,
+    c = 1 << 3,
+    d1 = 1 << 4,
+    d2 = 1 << 5,
+    e = 1 << 6,
+    f = 1 << 7,
+    g1 = 1 << 8,
+    g2 = 1 << 9,
+    h = 1 << 10,
+    i = 1 << 11,
+    j = 1 << 12,
+    k = 1 << 13,
+    l = 1 << 14,
+    m = 1 << 15
+  // Character map associates characters with a bit pattern
+  return {
+    ' ': 0,
+    '': 0,
+    0: a1 | a2 | b | c | d1 | d2 | e | f | j | m,
+    1: b | c | j,
+    2: a1 | a2 | b | d1 | d2 | e | g1 | g2,
+    3: a1 | a2 | b | c | d1 | d2 | g2,
+    4: b | c | f | g1 | g2,
+    5: a1 | a2 | c | d1 | d2 | f | g1 | g2,
+    6: a1 | a2 | c | d1 | d2 | e | f | g1 | g2,
+    7: a1 | a2 | b | c,
+    8: a1 | a2 | b | c | d1 | d2 | e | f | g1 | g2,
+    9: a1 | a2 | b | c | f | g1 | g2,
+    A: e | f | a1 | a2 | b | c | g1 | g2,
+    B: a1 | a2 | b | c | d1 | d2 | g2 | i | l,
+    C: a1 | a2 | f | e | d1 | d2,
+    D: a1 | a2 | b | c | d1 | d2 | i | l,
+    E: a1 | a2 | f | e | d1 | d2 | g1 | g2,
+    F: a1 | a2 | e | f | g1,
+    G: a1 | a2 | c | d1 | d2 | e | f | g2,
+    H: b | c | e | f | g1 | g2,
+    I: a1 | a2 | d1 | d2 | i | l,
+    J: b | c | d1 | d2 | e,
+    K: e | f | g1 | j | k,
+    L: d1 | d2 | e | f,
+    M: b | c | e | f | h | j,
+    N: b | c | e | f | h | k,
+    O: a1 | a2 | b | c | d1 | d2 | e | f,
+    P: a1 | a2 | b | e | f | g1 | g2,
+    Q: a1 | a2 | b | c | d1 | d2 | e | f | k,
+    R: a1 | a2 | b | e | f | g1 | g2 | k,
+    S: a1 | a2 | c | d1 | d2 | f | g1 | g2,
+    T: a1 | a2 | i | l,
+    U: b | c | d1 | d2 | e | f,
+    V: e | f | j | m,
+    W: b | c | e | f | k | m,
+    X: h | j | k | m,
+    Y: b | f | g1 | g2 | l,
+    Z: a1 | a2 | d1 | d2 | j | m,
+    '-': g1 | g2,
+    '?': a1 | a2 | b | g2 | l,
+    '+': g1 | g2 | i | l,
+    '*': g1 | g2 | h | i | j | k | l | m
+  }
+})()
+
+module.exports = LCD

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

@@ -0,0 +1,32 @@
+'use strict'
+const List = require('../../../blessed/lib/widgets/list'),
+  Node = require('../../../blessed/lib/widgets/node')
+
+function Log(options) {
+  if (!(this instanceof Node)) {
+    return new Log(options)
+  }
+
+  options = options || {}
+  options.bufferLength = options.bufferLength || 30
+  this.options = options
+  List.call(this, options)
+
+  this.logLines = []
+  this.interactive = false
+}
+
+Log.prototype = Object.create(List.prototype)
+
+Log.prototype.log = function (str) {
+  this.logLines.push(str)
+  if (this.logLines.length > this.options.bufferLength) {
+    this.logLines.shift()
+  }
+  this.setItems(this.logLines)
+  this.scrollTo(this.logLines.length)
+}
+
+Log.prototype.type = 'log'
+
+module.exports = Log

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

@@ -0,0 +1,97 @@
+'use strict'
+const InnerMap = require('map-canvas'),
+  Node = require('../../../blessed/lib/widgets/node'),
+  Canvas = require('./canvas')
+
+function Map(options) {
+  const self = this
+
+  if (!(this instanceof Node)) {
+    return new Map(options)
+  }
+
+  Canvas.call(this, options)
+
+  this.on('attach', function () {
+    options.style = options.style || {}
+
+    const opts = {
+      excludeAntartica:
+        options.excludeAntarctica === undefined
+          ? true
+          : options.excludeAntarctica,
+      disableBackground:
+        options.disableBackground === undefined
+          ? true
+          : options.disableBackground,
+      disableMapBackground:
+        options.disableMapBackground === undefined
+          ? true
+          : options.disableMapBackground,
+      disableGraticule:
+        options.disableGraticule === undefined
+          ? true
+          : options.disableGraticule,
+      disableFill:
+        options.disableFill === undefined ? true : options.disableFill,
+      width: self.ctx._canvas.width,
+      height: self.ctx._canvas.height,
+      shapeColor: options.style.shapeColor || 'green'
+    }
+
+    opts.startLon = options.startLon || undefined
+    opts.endLon = options.endLon || undefined
+    opts.startLat = options.startLat || undefined
+    opts.endLat = options.endLat || undefined
+    opts.region = options.region || undefined
+    opts.labelSpace = options.labelSpace || 5
+
+    this.ctx.strokeStyle = options.style.stroke || 'green'
+    this.ctx.fillStyle = options.style.fill || 'green'
+
+    self.innerMap = new InnerMap(opts, this._canvas)
+    self.innerMap.draw()
+
+    if (self.options.markers) {
+      for (const m in self.options.markers) {
+        self.addMarker(self.options.markers[m])
+      }
+    }
+  })
+}
+
+Map.prototype = Object.create(Canvas.prototype)
+
+Map.prototype.calcSize = function () {
+  this.canvasSize = { width: this.width * 2 - 12, height: this.height * 4 }
+}
+
+Map.prototype.type = 'map'
+
+Map.prototype.addMarker = function (options) {
+  if (!this.innerMap) {
+    throw 'error: canvas context does not exist. addMarker() for maps must be called after the map has been added to the screen via screen.append()'
+  }
+
+  this.innerMap.addMarker(options)
+}
+
+Map.prototype.getOptionsPrototype = function () {
+  return {
+    startLon: 10,
+    endLon: 10,
+    startLat: 10,
+    endLat: 10,
+    region: 'us',
+    markers: [
+      { lon: '-79.0000', lat: '37.5000', color: 'red', char: 'X' },
+      { lon: '79.0000', lat: '37.5000', color: 'blue', char: 'O' }
+    ]
+  }
+}
+
+Map.prototype.clearMarkers = function () {
+  this.innerMap.draw()
+}
+
+module.exports = Map

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

@@ -0,0 +1,68 @@
+'use strict'
+const Box = require('../../../blessed/lib/widgets/box'),
+  marked = require('marked'),
+  TerminalRenderer = require('marked-terminal'),
+  chalk = require('chalk')
+
+function Markdown(options) {
+  if (!(this instanceof Box)) {
+    return new Markdown(options)
+  }
+
+  options = options || {}
+
+  const markdownOptions = {
+    style: options.markdownStyle
+  }
+
+  this.evalStyles(markdownOptions)
+
+  this.setOptions(markdownOptions.style)
+
+  this.options = options
+  Box.call(this, options)
+
+  if (options.markdown) {
+    this.setMarkdown(options.markdown)
+  }
+}
+
+Markdown.prototype = Object.create(Box.prototype)
+
+Markdown.prototype.setMarkdown = function (str) {
+  this.setContent(marked.parse(str))
+}
+
+Markdown.prototype.setOptions = function (style) {
+  marked.setOptions({
+    renderer: new TerminalRenderer(style)
+  })
+}
+
+Markdown.prototype.evalStyles = function (options) {
+  if (!options.style) {
+    return
+  }
+  for (const st in options.style) {
+    if (typeof options.style[st] != 'string') {
+      continue
+    }
+
+    const tokens = options.style[st].split('.')
+    options.style[st] = chalk
+    for (let j = 1; j < tokens.length; j++) {
+      options.style[st] = options.style[st][tokens[j]]
+    }
+  }
+}
+
+Markdown.prototype.getOptionsPrototype = function () {
+  return {
+    markdown: 'string',
+    markdownStyle: 'object'
+  }
+}
+
+Markdown.prototype.type = 'markdown'
+
+module.exports = Markdown