now-cli/lib/utils/input/text.js

const ansiEscapes = require('ansi-escapes')
const ansiRegex = require('ansi-regex')
const chalk = require('chalk')
const stripAnsi = require('strip-ansi')

const ESCAPES = {
  LEFT: '\x1b[D',
  RIGHT: '\x1b[C',
  CTRL_C: '\x03',
  BACKSPACE: '\x08',
  CTRL_H: '\x7f',
  CARRIAGE: '\r'
}

module.exports = function ({
  label = '',
  initialValue = '',
  // can be:
  // - `false`, which does nothing
  // - `cc`, for credit cards
  // - `date`, for dates in the mm / yyyy format
  mask = false,
  placeholder = '',
  abortSequences = new Set(['\x03']),
  eraseSequences = new Set([ESCAPES.BACKSPACE, ESCAPES.CTRL_H]),
  resolveChars = new Set([ESCAPES.CARRIAGE]),
  stdin = process.stdin,
  stdout = process.stdout,
  // char to print before resolving/rejecting the promise
  // if `false`, nothing will be printed
  trailing = ansiEscapes.eraseLines(1),
  // gets called on each keypress;
  // `data` contains the current keypress;
  // `futureValue` contains the current value + the
  // keypress in the correct place
  validateKeypress = (data, futureValue) => true, // eslint-disable-line no-unused-vars
  // get's called before the promise is resolved
  // returning `false` here will prevent the user from submiting the value
  validateValue = data => true, // eslint-disable-line no-unused-vars
  // receives the value of the input and should return a string
  // or false if no autocomplion is available
  autoComplete = value => false, // eslint-disable-line no-unused-vars
  autoCompleteChars = new Set([
    '\t', // tab
    '\x1b[C' // right arrow
  ])
} = {}) {
  return new Promise((resolve, reject) => {
    const isRaw = process.stdin.isRaw

    let value
    let caretOffset = 0
    let regex
    let suggestion = ''

    stdout.write(label)
    value = initialValue
    stdout.write(initialValue)
    if (mask) {
      if (!value) {
        value = chalk.gray(placeholder)
        caretOffset = 0 - stripAnsi(value).length
        stdout.write(value)
        stdout.write(ansiEscapes.cursorBackward(Math.abs(caretOffset)))
      }

      regex = placeholder.split('').reduce((prev, curr) => {
        if (curr !== ' ' && !prev.includes(curr)) {
          if (curr === '/') {
            prev.push(' / ')
          } else {
            prev.push(curr)
          }
        }
        return prev
      }, []).join('|')
      regex = new RegExp(`(${regex})`, 'g')
    }
    stdin.setRawMode(true)
    stdin.resume()

    function restore() {
      stdin.setRawMode(isRaw)
      stdin.pause()
      stdin.removeListener('data', onData)
      if (trailing) {
        stdout.write(trailing)
      }
    }

    async function onData(buffer) {
      const data = buffer.toString()
      value = stripAnsi(value)

      if (abortSequences.has(data)) {
        restore()
        return reject(new Error('USER_ABORT'))
      }

      if (suggestion !== '' && !caretOffset && autoCompleteChars.has(data)) {
        value += stripAnsi(suggestion)
        suggestion = ''
      } else if (data === ESCAPES.LEFT) {
        if (value.length > Math.abs(caretOffset)) {
          caretOffset--
        }
      } else if (data === ESCAPES.RIGHT) {
        if (caretOffset < 0) {
          caretOffset++
        }
      } else if (eraseSequences.has(data)) {
        let char
        if ((mask) && value.length > Math.abs(caretOffset)) {
          if (value[value.length + caretOffset - 1] === ' ') {
            if (value[value.length + caretOffset - 2] === '/') {
              caretOffset -= 1
            }
            char = placeholder[value.length + caretOffset]
            value = value.substr(0, value.length + caretOffset - 2) + char +
              value.substr(value.length + caretOffset - 1)
            caretOffset--
          } else {
            char = placeholder[value.length + caretOffset - 1]
            value = value.substr(0, value.length + caretOffset - 1) + char +
              value.substr(value.length + caretOffset)
          }
          caretOffset--
        } else {
          value = value.substr(0, value.length + caretOffset - 1) +
            value.substr(value.length + caretOffset)
        }
        suggestion = ''
      } else if (resolveChars.has(data)) {
        if (validateValue(value)) {
          restore()
          resolve(value)
        } else {
          if (mask === 'cc' || mask === 'ccv') {
            value = value.replace(/\s/g, '').replace(/(.{4})/g, '$1 ').trim()
            value = value.replace(regex, chalk.gray('$1'))
          } else if (mask === 'expDate') {
            value = value.replace(regex, chalk.gray('$1'))
          }
          const l = chalk.red(label.replace('-', '✖'))
          stdout.write(ansiEscapes.eraseLines(1) + l + value + ansiEscapes.beep)
          if (caretOffset) {
            process.stdout.write(ansiEscapes.cursorBackward(Math.abs(caretOffset)))
          }
        }
        return
      } else if (!ansiRegex().test(data)) {
        let tmp = value.substr(0, value.length + caretOffset) + data +
          value.substr(value.length + caretOffset)

        if (mask) {
          if (/\d/.test(data) && caretOffset !== 0) {
            if (value[value.length + caretOffset + 1] === ' ') {
              tmp = value.substr(0, value.length + caretOffset) + data +
                value.substr(value.length + caretOffset + 1)
              caretOffset += 2
              if (value[value.length + caretOffset] === '/') {
                caretOffset += 2
              }
            } else {
              tmp = value.substr(0, value.length + caretOffset) + data +
                value.substr(value.length + caretOffset + 1)
              caretOffset++
            }
          } else if (/\s/.test(data) && caretOffset < 0) {
            caretOffset++
            tmp = value
          } else {
            return stdout.write(ansiEscapes.beep)
          }
          value = tmp
        } else if (validateKeypress(data, value)) {
          value = tmp
          if (caretOffset === 0) {
            const completion = await autoComplete(value)
            if (completion) {
              suggestion = chalk.gray(completion)
              suggestion += ansiEscapes.cursorBackward(completion.length)
            } else {
              suggestion = ''
            }
          }
        } else {
          return stdout.write(ansiEscapes.beep)
        }
      }

      if (mask === 'cc' || mask === 'ccv') {
        value = value.replace(/\s/g, '').replace(/(.{4})/g, '$1 ').trim()
        value = value.replace(regex, chalk.gray('$1'))
      } else if (mask === 'expDate') {
        value = value.replace(regex, chalk.gray('$1'))
      }

      stdout.write(ansiEscapes.eraseLines(1) + label + value + suggestion)
      if (caretOffset) {
        process.stdout.write(ansiEscapes.cursorBackward(Math.abs(caretOffset)))
      }
    }

    stdin.on('data', onData)
  })
}