@socketsecurity/cli-with-sentry 0.14.67 → 0.14.68

package/dist/blessed/lib/widgets/loading.js

@@ -0,0 +1,90 @@
+'use strict'
+
+/**
+ * loading.js - loading element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const Node = require('./node')
+const Box = require('./box')
+const Text = require('./text')
+
+/**
+ * Loading
+ */
+
+function Loading(options) {
+  if (!(this instanceof Node)) {
+    return new Loading(options)
+  }
+
+  options = options || {}
+
+  Box.call(this, options)
+
+  this._.icon = new Text({
+    parent: this,
+    align: 'center',
+    top: 2,
+    left: 1,
+    right: 1,
+    height: 1,
+    content: '|'
+  })
+}
+
+Object.setPrototypeOf(Loading.prototype, Box.prototype)
+
+Loading.prototype.type = 'loading'
+
+Loading.prototype.load = function (text) {
+  const self = this
+
+  // XXX Keep above:
+  // var parent = this.parent;
+  // this.detach();
+  // parent.append(this);
+
+  this.show()
+  this.setContent(text)
+
+  if (this._.timer) {
+    this.stop()
+  }
+
+  this.screen.lockKeys = true
+
+  this._.timer = setInterval(function () {
+    if (self._.icon.content === '|') {
+      self._.icon.setContent('/')
+    } else if (self._.icon.content === '/') {
+      self._.icon.setContent('-')
+    } else if (self._.icon.content === '-') {
+      self._.icon.setContent('\\')
+    } else if (self._.icon.content === '\\') {
+      self._.icon.setContent('|')
+    }
+    self.screen.render()
+  }, 200)
+}
+
+Loading.prototype.stop = function () {
+  this.screen.lockKeys = false
+  this.hide()
+  if (this._.timer) {
+    clearInterval(this._.timer)
+    delete this._.timer
+  }
+  this.screen.render()
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Loading

package/dist/blessed/lib/widgets/log.js

@@ -0,0 +1,84 @@
+'use strict'
+
+/**
+ * log.js - log element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const util = require('node:util')
+
+const nextTick = global.setImmediate || process.nextTick.bind(process)
+
+const Node = require('./node')
+const ScrollableText = require('./scrollabletext')
+
+/**
+ * Log
+ */
+
+function Log(options) {
+  const self = this
+
+  if (!(this instanceof Node)) {
+    return new Log(options)
+  }
+
+  options = options || {}
+
+  ScrollableText.call(this, options)
+
+  this.scrollback = options.scrollback != null ? options.scrollback : Infinity
+  this.scrollOnInput = options.scrollOnInput
+
+  this.on('set content', function () {
+    if (!self._userScrolled || self.scrollOnInput) {
+      nextTick(function () {
+        self.setScrollPerc(100)
+        self._userScrolled = false
+        self.screen.render()
+      })
+    }
+  })
+}
+
+Object.setPrototypeOf(Log.prototype, ScrollableText.prototype)
+
+Log.prototype.type = 'log'
+
+Log.prototype.log = Log.prototype.add = function () {
+  const args = Array.prototype.slice.call(arguments)
+  if (typeof args[0] === 'object') {
+    args[0] = util.inspect(args[0], true, 20, true)
+  }
+  const text = util.format.apply(util, args)
+  this.emit('log', text)
+  const ret = this.pushLine(text)
+  if (this._clines.fake.length > this.scrollback) {
+    this.shiftLine(0, (this.scrollback / 3) | 0)
+  }
+  return ret
+}
+
+Log.prototype._scroll = Log.prototype.scroll
+Log.prototype.scroll = function (offset, always) {
+  if (offset === 0) {
+    return this._scroll(offset, always)
+  }
+  this._userScrolled = true
+  const ret = this._scroll(offset, always)
+  if (this.getScrollPerc() === 100) {
+    this._userScrolled = false
+  }
+  return ret
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Log

package/dist/blessed/lib/widgets/message.js

@@ -0,0 +1,147 @@
+'use strict'
+
+/**
+ * message.js - message element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const Node = require('./node')
+const Box = require('./box')
+
+/**
+ * Message / Error
+ */
+
+function Message(options) {
+  if (!(this instanceof Node)) {
+    return new Message(options)
+  }
+
+  options = options || {}
+  options.tags = true
+
+  Box.call(this, options)
+}
+
+Object.setPrototypeOf(Message.prototype, Box.prototype)
+
+Message.prototype.type = 'message'
+
+Message.prototype.log = Message.prototype.display = function (
+  text,
+  time,
+  callback
+) {
+  const self = this
+
+  if (typeof time === 'function') {
+    callback = time
+    time = null
+  }
+
+  if (time == null) {
+    time = 3
+  }
+
+  // Keep above:
+  // var parent = this.parent;
+  // this.detach();
+  // parent.append(this);
+
+  if (this.scrollable) {
+    this.screen.saveFocus()
+    this.focus()
+    this.scrollTo(0)
+  }
+
+  this.show()
+  this.setContent(text)
+  this.screen.render()
+
+  if (time === Infinity || time === -1 || time === 0) {
+    const end = function () {
+      if (end.done) {
+        return
+      }
+      end.done = true
+      if (self.scrollable) {
+        try {
+          self.screen.restoreFocus()
+        } catch (e) {}
+      }
+      self.hide()
+      self.screen.render()
+      if (callback) {
+        callback()
+      }
+    }
+
+    setTimeout(function () {
+      self.onScreenEvent('keypress', function fn(ch, key) {
+        if (key.name === 'mouse') {
+          return
+        }
+        if (self.scrollable) {
+          if (
+            key.name === 'up' ||
+            (self.options.vi && key.name === 'k') ||
+            key.name === 'down' ||
+            (self.options.vi && key.name === 'j') ||
+            (self.options.vi && key.name === 'u' && key.ctrl) ||
+            (self.options.vi && key.name === 'd' && key.ctrl) ||
+            (self.options.vi && key.name === 'b' && key.ctrl) ||
+            (self.options.vi && key.name === 'f' && key.ctrl) ||
+            (self.options.vi && key.name === 'g' && !key.shift) ||
+            (self.options.vi && key.name === 'g' && key.shift)
+          ) {
+            return
+          }
+        }
+        if (
+          self.options.ignoreKeys &&
+          ~self.options.ignoreKeys.indexOf(key.name)
+        ) {
+          return
+        }
+        self.removeScreenEvent('keypress', fn)
+        end()
+      })
+      // XXX May be affected by new element.options.mouse option.
+      if (!self.options.mouse) {
+        return
+      }
+      self.onScreenEvent('mouse', function fn(data) {
+        if (data.action === 'mousemove') {
+          return
+        }
+        self.removeScreenEvent('mouse', fn)
+        end()
+      })
+    }, 10)
+
+    return
+  }
+
+  setTimeout(function () {
+    self.hide()
+    self.screen.render()
+    if (callback) {
+      callback()
+    }
+  }, time * 1000)
+}
+
+Message.prototype.error = function (text, time, callback) {
+  return this.display('{red-fg}Error: ' + text + '{/red-fg}', time, callback)
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Message

package/dist/blessed/lib/widgets/node.js

@@ -0,0 +1,316 @@
+'use strict'
+
+/**
+ * node.js - base abstract node for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const EventEmitter = require('../events').EventEmitter
+
+/**
+ * Node
+ */
+
+function Node(options) {
+  const self = this
+  const Screen = require('./screen')
+
+  if (!(this instanceof Node)) {
+    return new Node(options)
+  }
+
+  EventEmitter.call(this)
+
+  options = options || {}
+  this.options = options
+
+  this.screen = this.screen || options.screen
+
+  if (!this.screen) {
+    if (this.type === 'screen') {
+      this.screen = this
+    } else if (Screen.total === 1) {
+      this.screen = Screen.global
+    } else if (options.parent) {
+      this.screen = options.parent
+      while (this.screen && this.screen.type !== 'screen') {
+        this.screen = this.screen.parent
+      }
+    } else if (Screen.total) {
+      // This _should_ work in most cases as long as the element is appended
+      // synchronously after the screen's creation. Throw error if not.
+      this.screen = Screen.instances[Screen.instances.length - 1]
+      process.nextTick(function () {
+        if (!self.parent) {
+          throw new Error(
+            'Element (' +
+              self.type +
+              ')' +
+              ' was not appended synchronously after the' +
+              " screen's creation. Please set a `parent`" +
+              " or `screen` option in the element's constructor" +
+              ' if you are going to use multiple screens and' +
+              ' append the element later.'
+          )
+        }
+      })
+    } else {
+      throw new Error('No active screen.')
+    }
+  }
+
+  this.parent = options.parent || null
+  this.children = []
+  this.$ = this._ = this.data = {}
+  this.uid = Node.uid++
+  this.index = this.index != null ? this.index : -1
+
+  if (this.type !== 'screen') {
+    this.detached = true
+  }
+
+  if (this.parent) {
+    this.parent.append(this)
+  }
+
+  ;(options.children || []).forEach(this.append.bind(this))
+}
+
+Node.uid = 0
+
+Object.setPrototypeOf(Node.prototype, EventEmitter.prototype)
+
+Node.prototype.type = 'node'
+
+Node.prototype.insert = function (element, i) {
+  const self = this
+
+  if (element.screen && element.screen !== this.screen) {
+    throw new Error("Cannot switch a node's screen.")
+  }
+
+  element.detach()
+  element.parent = this
+  element.screen = this.screen
+
+  if (i === 0) {
+    this.children.unshift(element)
+  } else if (i === this.children.length) {
+    this.children.push(element)
+  } else {
+    this.children.splice(i, 0, element)
+  }
+
+  element.emit('reparent', this)
+  this.emit('adopt', element)
+
+  ;(function emit(el) {
+    const n = el.detached !== self.detached
+    el.detached = self.detached
+    if (n) {
+      el.emit('attach')
+    }
+    el.children.forEach(emit)
+  })(element)
+
+  if (!this.screen.focused) {
+    this.screen.focused = element
+  }
+}
+
+Node.prototype.prepend = function (element) {
+  this.insert(element, 0)
+}
+
+Node.prototype.append = function (element) {
+  this.insert(element, this.children.length)
+}
+
+Node.prototype.insertBefore = function (element, other) {
+  const i = this.children.indexOf(other)
+  if (~i) {
+    this.insert(element, i)
+  }
+}
+
+Node.prototype.insertAfter = function (element, other) {
+  const i = this.children.indexOf(other)
+  if (~i) {
+    this.insert(element, i + 1)
+  }
+}
+
+Node.prototype.remove = function (element) {
+  if (element.parent !== this) {
+    return
+  }
+
+  let i = this.children.indexOf(element)
+  if (!~i) {
+    return
+  }
+
+  element.clearPos()
+
+  element.parent = null
+
+  this.children.splice(i, 1)
+
+  i = this.screen.clickable.indexOf(element)
+  if (~i) {
+    this.screen.clickable.splice(i, 1)
+  }
+  i = this.screen.keyable.indexOf(element)
+  if (~i) {
+    this.screen.keyable.splice(i, 1)
+  }
+
+  element.emit('reparent', null)
+  this.emit('remove', element)
+
+  ;(function emit(el) {
+    const n = el.detached !== true
+    el.detached = true
+    if (n) {
+      el.emit('detach')
+    }
+    el.children.forEach(emit)
+  })(element)
+
+  if (this.screen.focused === element) {
+    this.screen.rewindFocus()
+  }
+}
+
+Node.prototype.detach = function () {
+  if (this.parent) {
+    this.parent.remove(this)
+  }
+}
+
+Node.prototype.free = function () {
+  return
+}
+
+Node.prototype.destroy = function () {
+  this.detach()
+  this.forDescendants(function (el) {
+    el.free()
+    el.destroyed = true
+    el.emit('destroy')
+  }, this)
+}
+
+Node.prototype.forDescendants = function (iter, s) {
+  if (s) {
+    iter(this)
+  }
+  this.children.forEach(function emit(el) {
+    iter(el)
+    el.children.forEach(emit)
+  })
+}
+
+Node.prototype.forAncestors = function (iter, s) {
+  let el = this
+  if (s) {
+    iter(this)
+  }
+  while ((el = el.parent)) {
+    iter(el)
+  }
+}
+
+Node.prototype.collectDescendants = function (s) {
+  const out = []
+  this.forDescendants(function (el) {
+    out.push(el)
+  }, s)
+  return out
+}
+
+Node.prototype.collectAncestors = function (s) {
+  const out = []
+  this.forAncestors(function (el) {
+    out.push(el)
+  }, s)
+  return out
+}
+
+Node.prototype.emitDescendants = function () {
+  let args = Array.prototype.slice(arguments),
+    iter
+
+  if (typeof args[args.length - 1] === 'function') {
+    iter = args.pop()
+  }
+
+  return this.forDescendants(function (el) {
+    if (iter) {
+      iter(el)
+    }
+    el.emit.apply(el, args)
+  }, true)
+}
+
+Node.prototype.emitAncestors = function () {
+  let args = Array.prototype.slice(arguments),
+    iter
+
+  if (typeof args[args.length - 1] === 'function') {
+    iter = args.pop()
+  }
+
+  return this.forAncestors(function (el) {
+    if (iter) {
+      iter(el)
+    }
+    el.emit.apply(el, args)
+  }, true)
+}
+
+Node.prototype.hasDescendant = function (target) {
+  return (function find(el) {
+    for (let i = 0; i < el.children.length; i++) {
+      if (el.children[i] === target) {
+        return true
+      }
+      if (find(el.children[i]) === true) {
+        return true
+      }
+    }
+    return false
+  })(this)
+}
+
+Node.prototype.hasAncestor = function (target) {
+  let el = this
+  while ((el = el.parent)) {
+    if (el === target) {
+      return true
+    }
+  }
+  return false
+}
+
+Node.prototype.get = function (name, value) {
+  if (this.data.hasOwnProperty(name)) {
+    return this.data[name]
+  }
+  return value
+}
+
+Node.prototype.set = function (name, value) {
+  return (this.data[name] = value)
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Node