diff options
Diffstat (limited to 'sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils')
6 files changed, 405 insertions, 0 deletions
diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/events.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/events.js new file mode 100644 index 00000000..b4b16bb1 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/events.js @@ -0,0 +1,54 @@ +'use strict'; +const { fromEvent } = require('rxjs'); +const { filter, map, share, takeUntil } = require('rxjs/operators'); + +function normalizeKeypressEvents(value, key) { + return { value, key: key || {} }; +} + +module.exports = function (rl) { + const keypress = fromEvent(rl.input, 'keypress', normalizeKeypressEvents) + .pipe(takeUntil(fromEvent(rl, 'close'))) + // Ignore `enter` key. On the readline, we only care about the `line` event. + .pipe(filter(({ key }) => key.name !== 'enter' && key.name !== 'return')); + + return { + line: fromEvent(rl, 'line'), + keypress, + + normalizedUpKey: keypress.pipe( + filter( + ({ key }) => + key.name === 'up' || key.name === 'k' || (key.name === 'p' && key.ctrl) + ), + share() + ), + + normalizedDownKey: keypress.pipe( + filter( + ({ key }) => + key.name === 'down' || key.name === 'j' || (key.name === 'n' && key.ctrl) + ), + share() + ), + + numberKey: keypress.pipe( + filter((e) => e.value && '123456789'.indexOf(e.value) >= 0), + map((e) => Number(e.value)), + share() + ), + + spaceKey: keypress.pipe( + filter(({ key }) => key && key.name === 'space'), + share() + ), + aKey: keypress.pipe( + filter(({ key }) => key && key.name === 'a'), + share() + ), + iKey: keypress.pipe( + filter(({ key }) => key && key.name === 'i'), + share() + ), + }; +}; diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/incrementListIndex.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/incrementListIndex.js new file mode 100644 index 00000000..49aa2011 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/incrementListIndex.js @@ -0,0 +1,19 @@ +function incrementListIndex(current, dir, opt) { + const len = opt.choices.realLength; + const shouldLoop = 'loop' in opt ? Boolean(opt.loop) : true; + if (dir === 'up') { + if (current > 0) { + return current - 1; + } + return shouldLoop ? len - 1 : current; + } + if (dir === 'down') { + if (current < len - 1) { + return current + 1; + } + return shouldLoop ? 0 : current; + } + throw new Error('dir must be up or down'); +} + +module.exports = incrementListIndex; diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/paginator.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/paginator.js new file mode 100644 index 00000000..767bf672 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/paginator.js @@ -0,0 +1,78 @@ +'use strict'; + +const _ = { + sum: require('lodash/sum'), + flatten: require('lodash/flatten'), +}; +const chalk = require('chalk'); + +/** + * The paginator returns a subset of the choices if the list is too long. + */ + +class Paginator { + constructor(screen, options = {}) { + const { isInfinite = true } = options; + this.lastIndex = 0; + this.screen = screen; + this.isInfinite = isInfinite; + } + + paginate(output, active, pageSize) { + pageSize = pageSize || 7; + let lines = output.split('\n'); + + if (this.screen) { + lines = this.screen.breakLines(lines); + active = _.sum(lines.map((lineParts) => lineParts.length).splice(0, active)); + lines = _.flatten(lines); + } + + // Make sure there's enough lines to paginate + if (lines.length <= pageSize) { + return output; + } + const visibleLines = this.isInfinite + ? this.getInfiniteLines(lines, active, pageSize) + : this.getFiniteLines(lines, active, pageSize); + this.lastIndex = active; + return ( + visibleLines.join('\n') + + '\n' + + chalk.dim('(Move up and down to reveal more choices)') + ); + } + + getInfiniteLines(lines, active, pageSize) { + if (this.pointer === undefined) { + this.pointer = 0; + } + const middleOfList = Math.floor(pageSize / 2); + // Move the pointer only when the user go down and limit it to the middle of the list + if ( + this.pointer < middleOfList && + this.lastIndex < active && + active - this.lastIndex < pageSize + ) { + this.pointer = Math.min(middleOfList, this.pointer + active - this.lastIndex); + } + + // Duplicate the lines so it give an infinite list look + const infinite = _.flatten([lines, lines, lines]); + const topIndex = Math.max(0, active + lines.length - this.pointer); + + return infinite.splice(topIndex, pageSize); + } + + getFiniteLines(lines, active, pageSize) { + let topIndex = active - pageSize / 2; + if (topIndex < 0) { + topIndex = 0; + } else if (topIndex + pageSize > lines.length) { + topIndex = lines.length - pageSize; + } + return lines.splice(topIndex, pageSize); + } +} + +module.exports = Paginator; diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/readline.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/readline.js new file mode 100644 index 00000000..769f5d7f --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/readline.js @@ -0,0 +1,51 @@ +'use strict'; +const ansiEscapes = require('ansi-escapes'); + +/** + * Move cursor left by `x` + * @param {Readline} rl - Readline instance + * @param {Number} x - How far to go left (default to 1) + */ + +exports.left = function (rl, x) { + rl.output.write(ansiEscapes.cursorBackward(x)); +}; + +/** + * Move cursor right by `x` + * @param {Readline} rl - Readline instance + * @param {Number} x - How far to go left (default to 1) + */ + +exports.right = function (rl, x) { + rl.output.write(ansiEscapes.cursorForward(x)); +}; + +/** + * Move cursor up by `x` + * @param {Readline} rl - Readline instance + * @param {Number} x - How far to go up (default to 1) + */ + +exports.up = function (rl, x) { + rl.output.write(ansiEscapes.cursorUp(x)); +}; + +/** + * Move cursor down by `x` + * @param {Readline} rl - Readline instance + * @param {Number} x - How far to go down (default to 1) + */ + +exports.down = function (rl, x) { + rl.output.write(ansiEscapes.cursorDown(x)); +}; + +/** + * Clear current line + * @param {Readline} rl - Readline instance + * @param {Number} len - number of line to delete + */ +exports.clearLine = function (rl, len) { + rl.output.write(ansiEscapes.eraseLines(len)); +}; diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/screen-manager.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/screen-manager.js new file mode 100644 index 00000000..12412c64 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/screen-manager.js @@ -0,0 +1,175 @@ +'use strict'; +const _ = { + last: require('lodash/last'), + flatten: require('lodash/flatten'), +}; +const util = require('./readline'); +const cliWidth = require('cli-width'); +const stripAnsi = require('strip-ansi'); +const stringWidth = require('string-width'); +const ora = require('ora'); + +function height(content) { + return content.split('\n').length; +} + +function lastLine(content) { + return _.last(content.split('\n')); +} + +class ScreenManager { + constructor(rl) { + // These variables are keeping information to allow correct prompt re-rendering + this.height = 0; + this.extraLinesUnderPrompt = 0; + + this.rl = rl; + } + + renderWithSpinner(content, bottomContent) { + if (this.spinnerId) { + clearInterval(this.spinnerId); + } + + let spinner; + let contentFunc; + let bottomContentFunc; + + if (bottomContent) { + spinner = ora(bottomContent); + contentFunc = () => content; + bottomContentFunc = () => spinner.frame(); + } else { + spinner = ora(content); + contentFunc = () => spinner.frame(); + bottomContentFunc = () => ''; + } + + this.spinnerId = setInterval( + () => this.render(contentFunc(), bottomContentFunc(), true), + spinner.interval + ); + } + + render(content, bottomContent, spinning = false) { + if (this.spinnerId && !spinning) { + clearInterval(this.spinnerId); + } + + this.rl.output.unmute(); + this.clean(this.extraLinesUnderPrompt); + + /** + * Write message to screen and setPrompt to control backspace + */ + + const promptLine = lastLine(content); + const rawPromptLine = stripAnsi(promptLine); + + // Remove the rl.line from our prompt. We can't rely on the content of + // rl.line (mainly because of the password prompt), so just rely on it's + // length. + let prompt = rawPromptLine; + if (this.rl.line.length) { + prompt = prompt.slice(0, -this.rl.line.length); + } + + this.rl.setPrompt(prompt); + + // SetPrompt will change cursor position, now we can get correct value + const cursorPos = this.rl._getCursorPos(); + const width = this.normalizedCliWidth(); + + content = this.forceLineReturn(content, width); + if (bottomContent) { + bottomContent = this.forceLineReturn(bottomContent, width); + } + + // Manually insert an extra line if we're at the end of the line. + // This prevent the cursor from appearing at the beginning of the + // current line. + if (rawPromptLine.length % width === 0) { + content += '\n'; + } + + const fullContent = content + (bottomContent ? '\n' + bottomContent : ''); + this.rl.output.write(fullContent); + + /** + * Re-adjust the cursor at the correct position. + */ + + // We need to consider parts of the prompt under the cursor as part of the bottom + // content in order to correctly cleanup and re-render. + const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - cursorPos.rows; + const bottomContentHeight = + promptLineUpDiff + (bottomContent ? height(bottomContent) : 0); + if (bottomContentHeight > 0) { + util.up(this.rl, bottomContentHeight); + } + + // Reset cursor at the beginning of the line + util.left(this.rl, stringWidth(lastLine(fullContent))); + + // Adjust cursor on the right + if (cursorPos.cols > 0) { + util.right(this.rl, cursorPos.cols); + } + + /** + * Set up state for next re-rendering + */ + this.extraLinesUnderPrompt = bottomContentHeight; + this.height = height(fullContent); + + this.rl.output.mute(); + } + + clean(extraLines) { + if (extraLines > 0) { + util.down(this.rl, extraLines); + } + + util.clearLine(this.rl, this.height); + } + + done() { + this.rl.setPrompt(''); + this.rl.output.unmute(); + this.rl.output.write('\n'); + } + + releaseCursor() { + if (this.extraLinesUnderPrompt > 0) { + util.down(this.rl, this.extraLinesUnderPrompt); + } + } + + normalizedCliWidth() { + const width = cliWidth({ + defaultWidth: 80, + output: this.rl.output, + }); + return width; + } + + breakLines(lines, width) { + // Break lines who're longer than the cli width so we can normalize the natural line + // returns behavior across terminals. + width = width || this.normalizedCliWidth(); + const regex = new RegExp('(?:(?:\\033[[0-9;]*m)*.?){1,' + width + '}', 'g'); + return lines.map((line) => { + const chunk = line.match(regex); + // Last match is always empty + chunk.pop(); + return chunk || ''; + }); + } + + forceLineReturn(content, width) { + width = width || this.normalizedCliWidth(); + return _.flatten(this.breakLines(content.split('\n'), width)).join('\n'); + } +} + +module.exports = ScreenManager; diff --git a/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/utils.js b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/utils.js new file mode 100644 index 00000000..92117510 --- /dev/null +++ b/sandbox/testAppNevena/Front/node_modules/inquirer/lib/utils/utils.js @@ -0,0 +1,28 @@ +'use strict'; +const _ = { + isFunction: require('lodash/isFunction'), +}; +const { from, of } = require('rxjs'); +const runAsync = require('run-async'); + +/** + * Resolve a question property value if it is passed as a function. + * This method will overwrite the property on the question object with the received value. + * @param {Object} question - Question object + * @param {String} prop - Property to fetch name + * @param {Object} answers - Answers object + * @return {Rx.Observable} - Observable emitting once value is known + */ + +exports.fetchAsyncQuestionProperty = function (question, prop, answers) { + if (!_.isFunction(question[prop])) { + return of(question); + } + + return from( + runAsync(question[prop])(answers).then((value) => { + question[prop] = value; + return question; + }) + ); +}; |