@socketsecurity/cli-with-sentry 0.15.10 → 0.15.12

package/external/blessed/lib/widgets/text.js

@@ -10,8 +10,8 @@
  * Modules
  */
 
-const Node = require('./node')
-const Element = require('./element')
+var Node = require('./node');
+var Element = require('./element');
 
 /**
  * Text
@@ -19,19 +19,19 @@ const Element = require('./element')
 
 function Text(options) {
   if (!(this instanceof Node)) {
-    return new Text(options)
+    return new Text(options);
   }
-  options = options || {}
-  options.shrink = true
-  Element.call(this, options)
+  options = options || {};
+  options.shrink = true;
+  Element.call(this, options);
 }
 
-Object.setPrototypeOf(Text.prototype, Element.prototype)
+Object.setPrototypeOf(Text.prototype, Element.prototype);
 
-Text.prototype.type = 'text'
+Text.prototype.type = 'text';
 
 /**
  * Expose
  */
 
-module.exports = Text
+module.exports = Text;

package/external/blessed/lib/widgets/textarea.js

@@ -10,369 +10,335 @@
  * Modules
  */
 
-const unicode = require('../unicode')
+var unicode = require('../unicode');
 
-const nextTick = global.setImmediate || process.nextTick.bind(process)
+var nextTick = global.setImmediate || process.nextTick.bind(process);
 
-const Node = require('./node')
-const Input = require('./input')
+var Node = require('./node');
+var Input = require('./input');
 
 /**
  * Textarea
  */
 
 function Textarea(options) {
-  const self = this
+  var self = this;
 
   if (!(this instanceof Node)) {
-    return new Textarea(options)
+    return new Textarea(options);
   }
 
-  options = options || {}
+  options = options || {};
 
-  options.scrollable = options.scrollable !== false
+  options.scrollable = options.scrollable !== false;
 
-  Input.call(this, options)
+  Input.call(this, options);
 
-  this.screen._listenKeys(this)
+  this.screen._listenKeys(this);
 
-  this.value = options.value || ''
+  this.value = options.value || '';
 
-  this.__updateCursor = this._updateCursor.bind(this)
-  this.on('resize', this.__updateCursor)
-  this.on('move', this.__updateCursor)
+  this.__updateCursor = this._updateCursor.bind(this);
+  this.on('resize', this.__updateCursor);
+  this.on('move', this.__updateCursor);
 
   if (options.inputOnFocus) {
-    this.on('focus', this.readInput.bind(this, null))
+    this.on('focus', this.readInput.bind(this, null));
   }
 
   if (!options.inputOnFocus && options.keys) {
-    this.on('keypress', function (ch, key) {
-      if (self._reading) {
-        return
-      }
+    this.on('keypress', function(ch, key) {
+      if (self._reading) return;
       if (key.name === 'enter' || (options.vi && key.name === 'i')) {
-        return self.readInput()
+        return self.readInput();
       }
       if (key.name === 'e') {
-        return self.readEditor()
+        return self.readEditor();
       }
-    })
+    });
   }
 
   if (options.mouse) {
-    this.on('click', function (data) {
-      if (self._reading) {
-        return
-      }
-      if (data.button !== 'right') {
-        return
-      }
-      self.readEditor()
-    })
+    this.on('click', function(data) {
+      if (self._reading) return;
+      if (data.button !== 'right') return;
+      self.readEditor();
+    });
   }
 }
 
-Object.setPrototypeOf(Textarea.prototype, Input.prototype)
+Object.setPrototypeOf(Textarea.prototype, Input.prototype);
 
-Textarea.prototype.type = 'textarea'
+Textarea.prototype.type = 'textarea';
 
-Textarea.prototype._updateCursor = function (get) {
+Textarea.prototype._updateCursor = function(get) {
   if (this.screen.focused !== this) {
-    return
+    return;
   }
 
-  const lpos = get ? this.lpos : this._getCoords()
-  if (!lpos) {
-    return
-  }
+  var lpos = get ? this.lpos : this._getCoords();
+  if (!lpos) return;
 
-  let last = this._clines[this._clines.length - 1],
-    program = this.screen.program,
-    line,
-    cx,
-    cy
+  var last = this._clines[this._clines.length - 1]
+    , program = this.screen.program
+    , line
+    , cx
+    , cy;
 
   // Stop a situation where the textarea begins scrolling
   // and the last cline appears to always be empty from the
   // _typeScroll `+ '\n'` thing.
   // Maybe not necessary anymore?
   if (last === '' && this.value[this.value.length - 1] !== '\n') {
-    last = this._clines[this._clines.length - 2] || ''
+    last = this._clines[this._clines.length - 2] || '';
   }
 
   line = Math.min(
     this._clines.length - 1 - (this.childBase || 0),
-    lpos.yl - lpos.yi - this.iheight - 1
-  )
+    (lpos.yl - lpos.yi) - this.iheight - 1);
 
   // When calling clearValue() on a full textarea with a border, the first
   // argument in the above Math.min call ends up being -2. Make sure we stay
   // positive.
-  line = Math.max(0, line)
+  line = Math.max(0, line);
 
-  cy = lpos.yi + this.itop + line
-  cx = lpos.xi + this.ileft + this.strWidth(last)
+  cy = lpos.yi + this.itop + line;
+  cx = lpos.xi + this.ileft + this.strWidth(last);
 
   // XXX Not sure, but this may still sometimes
   // cause problems when leaving editor.
   if (cy === program.y && cx === program.x) {
-    return
+    return;
   }
 
   if (cy === program.y) {
     if (cx > program.x) {
-      program.cuf(cx - program.x)
+      program.cuf(cx - program.x);
     } else if (cx < program.x) {
-      program.cub(program.x - cx)
+      program.cub(program.x - cx);
     }
   } else if (cx === program.x) {
     if (cy > program.y) {
-      program.cud(cy - program.y)
+      program.cud(cy - program.y);
     } else if (cy < program.y) {
-      program.cuu(program.y - cy)
+      program.cuu(program.y - cy);
     }
   } else {
-    program.cup(cy, cx)
+    program.cup(cy, cx);
   }
-}
+};
 
 Textarea.prototype.input =
-  Textarea.prototype.setInput =
-  Textarea.prototype.readInput =
-    function (callback) {
-      const self = this,
-        focused = this.screen.focused === this
-
-      if (this._reading) {
-        return
-      }
-      this._reading = true
+Textarea.prototype.setInput =
+Textarea.prototype.readInput = function(callback) {
+  var self = this
+    , focused = this.screen.focused === this;
 
-      this._callback = callback
+  if (this._reading) return;
+  this._reading = true;
 
-      if (!focused) {
-        this.screen.saveFocus()
-        this.focus()
-      }
+  this._callback = callback;
 
-      this.screen.grabKeys = true
+  if (!focused) {
+    this.screen.saveFocus();
+    this.focus();
+  }
 
-      this._updateCursor()
-      this.screen.program.showCursor()
-      //this.screen.program.sgr('normal');
+  this.screen.grabKeys = true;
 
-      this._done = function fn(err, value) {
-        if (!self._reading) {
-          return
-        }
+  this._updateCursor();
+  this.screen.program.showCursor();
+  //this.screen.program.sgr('normal');
 
-        if (fn.done) {
-          return
-        }
-        fn.done = true
+  this._done = function fn(err, value) {
+    if (!self._reading) return;
 
-        self._reading = false
+    if (fn.done) return;
+    fn.done = true;
 
-        delete self._callback
-        delete self._done
+    self._reading = false;
 
-        self.removeListener('keypress', self.__listener)
-        delete self.__listener
+    delete self._callback;
+    delete self._done;
 
-        self.removeListener('blur', self.__done)
-        delete self.__done
+    self.removeListener('keypress', self.__listener);
+    delete self.__listener;
 
-        self.screen.program.hideCursor()
-        self.screen.grabKeys = false
+    self.removeListener('blur', self.__done);
+    delete self.__done;
 
-        if (!focused) {
-          self.screen.restoreFocus()
-        }
+    self.screen.program.hideCursor();
+    self.screen.grabKeys = false;
 
-        if (self.options.inputOnFocus) {
-          self.screen.rewindFocus()
-        }
+    if (!focused) {
+      self.screen.restoreFocus();
+    }
 
-        // Ugly
-        if (err === 'stop') {
-          return
-        }
+    if (self.options.inputOnFocus) {
+      self.screen.rewindFocus();
+    }
 
-        if (err) {
-          self.emit('error', err)
-        } else if (value != null) {
-          self.emit('submit', value)
-        } else {
-          self.emit('cancel', value)
-        }
-        self.emit('action', value)
+    // Ugly
+    if (err === 'stop') return;
 
-        if (!callback) {
-          return
-        }
+    if (err) {
+      self.emit('error', err);
+    } else if (value != null) {
+      self.emit('submit', value);
+    } else {
+      self.emit('cancel', value);
+    }
+    self.emit('action', value);
 
-        return err ? callback(err) : callback(null, value)
-      }
+    if (!callback) return;
 
-      // Put this in a nextTick so the current
-      // key event doesn't trigger any keys input.
-      nextTick(function () {
-        self.__listener = self._listener.bind(self)
-        self.on('keypress', self.__listener)
-      })
+    return err
+      ? callback(err)
+      : callback(null, value);
+  };
 
-      this.__done = this._done.bind(this, null, null)
-      this.on('blur', this.__done)
-    }
+  // Put this in a nextTick so the current
+  // key event doesn't trigger any keys input.
+  nextTick(function() {
+    self.__listener = self._listener.bind(self);
+    self.on('keypress', self.__listener);
+  });
 
-Textarea.prototype._listener = function (ch, key) {
-  const done = this._done,
-    value = this.value
+  this.__done = this._done.bind(this, null, null);
+  this.on('blur', this.__done);
+};
 
-  if (key.name === 'return') {
-    return
-  }
+Textarea.prototype._listener = function(ch, key) {
+  var done = this._done
+    , value = this.value;
+
+  if (key.name === 'return') return;
   if (key.name === 'enter') {
-    ch = '\n'
+    ch = '\n';
   }
 
   // TODO: Handle directional keys.
-  if (
-    key.name === 'left' ||
-    key.name === 'right' ||
-    key.name === 'up' ||
-    key.name === 'down'
-  ) {
+  if (key.name === 'left' || key.name === 'right'
+      || key.name === 'up' || key.name === 'down') {
+    ;
   }
 
   if (this.options.keys && key.ctrl && key.name === 'e') {
-    return this.readEditor()
+    return this.readEditor();
   }
 
   // TODO: Optimize typing by writing directly
   // to the screen and screen buffer here.
   if (key.name === 'escape') {
-    done(null, null)
+    done(null, null);
   } else if (key.name === 'backspace') {
     if (this.value.length) {
       if (this.screen.fullUnicode) {
         if (unicode.isSurrogate(this.value, this.value.length - 2)) {
-          // || unicode.isCombining(this.value, this.value.length - 1)) {
-          this.value = this.value.slice(0, -2)
+        // || unicode.isCombining(this.value, this.value.length - 1)) {
+          this.value = this.value.slice(0, -2);
         } else {
-          this.value = this.value.slice(0, -1)
+          this.value = this.value.slice(0, -1);
         }
       } else {
-        this.value = this.value.slice(0, -1)
+        this.value = this.value.slice(0, -1);
       }
     }
   } else if (ch) {
     if (!/^[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]$/.test(ch)) {
-      this.value += ch
+      this.value += ch;
     }
   }
 
   if (this.value !== value) {
-    this.screen.render()
+    this.screen.render();
   }
-}
+};
 
-Textarea.prototype._typeScroll = function () {
+Textarea.prototype._typeScroll = function() {
   // XXX Workaround
-  const height = this.height - this.iheight
+  var height = this.height - this.iheight;
   if (this._clines.length - this.childBase > height) {
-    this.scroll(this._clines.length)
+    this.scroll(this._clines.length);
   }
-}
+};
 
-Textarea.prototype.getValue = function () {
-  return this.value
-}
+Textarea.prototype.getValue = function() {
+  return this.value;
+};
 
-Textarea.prototype.setValue = function (value) {
+Textarea.prototype.setValue = function(value) {
   if (value == null) {
-    value = this.value
+    value = this.value;
   }
   if (this._value !== value) {
-    this.value = value
-    this._value = value
-    this.setContent(this.value)
-    this._typeScroll()
-    this._updateCursor()
+    this.value = value;
+    this._value = value;
+    this.setContent(this.value);
+    this._typeScroll();
+    this._updateCursor();
   }
-}
+};
 
-Textarea.prototype.clearInput = Textarea.prototype.clearValue = function () {
-  return this.setValue('')
-}
+Textarea.prototype.clearInput =
+Textarea.prototype.clearValue = function() {
+  return this.setValue('');
+};
 
-Textarea.prototype.submit = function () {
-  if (!this.__listener) {
-    return
-  }
-  return this.__listener('\x1b', { name: 'escape' })
-}
+Textarea.prototype.submit = function() {
+  if (!this.__listener) return;
+  return this.__listener('\x1b', { name: 'escape' });
+};
 
-Textarea.prototype.cancel = function () {
-  if (!this.__listener) {
-    return
-  }
-  return this.__listener('\x1b', { name: 'escape' })
-}
+Textarea.prototype.cancel = function() {
+  if (!this.__listener) return;
+  return this.__listener('\x1b', { name: 'escape' });
+};
 
-Textarea.prototype.render = function () {
-  this.setValue()
-  return this._render()
-}
+Textarea.prototype.render = function() {
+  this.setValue();
+  return this._render();
+};
 
 Textarea.prototype.editor =
-  Textarea.prototype.setEditor =
-  Textarea.prototype.readEditor =
-    function (callback) {
-      const self = this
-
-      if (this._reading) {
-        const _cb = this._callback,
-          cb = callback
-
-        this._done('stop')
-
-        callback = function (err, value) {
-          if (_cb) {
-            _cb(err, value)
-          }
-          if (cb) {
-            cb(err, value)
-          }
-        }
-      }
+Textarea.prototype.setEditor =
+Textarea.prototype.readEditor = function(callback) {
+  var self = this;
 
-      if (!callback) {
-        callback = function () {}
-      }
+  if (this._reading) {
+    var _cb = this._callback
+      , cb = callback;
 
-      return this.screen.readEditor(
-        { value: this.value },
-        function (err, value) {
-          if (err) {
-            if (err.message === 'Unsuccessful.') {
-              self.screen.render()
-              return self.readInput(callback)
-            }
-            self.screen.render()
-            self.readInput(callback)
-            return callback(err)
-          }
-          self.setValue(value)
-          self.screen.render()
-          return self.readInput(callback)
-        }
-      )
+    this._done('stop');
+
+    callback = function(err, value) {
+      if (_cb) _cb(err, value);
+      if (cb) cb(err, value);
+    };
+  }
+
+  if (!callback) {
+    callback = function() {};
+  }
+
+  return this.screen.readEditor({ value: this.value }, function(err, value) {
+    if (err) {
+      if (err.message === 'Unsuccessful.') {
+        self.screen.render();
+        return self.readInput(callback);
+      }
+      self.screen.render();
+      self.readInput(callback);
+      return callback(err);
     }
+    self.setValue(value);
+    self.screen.render();
+    return self.readInput(callback);
+  });
+};
 
 /**
  * Expose
  */
 
-module.exports = Textarea
+module.exports = Textarea;