@socketsecurity/cli-with-sentry 0.14.136 → 0.14.138

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

@@ -0,0 +1,223 @@
+/**
+ * filemanager.js - file manager element for blessed
+ * Copyright (c) 2013-2015, Christopher Jeffrey and contributors (MIT License).
+ * https://github.com/chjj/blessed
+ */
+
+/**
+ * Modules
+ */
+
+const path = require('node:path'),
+  fs = require('node:fs')
+
+const helpers = require('../helpers')
+
+const Node = require('./node')
+const List = require('./list')
+
+/**
+ * FileManager
+ */
+
+function FileManager(options) {
+  const self = this
+
+  if (!(this instanceof Node)) {
+    return new FileManager(options)
+  }
+
+  options = options || {}
+  options.parseTags = true
+  // options.label = ' {blue-fg}%path{/blue-fg} ';
+
+  List.call(this, options)
+
+  this.cwd = options.cwd || process.cwd()
+  this.file = this.cwd
+  this.value = this.cwd
+
+  if (options.label && ~options.label.indexOf('%path')) {
+    this._label.setContent(options.label.replace('%path', this.cwd))
+  }
+
+  this.on('select', function (item) {
+    const value = item.content.replace(/\{[^{}]+\}/g, '').replace(/@$/, ''),
+      file = path.resolve(self.cwd, value)
+
+    return fs.stat(file, function (err, stat) {
+      if (err) {
+        return self.emit('error', err, file)
+      }
+      self.file = file
+      self.value = file
+      if (stat.isDirectory()) {
+        self.emit('cd', file, self.cwd)
+        self.cwd = file
+        if (options.label && ~options.label.indexOf('%path')) {
+          self._label.setContent(options.label.replace('%path', file))
+        }
+        self.refresh()
+      } else {
+        self.emit('file', file)
+      }
+    })
+  })
+}
+
+Object.setPrototypeOf(FileManager.prototype, List.prototype)
+
+FileManager.prototype.type = 'file-manager'
+
+FileManager.prototype.refresh = function (cwd, callback) {
+  if (!callback) {
+    callback = cwd
+    cwd = null
+  }
+
+  const self = this
+
+  if (cwd) {
+    this.cwd = cwd
+  } else {
+    cwd = this.cwd
+  }
+
+  return fs.readdir(cwd, function (err, list) {
+    if (err && err.code === 'ENOENT') {
+      self.cwd = cwd !== process.env.HOME ? process.env.HOME : '/'
+      return self.refresh(callback)
+    }
+
+    if (err) {
+      if (callback) {
+        return callback(err)
+      }
+      return self.emit('error', err, cwd)
+    }
+
+    let dirs = [],
+      files = []
+
+    list.unshift('..')
+
+    list.forEach(function (name) {
+      let f = path.resolve(cwd, name),
+        stat
+
+      try {
+        stat = fs.lstatSync(f)
+      } catch (e) {}
+
+      if ((stat && stat.isDirectory()) || name === '..') {
+        dirs.push({
+          name: name,
+          text: '{light-blue-fg}' + name + '{/light-blue-fg}/',
+          dir: true
+        })
+      } else if (stat && stat.isSymbolicLink()) {
+        files.push({
+          name: name,
+          text: '{light-cyan-fg}' + name + '{/light-cyan-fg}@',
+          dir: false
+        })
+      } else {
+        files.push({
+          name: name,
+          text: name,
+          dir: false
+        })
+      }
+    })
+
+    dirs = helpers.asort(dirs)
+    files = helpers.asort(files)
+
+    list = dirs.concat(files).map(function (data) {
+      return data.text
+    })
+
+    self.setItems(list)
+    self.select(0)
+    self.screen.render()
+
+    self.emit('refresh')
+
+    if (callback) {
+      callback()
+    }
+  })
+}
+
+FileManager.prototype.pick = function (cwd, callback) {
+  if (!callback) {
+    callback = cwd
+    cwd = null
+  }
+
+  let self = this,
+    focused = this.screen.focused === this,
+    hidden = this.hidden,
+    onfile,
+    oncancel
+
+  function resume() {
+    self.removeListener('file', onfile)
+    self.removeListener('cancel', oncancel)
+    if (hidden) {
+      self.hide()
+    }
+    if (!focused) {
+      self.screen.restoreFocus()
+    }
+    self.screen.render()
+  }
+
+  this.on(
+    'file',
+    (onfile = function (file) {
+      resume()
+      return callback(null, file)
+    })
+  )
+
+  this.on(
+    'cancel',
+    (oncancel = function () {
+      resume()
+      return callback()
+    })
+  )
+
+  this.refresh(cwd, function (err) {
+    if (err) {
+      return callback(err)
+    }
+
+    if (hidden) {
+      self.show()
+    }
+
+    if (!focused) {
+      self.screen.saveFocus()
+      self.focus()
+    }
+
+    self.screen.render()
+  })
+}
+
+FileManager.prototype.reset = function (cwd, callback) {
+  if (!callback) {
+    callback = cwd
+    cwd = null
+  }
+  this.cwd = cwd || this.options.cwd
+  this.refresh(callback)
+}
+
+/**
+ * Expose
+ */
+
+module.exports = FileManager

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

@@ -0,0 +1,301 @@
+/**
+ * form.js - form 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')
+
+/**
+ * Form
+ */
+
+function Form(options) {
+  const self = this
+
+  if (!(this instanceof Node)) {
+    return new Form(options)
+  }
+
+  options = options || {}
+
+  options.ignoreKeys = true
+  Box.call(this, options)
+
+  if (options.keys) {
+    this.screen._listenKeys(this)
+    this.on('element keypress', function (el, ch, key) {
+      if (
+        (key.name === 'tab' && !key.shift) ||
+        (el.type === 'textbox' && options.autoNext && key.name === 'enter') ||
+        key.name === 'down' ||
+        (options.vi && key.name === 'j')
+      ) {
+        if (el.type === 'textbox' || el.type === 'textarea') {
+          if (key.name === 'j') {
+            return
+          }
+          if (key.name === 'tab') {
+            // Workaround, since we can't stop the tab from being added.
+            el.emit('keypress', null, { name: 'backspace' })
+          }
+          el.emit('keypress', '\x1b', { name: 'escape' })
+        }
+        self.focusNext()
+        return
+      }
+
+      if (
+        (key.name === 'tab' && key.shift) ||
+        key.name === 'up' ||
+        (options.vi && key.name === 'k')
+      ) {
+        if (el.type === 'textbox' || el.type === 'textarea') {
+          if (key.name === 'k') {
+            return
+          }
+          el.emit('keypress', '\x1b', { name: 'escape' })
+        }
+        self.focusPrevious()
+        return
+      }
+
+      if (key.name === 'escape') {
+        self.focus()
+        return
+      }
+    })
+  }
+}
+
+Object.setPrototypeOf(Form.prototype, Box.prototype)
+
+Form.prototype.type = 'form'
+
+Form.prototype._refresh = function () {
+  // XXX Possibly remove this if statement and refresh on every focus.
+  // Also potentially only include *visible* focusable elements.
+  // This would remove the need to check for _selected.visible in previous()
+  // and next().
+  if (!this._children) {
+    const out = []
+
+    this.children.forEach(function fn(el) {
+      if (el.keyable) {
+        out.push(el)
+      }
+      el.children.forEach(fn)
+    })
+
+    this._children = out
+  }
+}
+
+Form.prototype._visible = function () {
+  return !!this._children.filter(function (el) {
+    return el.visible
+  }).length
+}
+
+Form.prototype.next = function () {
+  this._refresh()
+
+  if (!this._visible()) {
+    return
+  }
+
+  if (!this._selected) {
+    this._selected = this._children[0]
+    if (!this._selected.visible) {
+      return this.next()
+    }
+    if (this.screen.focused !== this._selected) {
+      return this._selected
+    }
+  }
+
+  const i = this._children.indexOf(this._selected)
+  if (!~i || !this._children[i + 1]) {
+    this._selected = this._children[0]
+    if (!this._selected.visible) {
+      return this.next()
+    }
+    return this._selected
+  }
+
+  this._selected = this._children[i + 1]
+  if (!this._selected.visible) {
+    return this.next()
+  }
+  return this._selected
+}
+
+Form.prototype.previous = function () {
+  this._refresh()
+
+  if (!this._visible()) {
+    return
+  }
+
+  if (!this._selected) {
+    this._selected = this._children[this._children.length - 1]
+    if (!this._selected.visible) {
+      return this.previous()
+    }
+    if (this.screen.focused !== this._selected) {
+      return this._selected
+    }
+  }
+
+  const i = this._children.indexOf(this._selected)
+  if (!~i || !this._children[i - 1]) {
+    this._selected = this._children[this._children.length - 1]
+    if (!this._selected.visible) {
+      return this.previous()
+    }
+    return this._selected
+  }
+
+  this._selected = this._children[i - 1]
+  if (!this._selected.visible) {
+    return this.previous()
+  }
+  return this._selected
+}
+
+Form.prototype.focusNext = function () {
+  const next = this.next()
+  if (next) {
+    next.focus()
+  }
+}
+
+Form.prototype.focusPrevious = function () {
+  const previous = this.previous()
+  if (previous) {
+    previous.focus()
+  }
+}
+
+Form.prototype.resetSelected = function () {
+  this._selected = null
+}
+
+Form.prototype.focusFirst = function () {
+  this.resetSelected()
+  this.focusNext()
+}
+
+Form.prototype.focusLast = function () {
+  this.resetSelected()
+  this.focusPrevious()
+}
+
+Form.prototype.submit = function () {
+  const out = {}
+
+  this.children.forEach(function fn(el) {
+    if (el.value != null) {
+      const name = el.name || el.type
+      if (Array.isArray(out[name])) {
+        out[name].push(el.value)
+      } else if (out[name]) {
+        out[name] = [out[name], el.value]
+      } else {
+        out[name] = el.value
+      }
+    }
+    el.children.forEach(fn)
+  })
+
+  this.emit('submit', out)
+
+  return (this.submission = out)
+}
+
+Form.prototype.cancel = function () {
+  this.emit('cancel')
+}
+
+Form.prototype.reset = function () {
+  this.children.forEach(function fn(el) {
+    switch (el.type) {
+      case 'screen':
+        break
+      case 'box':
+        break
+      case 'text':
+        break
+      case 'line':
+        break
+      case 'scrollable-box':
+        break
+      case 'list':
+        el.select(0)
+        return
+      case 'form':
+        break
+      case 'input':
+        break
+      case 'textbox':
+        el.clearInput()
+        return
+      case 'textarea':
+        el.clearInput()
+        return
+      case 'button':
+        delete el.value
+        break
+      case 'progress-bar':
+        el.setProgress(0)
+        break
+      case 'file-manager':
+        el.refresh(el.options.cwd)
+        return
+      case 'checkbox':
+        el.uncheck()
+        return
+      case 'radio-set':
+        break
+      case 'radio-button':
+        el.uncheck()
+        return
+      case 'prompt':
+        break
+      case 'question':
+        break
+      case 'message':
+        break
+      case 'info':
+        break
+      case 'loading':
+        break
+      case 'list-bar':
+        //el.select(0);
+        break
+      case 'dir-manager':
+        el.refresh(el.options.cwd)
+        return
+      case 'terminal':
+        el.write('')
+        return
+      case 'image':
+        //el.clearImage();
+        return
+    }
+    el.children.forEach(fn)
+  })
+
+  this.emit('reset')
+}
+
+/**
+ * Expose
+ */
+
+module.exports = Form

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

@@ -0,0 +1,71 @@
+/**
+ * image.js - image 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')
+
+/**
+ * Image
+ */
+
+function Image(options) {
+  if (!(this instanceof Node)) {
+    return new Image(options)
+  }
+
+  options = options || {}
+  options.type = options.itype || options.type || 'ansi'
+
+  Box.call(this, options)
+
+  if (options.type === 'ansi' && this.type !== 'ansiimage') {
+    const ANSIImage = require('./ansiimage')
+    Object.getOwnPropertyNames(ANSIImage.prototype).forEach(function (key) {
+      if (key === 'type') {
+        return
+      }
+      Object.defineProperty(
+        this,
+        key,
+        Object.getOwnPropertyDescriptor(ANSIImage.prototype, key)
+      )
+    }, this)
+    ANSIImage.call(this, options)
+    return this
+  }
+
+  if (options.type === 'overlay' && this.type !== 'overlayimage') {
+    const OverlayImage = require('./overlayimage')
+    Object.getOwnPropertyNames(OverlayImage.prototype).forEach(function (key) {
+      if (key === 'type') {
+        return
+      }
+      Object.defineProperty(
+        this,
+        key,
+        Object.getOwnPropertyDescriptor(OverlayImage.prototype, key)
+      )
+    }, this)
+    OverlayImage.call(this, options)
+    return this
+  }
+
+  throw new Error('`type` must either be `ansi` or `overlay`.')
+}
+
+Object.setPrototypeOf(Image.prototype, Box.prototype)
+
+Image.prototype.type = 'image'
+
+/**
+ * Expose
+ */
+
+module.exports = Image

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

@@ -0,0 +1,34 @@
+/**
+ * input.js - abstract input 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')
+
+/**
+ * Input
+ */
+
+function Input(options) {
+  if (!(this instanceof Node)) {
+    return new Input(options)
+  }
+  options = options || {}
+  Box.call(this, options)
+}
+
+Object.setPrototypeOf(Input.prototype, Box.prototype)
+
+Input.prototype.type = 'input'
+
+/**
+ * Expose
+ */
+
+module.exports = Input