snyk
Version:
snyk library and cli utility
5,407 lines • 134 kB
JavaScript
exports.id = 31;
exports.ids = [31];
exports.modules = {
/***/ 53692:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
const identity = val => val;
/* eslint-disable no-control-regex */
// this is a modified version of https://github.com/chalk/ansi-regex (MIT License)
const ANSI_REGEX = /[\u001b\u009b][[\]#;?()]*(?:(?:(?:[^\W_]*;?[^\W_]*)\u0007)|(?:(?:[0-9]{1,4}(;[0-9]{0,4})*)?[~0-9=<>cf-nqrtyA-PRZ]))/g;
const create = () => {
const colors = { enabled: true, visible: true, styles: {}, keys: {} };
if ('FORCE_COLOR' in process.env) {
colors.enabled = process.env.FORCE_COLOR !== '0';
}
const ansi = style => {
let open = style.open = `\u001b[${style.codes[0]}m`;
let close = style.close = `\u001b[${style.codes[1]}m`;
let regex = style.regex = new RegExp(`\\u001b\\[${style.codes[1]}m`, 'g');
style.wrap = (input, newline) => {
if (input.includes(close)) input = input.replace(regex, close + open);
let output = open + input + close;
// see https://github.com/chalk/chalk/pull/92, thanks to the
// chalk contributors for this fix. However, we've confirmed that
// this issue is also present in Windows terminals
return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
};
return style;
};
const wrap = (style, input, newline) => {
return typeof style === 'function' ? style(input) : style.wrap(input, newline);
};
const style = (input, stack) => {
if (input === '' || input == null) return '';
if (colors.enabled === false) return input;
if (colors.visible === false) return '';
let str = '' + input;
let nl = str.includes('\n');
let n = stack.length;
if (n > 0 && stack.includes('unstyle')) {
stack = [...new Set(['unstyle', ...stack])].reverse();
}
while (n-- > 0) str = wrap(colors.styles[stack[n]], str, nl);
return str;
};
const define = (name, codes, type) => {
colors.styles[name] = ansi({ name, codes });
let keys = colors.keys[type] || (colors.keys[type] = []);
keys.push(name);
Reflect.defineProperty(colors, name, {
configurable: true,
enumerable: true,
set(value) {
colors.alias(name, value);
},
get() {
let color = input => style(input, color.stack);
Reflect.setPrototypeOf(color, colors);
color.stack = this.stack ? this.stack.concat(name) : [name];
return color;
}
});
};
define('reset', [0, 0], 'modifier');
define('bold', [1, 22], 'modifier');
define('dim', [2, 22], 'modifier');
define('italic', [3, 23], 'modifier');
define('underline', [4, 24], 'modifier');
define('inverse', [7, 27], 'modifier');
define('hidden', [8, 28], 'modifier');
define('strikethrough', [9, 29], 'modifier');
define('black', [30, 39], 'color');
define('red', [31, 39], 'color');
define('green', [32, 39], 'color');
define('yellow', [33, 39], 'color');
define('blue', [34, 39], 'color');
define('magenta', [35, 39], 'color');
define('cyan', [36, 39], 'color');
define('white', [37, 39], 'color');
define('gray', [90, 39], 'color');
define('grey', [90, 39], 'color');
define('bgBlack', [40, 49], 'bg');
define('bgRed', [41, 49], 'bg');
define('bgGreen', [42, 49], 'bg');
define('bgYellow', [43, 49], 'bg');
define('bgBlue', [44, 49], 'bg');
define('bgMagenta', [45, 49], 'bg');
define('bgCyan', [46, 49], 'bg');
define('bgWhite', [47, 49], 'bg');
define('blackBright', [90, 39], 'bright');
define('redBright', [91, 39], 'bright');
define('greenBright', [92, 39], 'bright');
define('yellowBright', [93, 39], 'bright');
define('blueBright', [94, 39], 'bright');
define('magentaBright', [95, 39], 'bright');
define('cyanBright', [96, 39], 'bright');
define('whiteBright', [97, 39], 'bright');
define('bgBlackBright', [100, 49], 'bgBright');
define('bgRedBright', [101, 49], 'bgBright');
define('bgGreenBright', [102, 49], 'bgBright');
define('bgYellowBright', [103, 49], 'bgBright');
define('bgBlueBright', [104, 49], 'bgBright');
define('bgMagentaBright', [105, 49], 'bgBright');
define('bgCyanBright', [106, 49], 'bgBright');
define('bgWhiteBright', [107, 49], 'bgBright');
colors.ansiRegex = ANSI_REGEX;
colors.hasColor = colors.hasAnsi = str => {
colors.ansiRegex.lastIndex = 0;
return typeof str === 'string' && str !== '' && colors.ansiRegex.test(str);
};
colors.alias = (name, color) => {
let fn = typeof color === 'string' ? colors[color] : color;
if (typeof fn !== 'function') {
throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
}
if (!fn.stack) {
Reflect.defineProperty(fn, 'name', { value: name });
colors.styles[name] = fn;
fn.stack = [name];
}
Reflect.defineProperty(colors, name, {
configurable: true,
enumerable: true,
set(value) {
colors.alias(name, value);
},
get() {
let color = input => style(input, color.stack);
Reflect.setPrototypeOf(color, colors);
color.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
return color;
}
});
};
colors.theme = custom => {
if (!isObject(custom)) throw new TypeError('Expected theme to be an object');
for (let name of Object.keys(custom)) {
colors.alias(name, custom[name]);
}
return colors;
};
colors.alias('unstyle', str => {
if (typeof str === 'string' && str !== '') {
colors.ansiRegex.lastIndex = 0;
return str.replace(colors.ansiRegex, '');
}
return '';
});
colors.alias('noop', str => str);
colors.none = colors.clear = colors.noop;
colors.stripColor = colors.unstyle;
colors.symbols = __webpack_require__(17142);
colors.define = define;
return colors;
};
module.exports = create();
module.exports.create = create;
/***/ }),
/***/ 17142:
/***/ ((module) => {
"use strict";
const isHyper = process.env.TERM_PROGRAM === 'Hyper';
const isWindows = process.platform === 'win32';
const isLinux = process.platform === 'linux';
const common = {
ballotDisabled: '☒',
ballotOff: '☐',
ballotOn: '☑',
bullet: '•',
bulletWhite: '◦',
fullBlock: '█',
heart: '❤',
identicalTo: '≡',
line: '─',
mark: '※',
middot: '·',
minus: '－',
multiplication: '×',
obelus: '÷',
pencilDownRight: '✎',
pencilRight: '✏',
pencilUpRight: '✐',
percent: '%',
pilcrow2: '❡',
pilcrow: '¶',
plusMinus: '±',
section: '§',
starsOff: '☆',
starsOn: '★',
upDownArrow: '↕'
};
const windows = Object.assign({}, common, {
check: '√',
cross: '×',
ellipsisLarge: '...',
ellipsis: '...',
info: 'i',
question: '?',
questionSmall: '?',
pointer: '>',
pointerSmall: '»',
radioOff: '( )',
radioOn: '(*)',
warning: '‼'
});
const other = Object.assign({}, common, {
ballotCross: '✘',
check: '✔',
cross: '✖',
ellipsisLarge: '⋯',
ellipsis: '…',
info: 'ℹ',
question: '?',
questionFull: '？',
questionSmall: '﹖',
pointer: isLinux ? '▸' : '❯',
pointerSmall: isLinux ? '‣' : '›',
radioOff: '◯',
radioOn: '◉',
warning: '⚠'
});
module.exports = (isWindows && !isHyper) ? windows : other;
Reflect.defineProperty(module.exports, 'common', { enumerable: false, value: common });
Reflect.defineProperty(module.exports, 'windows', { enumerable: false, value: windows });
Reflect.defineProperty(module.exports, 'other', { enumerable: false, value: other });
/***/ }),
/***/ 84031:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const assert = __webpack_require__(39491);
const Events = __webpack_require__(82361);
const utils = __webpack_require__(83546);
/**
* Create an instance of `Enquirer`.
*
* ```js
* const Enquirer = require('enquirer');
* const enquirer = new Enquirer();
* ```
* @name Enquirer
* @param {Object} `options` (optional) Options to use with all prompts.
* @param {Object} `answers` (optional) Answers object to initialize with.
* @api public
*/
class Enquirer extends Events {
constructor(options, answers) {
super();
this.options = utils.merge({}, options);
this.answers = { ...answers };
}
/**
* Register a custom prompt type.
*
* ```js
* const Enquirer = require('enquirer');
* const enquirer = new Enquirer();
* enquirer.register('customType', require('./custom-prompt'));
* ```
* @name register()
* @param {String} `type`
* @param {Function|Prompt} `fn` `Prompt` class, or a function that returns a `Prompt` class.
* @return {Object} Returns the Enquirer instance
* @api public
*/
register(type, fn) {
if (utils.isObject(type)) {
for (let key of Object.keys(type)) this.register(key, type[key]);
return this;
}
assert.equal(typeof fn, 'function', 'expected a function');
let name = type.toLowerCase();
if (fn.prototype instanceof this.Prompt) {
this.prompts[name] = fn;
} else {
this.prompts[name] = fn(this.Prompt, this);
}
return this;
}
/**
* Prompt function that takes a "question" object or array of question objects,
* and returns an object with responses from the user.
*
* ```js
* const Enquirer = require('enquirer');
* const enquirer = new Enquirer();
*
* const response = await enquirer.prompt({
* type: 'input',
* name: 'username',
* message: 'What is your username?'
* });
* console.log(response);
* ```
* @name prompt()
* @param {Array|Object} `questions` Options objects for one or more prompts to run.
* @return {Promise} Promise that returns an "answers" object with the user's responses.
* @api public
*/
async prompt(questions = []) {
for (let question of [].concat(questions)) {
try {
if (typeof question === 'function') question = await question.call(this);
await this.ask(utils.merge({}, this.options, question));
} catch (err) {
return Promise.reject(err);
}
}
return this.answers;
}
async ask(question) {
if (typeof question === 'function') {
question = await question.call(this);
}
let opts = utils.merge({}, this.options, question);
let { type, name } = question;
let { set, get } = utils;
if (typeof type === 'function') {
type = await type.call(this, question, this.answers);
}
if (!type) return this.answers[name];
assert(this.prompts[type], `Prompt "${type}" is not registered`);
let prompt = new this.prompts[type](opts);
let value = get(this.answers, name);
prompt.state.answers = this.answers;
prompt.enquirer = this;
if (name) {
prompt.on('submit', value => {
this.emit('answer', name, value, prompt);
set(this.answers, name, value);
});
}
// bubble events
let emit = prompt.emit.bind(prompt);
prompt.emit = (...args) => {
this.emit.call(this, ...args);
return emit(...args);
};
this.emit('prompt', prompt, this);
if (opts.autofill && value != null) {
prompt.value = prompt.input = value;
// if "autofill=show" render the prompt, otherwise stay "silent"
if (opts.autofill === 'show') {
await prompt.submit();
}
} else {
value = prompt.value = await prompt.run();
}
return value;
}
/**
* Use an enquirer plugin.
*
* ```js
* const Enquirer = require('enquirer');
* const enquirer = new Enquirer();
* const plugin = enquirer => {
* // do stuff to enquire instance
* };
* enquirer.use(plugin);
* ```
* @name use()
* @param {Function} `plugin` Plugin function that takes an instance of Enquirer.
* @return {Object} Returns the Enquirer instance.
* @api public
*/
use(plugin) {
plugin.call(this, this);
return this;
}
set Prompt(value) {
this._Prompt = value;
}
get Prompt() {
return this._Prompt || this.constructor.Prompt;
}
get prompts() {
return this.constructor.prompts;
}
static set Prompt(value) {
this._Prompt = value;
}
static get Prompt() {
return this._Prompt || __webpack_require__(232);
}
static get prompts() {
return __webpack_require__(29594);
}
static get types() {
return __webpack_require__(29920);
}
/**
* Prompt function that takes a "question" object or array of question objects,
* and returns an object with responses from the user.
*
* ```js
* const { prompt } = require('enquirer');
* const response = await prompt({
* type: 'input',
* name: 'username',
* message: 'What is your username?'
* });
* console.log(response);
* ```
* @name Enquirer#prompt
* @param {Array|Object} `questions` Options objects for one or more prompts to run.
* @return {Promise} Promise that returns an "answers" object with the user's responses.
* @api public
*/
static get prompt() {
const fn = (questions, ...rest) => {
let enquirer = new this(...rest);
let emit = enquirer.emit.bind(enquirer);
enquirer.emit = (...args) => {
fn.emit(...args);
return emit(...args);
};
return enquirer.prompt(questions);
};
utils.mixinEmitter(fn, new Events());
return fn;
}
}
utils.mixinEmitter(Enquirer, new Events());
const prompts = Enquirer.prompts;
for (let name of Object.keys(prompts)) {
let key = name.toLowerCase();
let run = options => new prompts[name](options).run();
Enquirer.prompt[key] = run;
Enquirer[key] = run;
if (!Enquirer[name]) {
Reflect.defineProperty(Enquirer, name, { get: () => prompts[name] });
}
}
const exp = name => {
utils.defineExport(Enquirer, name, () => Enquirer.types[name]);
};
exp('ArrayPrompt');
exp('AuthPrompt');
exp('BooleanPrompt');
exp('NumberPrompt');
exp('StringPrompt');
module.exports = Enquirer;
/***/ }),
/***/ 94907:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
const isTerm = process.env.TERM_PROGRAM === 'Apple_Terminal';
const colors = __webpack_require__(53692);
const utils = __webpack_require__(83546);
const ansi = module.exports = exports;
const ESC = '\u001b[';
const BEL = '\u0007';
let hidden = false;
const code = ansi.code = {
bell: BEL,
beep: BEL,
beginning: `${ESC}G`,
down: `${ESC}J`,
esc: ESC,
getPosition: `${ESC}6n`,
hide: `${ESC}?25l`,
line: `${ESC}2K`,
lineEnd: `${ESC}K`,
lineStart: `${ESC}1K`,
restorePosition: ESC + (isTerm ? '8' : 'u'),
savePosition: ESC + (isTerm ? '7' : 's'),
screen: `${ESC}2J`,
show: `${ESC}?25h`,
up: `${ESC}1J`
};
const cursor = ansi.cursor = {
get hidden() {
return hidden;
},
hide() {
hidden = true;
return code.hide;
},
show() {
hidden = false;
return code.show;
},
forward: (count = 1) => `${ESC}${count}C`,
backward: (count = 1) => `${ESC}${count}D`,
nextLine: (count = 1) => `${ESC}E`.repeat(count),
prevLine: (count = 1) => `${ESC}F`.repeat(count),
up: (count = 1) => count ? `${ESC}${count}A` : '',
down: (count = 1) => count ? `${ESC}${count}B` : '',
right: (count = 1) => count ? `${ESC}${count}C` : '',
left: (count = 1) => count ? `${ESC}${count}D` : '',
to(x, y) {
return y ? `${ESC}${y + 1};${x + 1}H` : `${ESC}${x + 1}G`;
},
move(x = 0, y = 0) {
let res = '';
res += (x < 0) ? cursor.left(-x) : (x > 0) ? cursor.right(x) : '';
res += (y < 0) ? cursor.up(-y) : (y > 0) ? cursor.down(y) : '';
return res;
},
restore(state = {}) {
let { after, cursor, initial, input, prompt, size, value } = state;
initial = utils.isPrimitive(initial) ? String(initial) : '';
input = utils.isPrimitive(input) ? String(input) : '';
value = utils.isPrimitive(value) ? String(value) : '';
if (size) {
let codes = ansi.cursor.up(size) + ansi.cursor.to(prompt.length);
let diff = input.length - cursor;
if (diff > 0) {
codes += ansi.cursor.left(diff);
}
return codes;
}
if (value || after) {
let pos = (!input && !!initial) ? -initial.length : -input.length + cursor;
if (after) pos -= after.length;
if (input === '' && initial && !prompt.includes(initial)) {
pos += initial.length;
}
return ansi.cursor.move(pos);
}
}
};
const erase = ansi.erase = {
screen: code.screen,
up: code.up,
down: code.down,
line: code.line,
lineEnd: code.lineEnd,
lineStart: code.lineStart,
lines(n) {
let str = '';
for (let i = 0; i < n; i++) {
str += ansi.erase.line + (i < n - 1 ? ansi.cursor.up(1) : '');
}
if (n) str += ansi.code.beginning;
return str;
}
};
ansi.clear = (input = '', columns = process.stdout.columns) => {
if (!columns) return erase.line + cursor.to(0);
let width = str => [...colors.unstyle(str)].length;
let lines = input.split(/\r?\n/);
let rows = 0;
for (let line of lines) {
rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / columns);
}
return (erase.line + cursor.prevLine()).repeat(rows - 1) + erase.line + cursor.to(0);
};
/***/ }),
/***/ 64726:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/**
* Actions are mappings from keypress event names to method names
* in the prompts.
*/
exports.ctrl = {
a: 'first',
b: 'backward',
c: 'cancel',
d: 'deleteForward',
e: 'last',
f: 'forward',
g: 'reset',
i: 'tab',
k: 'cutForward',
l: 'reset',
n: 'newItem',
m: 'cancel',
j: 'submit',
p: 'search',
r: 'remove',
s: 'save',
u: 'undo',
w: 'cutLeft',
x: 'toggleCursor',
v: 'paste'
};
exports.shift = {
up: 'shiftUp',
down: 'shiftDown',
left: 'shiftLeft',
right: 'shiftRight',
tab: 'prev'
};
exports.fn = {
up: 'pageUp',
down: 'pageDown',
left: 'pageLeft',
right: 'pageRight',
delete: 'deleteForward'
};
// <alt> on Windows
exports.option = {
b: 'backward',
f: 'forward',
d: 'cutRight',
left: 'cutLeft',
up: 'altUp',
down: 'altDown'
};
exports.keys = {
pageup: 'pageUp', // <fn>+<up> (mac), <Page Up> (windows)
pagedown: 'pageDown', // <fn>+<down> (mac), <Page Down> (windows)
home: 'home', // <fn>+<left> (mac), <home> (windows)
end: 'end', // <fn>+<right> (mac), <end> (windows)
cancel: 'cancel',
delete: 'deleteForward',
backspace: 'delete',
down: 'down',
enter: 'submit',
escape: 'cancel',
left: 'left',
space: 'space',
number: 'number',
return: 'submit',
right: 'right',
tab: 'next',
up: 'up'
};
/***/ }),
/***/ 73736:
/***/ ((module) => {
"use strict";
const unique = arr => arr.filter((v, i) => arr.lastIndexOf(v) === i);
const compact = arr => unique(arr).filter(Boolean);
module.exports = (action, data = {}, value = '') => {
let { past = [], present = '' } = data;
let rest, prev;
switch (action) {
case 'prev':
case 'undo':
rest = past.slice(0, past.length - 1);
prev = past[past.length - 1] || '';
return {
past: compact([value, ...rest]),
present: prev
};
case 'next':
case 'redo':
rest = past.slice(1);
prev = past[0] || '';
return {
past: compact([...rest, value]),
present: prev
};
case 'save':
return {
past: compact([...past, value]),
present: ''
};
case 'remove':
prev = compact(past.filter(v => v !== value));
present = '';
if (prev.length) {
present = prev.pop();
}
return {
past: prev,
present
};
default: {
throw new Error(`Invalid action: "${action}"`);
}
}
};
/***/ }),
/***/ 27189:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const colors = __webpack_require__(53692);
const clean = (str = '') => {
return typeof str === 'string' ? str.replace(/^['"]|['"]$/g, '') : '';
};
/**
* This file contains the interpolation and rendering logic for
* the Snippet prompt.
*/
class Item {
constructor(token) {
this.name = token.key;
this.field = token.field || {};
this.value = clean(token.initial || this.field.initial || '');
this.message = token.message || this.name;
this.cursor = 0;
this.input = '';
this.lines = [];
}
}
const tokenize = async(options = {}, defaults = {}, fn = token => token) => {
let unique = new Set();
let fields = options.fields || [];
let input = options.template;
let tabstops = [];
let items = [];
let keys = [];
let line = 1;
if (typeof input === 'function') {
input = await input();
}
let i = -1;
let next = () => input[++i];
let peek = () => input[i + 1];
let push = token => {
token.line = line;
tabstops.push(token);
};
push({ type: 'bos', value: '' });
while (i < input.length - 1) {
let value = next();
if (/^[^\S\n ]$/.test(value)) {
push({ type: 'text', value });
continue;
}
if (value === '\n') {
push({ type: 'newline', value });
line++;
continue;
}
if (value === '\\') {
value += next();
push({ type: 'text', value });
continue;
}
if ((value === '$' || value === '#' || value === '{') && peek() === '{') {
let n = next();
value += n;
let token = { type: 'template', open: value, inner: '', close: '', value };
let ch;
while ((ch = next())) {
if (ch === '}') {
if (peek() === '}') ch += next();
token.value += ch;
token.close = ch;
break;
}
if (ch === ':') {
token.initial = '';
token.key = token.inner;
} else if (token.initial !== void 0) {
token.initial += ch;
}
token.value += ch;
token.inner += ch;
}
token.template = token.open + (token.initial || token.inner) + token.close;
token.key = token.key || token.inner;
if (defaults.hasOwnProperty(token.key)) {
token.initial = defaults[token.key];
}
token = fn(token);
push(token);
keys.push(token.key);
unique.add(token.key);
let item = items.find(item => item.name === token.key);
token.field = fields.find(ch => ch.name === token.key);
if (!item) {
item = new Item(token);
items.push(item);
}
item.lines.push(token.line - 1);
continue;
}
let last = tabstops[tabstops.length - 1];
if (last.type === 'text' && last.line === line) {
last.value += value;
} else {
push({ type: 'text', value });
}
}
push({ type: 'eos', value: '' });
return { input, tabstops, unique, keys, items };
};
module.exports = async prompt => {
let options = prompt.options;
let required = new Set(options.required === true ? [] : (options.required || []));
let defaults = { ...options.values, ...options.initial };
let { tabstops, items, keys } = await tokenize(options, defaults);
let result = createFn('result', prompt, options);
let format = createFn('format', prompt, options);
let isValid = createFn('validate', prompt, options, true);
let isVal = prompt.isValue.bind(prompt);
return async(state = {}, submitted = false) => {
let index = 0;
state.required = required;
state.items = items;
state.keys = keys;
state.output = '';
let validate = async(value, state, item, index) => {
let error = await isValid(value, state, item, index);
if (error === false) {
return 'Invalid field ' + item.name;
}
return error;
};
for (let token of tabstops) {
let value = token.value;
let key = token.key;
if (token.type !== 'template') {
if (value) state.output += value;
continue;
}
if (token.type === 'template') {
let item = items.find(ch => ch.name === key);
if (options.required === true) {
state.required.add(item.name);
}
let val = [item.input, state.values[item.value], item.value, value].find(isVal);
let field = item.field || {};
let message = field.message || token.inner;
if (submitted) {
let error = await validate(state.values[key], state, item, index);
if ((error && typeof error === 'string') || error === false) {
state.invalid.set(key, error);
continue;
}
state.invalid.delete(key);
let res = await result(state.values[key], state, item, index);
state.output += colors.unstyle(res);
continue;
}
item.placeholder = false;
let before = value;
value = await format(value, state, item, index);
if (val !== value) {
state.values[key] = val;
value = prompt.styles.typing(val);
state.missing.delete(message);
} else {
state.values[key] = void 0;
val = `<${message}>`;
value = prompt.styles.primary(val);
item.placeholder = true;
if (state.required.has(key)) {
state.missing.add(message);
}
}
if (state.missing.has(message) && state.validating) {
value = prompt.styles.warning(val);
}
if (state.invalid.has(key) && state.validating) {
value = prompt.styles.danger(val);
}
if (index === state.index) {
if (before !== value) {
value = prompt.styles.underline(value);
} else {
value = prompt.styles.heading(colors.unstyle(value));
}
}
index++;
}
if (value) {
state.output += value;
}
}
let lines = state.output.split('\n').map(l => ' ' + l);
let len = items.length;
let done = 0;
for (let item of items) {
if (state.invalid.has(item.name)) {
item.lines.forEach(i => {
if (lines[i][0] !== ' ') return;
lines[i] = state.styles.danger(state.symbols.bullet) + lines[i].slice(1);
});
}
if (prompt.isValue(state.values[item.name])) {
done++;
}
}
state.completed = ((done / len) * 100).toFixed(0);
state.output = lines.join('\n');
return state.output;
};
};
function createFn(prop, prompt, options, fallback) {
return (value, state, item, index) => {
if (typeof item.field[prop] === 'function') {
return item.field[prop].call(prompt, value, state, item, index);
}
return [fallback, value].find(v => prompt.isValue(v));
};
}
/***/ }),
/***/ 28914:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const readline = __webpack_require__(14521);
const combos = __webpack_require__(64726);
/* eslint-disable no-control-regex */
const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
const fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
const keyName = {
/* xterm/gnome ESC O letter */
'OP': 'f1',
'OQ': 'f2',
'OR': 'f3',
'OS': 'f4',
/* xterm/rxvt ESC [ number ~ */
'[11~': 'f1',
'[12~': 'f2',
'[13~': 'f3',
'[14~': 'f4',
/* from Cygwin and used in libuv */
'[[A': 'f1',
'[[B': 'f2',
'[[C': 'f3',
'[[D': 'f4',
'[[E': 'f5',
/* common */
'[15~': 'f5',
'[17~': 'f6',
'[18~': 'f7',
'[19~': 'f8',
'[20~': 'f9',
'[21~': 'f10',
'[23~': 'f11',
'[24~': 'f12',
/* xterm ESC [ letter */
'[A': 'up',
'[B': 'down',
'[C': 'right',
'[D': 'left',
'[E': 'clear',
'[F': 'end',
'[H': 'home',
/* xterm/gnome ESC O letter */
'OA': 'up',
'OB': 'down',
'OC': 'right',
'OD': 'left',
'OE': 'clear',
'OF': 'end',
'OH': 'home',
/* xterm/rxvt ESC [ number ~ */
'[1~': 'home',
'[2~': 'insert',
'[3~': 'delete',
'[4~': 'end',
'[5~': 'pageup',
'[6~': 'pagedown',
/* putty */
'[[5~': 'pageup',
'[[6~': 'pagedown',
/* rxvt */
'[7~': 'home',
'[8~': 'end',
/* rxvt keys with modifiers */
'[a': 'up',
'[b': 'down',
'[c': 'right',
'[d': 'left',
'[e': 'clear',
'[2$': 'insert',
'[3$': 'delete',
'[5$': 'pageup',
'[6$': 'pagedown',
'[7$': 'home',
'[8$': 'end',
'Oa': 'up',
'Ob': 'down',
'Oc': 'right',
'Od': 'left',
'Oe': 'clear',
'[2^': 'insert',
'[3^': 'delete',
'[5^': 'pageup',
'[6^': 'pagedown',
'[7^': 'home',
'[8^': 'end',
/* misc. */
'[Z': 'tab',
}
function isShiftKey(code) {
return ['[a', '[b', '[c', '[d', '[e', '[2$', '[3$', '[5$', '[6$', '[7$', '[8$', '[Z'].includes(code)
}
function isCtrlKey(code) {
return [ 'Oa', 'Ob', 'Oc', 'Od', 'Oe', '[2^', '[3^', '[5^', '[6^', '[7^', '[8^'].includes(code)
}
const keypress = (s = '', event = {}) => {
let parts;
let key = {
name: event.name,
ctrl: false,
meta: false,
shift: false,
option: false,
sequence: s,
raw: s,
...event
};
if (Buffer.isBuffer(s)) {
if (s[0] > 127 && s[1] === void 0) {
s[0] -= 128;
s = '\x1b' + String(s);
} else {
s = String(s);
}
} else if (s !== void 0 && typeof s !== 'string') {
s = String(s);
} else if (!s) {
s = key.sequence || '';
}
key.sequence = key.sequence || s || key.name;
if (s === '\r') {
// carriage return
key.raw = void 0;
key.name = 'return';
} else if (s === '\n') {
// enter, should have been called linefeed
key.name = 'enter';
} else if (s === '\t') {
// tab
key.name = 'tab';
} else if (s === '\b' || s === '\x7f' || s === '\x1b\x7f' || s === '\x1b\b') {
// backspace or ctrl+h
key.name = 'backspace';
key.meta = s.charAt(0) === '\x1b';
} else if (s === '\x1b' || s === '\x1b\x1b') {
// escape key
key.name = 'escape';
key.meta = s.length === 2;
} else if (s === ' ' || s === '\x1b ') {
key.name = 'space';
key.meta = s.length === 2;
} else if (s <= '\x1a') {
// ctrl+letter
key.name = String.fromCharCode(s.charCodeAt(0) + 'a'.charCodeAt(0) - 1);
key.ctrl = true;
} else if (s.length === 1 && s >= '0' && s <= '9') {
// number
key.name = 'number';
} else if (s.length === 1 && s >= 'a' && s <= 'z') {
// lowercase letter
key.name = s;
} else if (s.length === 1 && s >= 'A' && s <= 'Z') {
// shift+letter
key.name = s.toLowerCase();
key.shift = true;
} else if ((parts = metaKeyCodeRe.exec(s))) {
// meta+character key
key.meta = true;
key.shift = /^[A-Z]$/.test(parts[1]);
} else if ((parts = fnKeyRe.exec(s))) {
let segs = [...s];
if (segs[0] === '\u001b' && segs[1] === '\u001b') {
key.option = true;
}
// ansi escape sequence
// reassemble the key code leaving out leading \x1b's,
// the modifier key bitflag and any meaningless "1;" sequence
let code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join('');
let modifier = (parts[3] || parts[5] || 1) - 1;
// Parse the key modifier
key.ctrl = !!(modifier & 4);
key.meta = !!(modifier & 10);
key.shift = !!(modifier & 1);
key.code = code;
key.name = keyName[code];
key.shift = isShiftKey(code) || key.shift;
key.ctrl = isCtrlKey(code) || key.ctrl;
}
return key;
};
keypress.listen = (options = {}, onKeypress) => {
let { stdin } = options;
if (!stdin || (stdin !== process.stdin && !stdin.isTTY)) {
throw new Error('Invalid stream passed');
}
let rl = readline.createInterface({ terminal: true, input: stdin });
readline.emitKeypressEvents(stdin, rl);
let on = (buf, key) => onKeypress(buf, keypress(buf, key), rl);
let isRaw = stdin.isRaw;
if (stdin.isTTY) stdin.setRawMode(true);
stdin.on('keypress', on);
rl.resume();
let off = () => {
if (stdin.isTTY) stdin.setRawMode(isRaw);
stdin.removeListener('keypress', on);
rl.pause();
rl.close();
};
return off;
};
keypress.action = (buf, key, customActions) => {
let obj = { ...combos, ...customActions };
if (key.ctrl) {
key.action = obj.ctrl[key.name];
return key;
}
if (key.option && obj.option) {
key.action = obj.option[key.name];
return key;
}
if (key.shift) {
key.action = obj.shift[key.name];
return key;
}
key.action = obj.keys[key.name];
return key;
};
module.exports = keypress;
/***/ }),
/***/ 12786:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const utils = __webpack_require__(83546);
/**
* Render a placeholder value with cursor and styling based on the
* position of the cursor.
*
* @param {Object} `prompt` Prompt instance.
* @param {String} `input` Input string.
* @param {String} `initial` The initial user-provided value.
* @param {Number} `pos` Current cursor position.
* @param {Boolean} `showCursor` Render a simulated cursor using the inverse primary style.
* @return {String} Returns the styled placeholder string.
* @api public
*/
module.exports = (prompt, options = {}) => {
prompt.cursorHide();
let { input = '', initial = '', pos, showCursor = true, color } = options;
let style = color || prompt.styles.placeholder;
let inverse = utils.inverse(prompt.styles.primary);
let blinker = str => inverse(prompt.styles.black(str));
let output = input;
let char = ' ';
let reverse = blinker(char);
if (prompt.blink && prompt.blink.off === true) {
blinker = str => str;
reverse = '';
}
if (showCursor && pos === 0 && initial === '' && input === '') {
return blinker(char);
}
if (showCursor && pos === 0 && (input === initial || input === '')) {
return blinker(initial[0]) + style(initial.slice(1));
}
initial = utils.isPrimitive(initial) ? `${initial}` : '';
input = utils.isPrimitive(input) ? `${input}` : '';
let placeholder = initial && initial.startsWith(input) && initial !== input;
let cursor = placeholder ? blinker(initial[input.length]) : reverse;
if (pos !== input.length && showCursor === true) {
output = input.slice(0, pos) + blinker(input[pos]) + input.slice(pos + 1);
cursor = '';
}
if (showCursor === false) {
cursor = '';
}
if (placeholder) {
let raw = prompt.styles.unstyle(output + cursor);
return output + cursor + style(initial.slice(raw.length));
}
return output + cursor;
};
/***/ }),
/***/ 232:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Events = __webpack_require__(82361);
const colors = __webpack_require__(53692);
const keypress = __webpack_require__(28914);
const timer = __webpack_require__(33940);
const State = __webpack_require__(36873);
const theme = __webpack_require__(39227);
const utils = __webpack_require__(83546);
const ansi = __webpack_require__(94907);
/**
* Base class for creating a new Prompt.
* @param {Object} `options` Question object.
*/
class Prompt extends Events {
constructor(options = {}) {
super();
this.name = options.name;
this.type = options.type;
this.options = options;
theme(this);
timer(this);
this.state = new State(this);
this.initial = [options.initial, options.default].find(v => v != null);
this.stdout = options.stdout || process.stdout;
this.stdin = options.stdin || process.stdin;
this.scale = options.scale || 1;
this.term = this.options.term || process.env.TERM_PROGRAM;
this.margin = margin(this.options.margin);
this.setMaxListeners(0);
setOptions(this);
}
async keypress(input, event = {}) {
this.keypressed = true;
let key = keypress.action(input, keypress(input, event), this.options.actions);
this.state.keypress = key;
this.emit('keypress', input, key);
this.emit('state', this.state.clone());
let fn = this.options[key.action] || this[key.action] || this.dispatch;
if (typeof fn === 'function') {
return await fn.call(this, input, key);
}
this.alert();
}
alert() {
delete this.state.alert;
if (this.options.show === false) {
this.emit('alert');
} else {
this.stdout.write(ansi.code.beep);
}
}
cursorHide() {
this.stdout.write(ansi.cursor.hide());
utils.onExit(() => this.cursorShow());
}
cursorShow() {
this.stdout.write(ansi.cursor.show());
}
write(str) {
if (!str) return;
if (this.stdout && this.state.show !== false) {
this.stdout.write(str);
}
this.state.buffer += str;
}
clear(lines = 0) {
let buffer = this.state.buffer;
this.state.buffer = '';
if ((!buffer && !lines) || this.options.show === false) return;
this.stdout.write(ansi.cursor.down(lines) + ansi.clear(buffer, this.width));
}
restore() {
if (this.state.closed || this.options.show === false) return;
let { prompt, after, rest } = this.sections();
let { cursor, initial = '', input = '', value = '' } = this;
let size = this.state.size = rest.length;
let state = { after, cursor, initial, input, prompt, size, value };
let codes = ansi.cursor.restore(state);
if (codes) {
this.stdout.write(codes);
}
}
sections() {
let { buffer, input, prompt } = this.state;
prompt = colors.unstyle(prompt);
let buf = colors.unstyle(buffer);
let idx = buf.indexOf(prompt);
let header = buf.slice(0, idx);
let rest = buf.slice(idx);
let lines = rest.split('\n');
let first = lines[0];
let last = lines[lines.length - 1];
let promptLine = prompt + (input ? ' ' + input : '');
let len = promptLine.length;
let after = len < first.length ? first.slice(len + 1) : '';
return { header, prompt: first, after, rest: lines.slice(1), last };
}
async submit() {
this.state.submitted = true;
this.state.validating = true;
// this will only be called when the prompt is directly submitted
// without initializing, i.e. when the prompt is skipped, etc. Otherwize,
// "options.onSubmit" is will be handled by the "initialize()" method.
if (this.options.onSubmit) {
await this.options.onSubmit.call(this, this.name, this.value, this);
}
let result = this.state.error || await this.validate(this.value, this.state);
if (result !== true) {
let error = '\n' + this.symbols.pointer + ' ';
if (typeof result === 'string') {
error += result.trim();
} else {
error += 'Invalid input';
}
this.state.error = '\n' + this.styles.danger(error);
this.state.submitted = false;
await this.render();
await this.alert();
this.state.validating = false;
this.state.error = void 0;
return;
}
this.state.validating = false;
await this.render();
await this.close();
this.value = await this.result(this.value);
this.emit('submit', this.value);
}
async cancel(err) {
this.state.cancelled = this.state.submitted = true;
await this.render();
await this.close();
if (typeof this.options.onCancel === 'function') {
await this.options.onCancel.call(this, this.name, this.value, this);
}
this.emit('cancel', await this.error(err));
}
async close() {
this.state.closed = true;
try {
let sections = this.sections();
let lines = Math.ceil(sections.prompt.length / this.width);
if (sections.rest) {
this.write(ansi.cursor.down(sections.rest.length));
}
this.write('\n'.repeat(lines));
} catch (err) { /* do nothing */ }
this.emit('close');
}
start() {
if (!this.stop && this.options.show !== false) {
this.stop = keypress.listen(this, this.keypress.bind(this));
this.once('close', this.stop);
}
}
async skip() {
this.skipped = this.options.skip === true;
if (typeof this.options.skip === 'function') {
this.skipped = await this.options.skip.call(this, this.name, this.value);
}
return this.skipped;
}
async initialize() {
let { format, options, result } = this;
this.format = () => format.call(this, this.value);
this.result = () => result.call(this, this.value);
if (typeof options.initial === 'function') {
this.initial = await options.initial.call(this, this);
}
if (typeof options.onRun === 'function') {
await options.onRun.call(this, this);
}
// if "options.onSubmit" is defined, we wrap the "submit" method to guarantee
// that "onSubmit" will always called first thing inside the submit
// method, regardless of how it's handled in inheriting prompts.
if (typeof options.onSubmit === 'function') {
let onSubmit = options.onSubmit.bind(this);
let submit = this.submit.bind(this);
delete this.options.onSubmit;
this.submit = async() => {
await onSubmit(this.name, this.value, this);
return submit();
};
}
await this.start();
await this.render();
}
render() {
throw new Error('expected prompt to have a custom render method');
}
run() {
return new Promise(async(resolve, reject) => {
this.once('submit', resolve);
this.once('cancel', reject);
if (await this.skip()) {
this.render = () => {};
return this.submit();
}
await this.initialize();
this.emit('run');
});
}
async element(name, choice, i) {
let { options, state, symbols, timers } = this;
let timer = timers && timers[name];
state.timer = timer;
let value = options[name] || state[name] || symbols[name];
let val = choice && choice[name] != null ? choice[name] : await value;
if (val === '') return val;
let res = await this.resolve(val, state, choice, i);
if (!res && choice && choice[name]) {
return this.resolve(value, state, choice, i);
}
return res;
}
async prefix() {
let element = await this.element('prefix') || this.symbols;
let timer = this.timers && this.timers.prefix;
let state = this.state;
state.timer = timer;
if (utils.isObject(element)) element = element[state.status] || element.pending;
if (!utils.hasColor(element)) {
let style = this.styles[state.status] || this.styles.pending;
return style(element);
}
return element;
}
async message() {
let message = await this.element('message');
if (!utils.hasColor(message)) {
return this.styles.strong(message);
}
return message;
}
async separator() {
let element = await this.element('separator') || this.symbols;
let timer = this.timers && this.timers.separator;
let state = this.state;
state.timer = timer;
let value = element[state.status] || element.pending || state.separator;
let ele = await this.resolve(value, state);
if (utils.isObject(ele)) ele = ele[state.status] || ele.pending;
if (!utils.hasColor(ele)) {
return this.styles.muted(ele);
}
return ele;
}
async pointer(choice, i) {
let val = await this.element('pointer', choice, i);
if (typeof val === 'string' && utils.hasColor(val)) {
return val;
}
if (val) {
let styles = this.styles;
let focused = this.index === i;
let style = focused ? styles.primary : val => val;
let ele = await this.resolve(val[focused ? 'on' : 'off'] || val, this.state);
let styled = !utils.hasColor(ele) ? style(ele) : ele;
return focused ? styled : ' '.repeat(ele.length);
}
}
async indicator(choice, i) {
let val = await this.element('indicator', choice, i);
if (typeof val === 'string' && utils.hasColor(val)) {
return val;
}
if (val) {
let styles = this.styles;
let enabled = choice.enabled === true;
let style = enabled ? styles.success : styles.dark;
let ele = val[enabled ? 'on' : 'off'] || val;
return !utils.hasColor(ele) ? style(ele) : ele;
}
return '';
}
body() {
return null;
}
footer() {
if (this.state.status === 'pending') {
return this.element('footer');
}
}
header() {
if (this.state.status === 'pending') {
return this.element('header');
}
}
async hint() {
if (this.state.status === 'pending' && !this.isValue(this.state.input)) {
let hint = await this.element('hint');
if (!utils.hasColor(hint)) {
return this.styles.muted(hint);
}
return hint;
}
}
error(err) {
return !this.state.submitted ? (err || this.state.error) : '';
}
format(value) {
return value;
}
result(value) {
return value;
}
validate(value) {
if (this.options.required === true) {
return this.isValue(value);
}
return true;
}
isValue(value) {
return value != null && value !== '';
}
resolve(value, ...args) {
return utils.resolve(this, value, ...args);
}
get base() {
return Prompt.prototype;
}
get style() {
return this.styles[this.state.status];
}
get height() {
return this.options.rows || utils.height(this.stdout, 25);
}
get width() {
return this.options.columns || utils.width(this.stdout, 80);
}
get size() {
return { width: this.width, height: this.height };
}
set cursor(value) {
this.state.cursor = value;
}
get cursor() {
return this.state.cursor;
}
set input(value) {
this.state.input = value;
}
get input() {
return this.state.input;
}
set value(value) {
this.state.value = value;
}
get value() {
let { input, value } = this.state;
let result = [value, input].find(this.isValue.bind(this));
return this.isValue(result) ? result : this.initial;
}
static get prompt() {
return options => new this(options).run();
}
}
function setOptions(prompt) {
let isValidKey = key => {
return prompt[key] === void 0 || typeof prompt[key] === 'function';
};
let ignore = [
'actions',
'choices',
'initial',
'margin',
'roles',
'styles',
'symbols',
'theme',
'timers',
'value'
];
let ignoreFn = [
'body',
'footer',
'error',
'header',
'hint',
'indicator',
'message',
'prefix',
'separator',
'skip'
];
for (let key of Object.keys(prompt.options)) {
if (ignore.includes(key)) continue;
if (/^on[A-Z]/.test(key)) continue;
let option = prompt.options[key];
if (typeof option === 'function' && isValidKey(key)) {
if (!ignoreFn.includes(key)) {
prompt[key] = option.bind(prompt);
}
} else if (typeof prompt[key] !== 'function') {
prompt[key] = option;
}
}
}
function margin(value) {
if (typeof value === 'number') {
value = [value, value, value, value];
}
let arr = [].concat(value || []);
let pad = i => i % 2 === 0 ? '\n' : ' ';
let res = [];
for (let i = 0; i < 4; i++) {
let char = pad(i);
if (arr[i]) {
res.push(char.repeat(arr[i]));
} else {
res.push('');
}
}
return res;
}
module.exports = Prompt;
/***/ }),
/***/ 89317:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Select = __webpack_require__(13466);
const highlight = (input, color) => {
let val = input.toLowerCase();
return str => {
let s = str.toLowerCase();
let i = s.indexOf(val);
let colored = color(str.slice(i, i + val.length));
return i >= 0 ? str.slice(0, i) + colored + str.slice(i + val.length) : str;
};
};
class AutoComplete extends Select {
constructor(options) {
super(options);
this.cursorShow();
}
moveCursor(n) {
this.state.cursor += n;
}
dispatch(ch) {
return this.append(ch);
}
space(ch) {
return this.options.multiple ? super.space(ch) : this.append(ch);
}
append(ch) {
let { cursor, input } = this.state;
this.input = input.slice(0, cursor) + ch + input.slice(cursor);
this.moveCursor(1);
return this.complete();
}
delete() {
let { cursor, input } = this.state;
if (!input) return this.alert();
this.input = input.slice(0, cursor - 1) + input.slice(cursor);
this.moveCursor(-1);
return this.complete();
}
deleteForward() {
let { cursor, input } = this.state;
if (input[cursor] === void 0) return this.alert();
this.input = `${input}`.slice(0, cursor) + `${input}`.slice(cursor + 1);
return this.complete();
}
number(ch) {
return this.append(ch);
}
async complete() {
this.completing = true;
this.choices = await this.suggest(this.input, this.state._choices);
this.state.limit = void 0; // allow getter/setter to reset limit
this.index = Math.min(Math.max(this.visible.length - 1, 0), this.index);
await this.render();
this.completing = false;
}
suggest(input = this.input, choices = this.state._choices) {
if (typeof this.options.suggest === 'function') {
return this.options.suggest.call(this, input, choices);
}
let str = input.toLowerCase();
return choices.filter(ch => ch.message.toLowerCase().includes(str));
}
pointer() {
return '';
}
format() {
if (!this.focused) return this.input;
if (this.options.multiple && this.state.submitted) {
return this.selected.map(ch => this.styles.primary(ch.message)).join(', ');
}
if (this.state.submitted) {
let value = this.value = this.input = this.focused.value;
return this.styles.primary(value);
}
return this.input;
}
async render() {
if (this.state.status !== 'pending') return super.render();
let style = this.options.highlight
? this.options.highlight.bind(this)
: this.styles.placeholder;
let color = highlight(this.input, style);
let choices = this.choices;
this.choices = choices.map(ch => ({ ...ch, message: color(ch.message) }));
await super.render();
this.choices = choices;
}
submit() {
if (this.options.multiple) {
this.value = this.selected.map(ch => ch.name);
}
return super.submit();
}
}
module.exports = AutoComplete;
/***/ }),
/***/ 7186:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const AuthPrompt = __webpack_require__(66926);
function defaultAuthenticate(value, state) {
if (value.username === this.options.username && value.password === this.options.password) {
return true;
}
return false;
}
const factory = (authenticate = defaultAuthenticate) => {
const choices = [
{ name: 'username', message: 'username' },
{
name: 'password',
message: 'password',
format(input) {
if (this.options.showPassword) {
return input;
}
let color = this.state.submitted ? this.styles.primary : this.styles.muted;
return color(this.symbols.asterisk.repeat(input.length));
}
}
];
class BasicAuthPrompt extends AuthPrompt.create(authenticate) {
constructor(options) {
super({ ...options, choices });
}
static create(authenticate) {
return factory(authenticate);
}
}
return BasicAuthPrompt;
};
module.exports = factory();
/***/ }),
/***/ 31291:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const BooleanPrompt = __webpack_require__(23838);
class ConfirmPrompt extends BooleanPrompt {
constructor(options) {
super(options);
this.default = this.options.default || (this.initial ? '(Y/n)' : '(y/N)');
}
}
module.exports = ConfirmPrompt;
/***/ }),
/***/ 50848:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Select = __webpack_require__(13466);
const Form = __webpack_require__(21826);
const form = Form.prototype;
class Editable extends Select {
constructor(options) {
super({ ...options, multiple: true });
this.align = [this.options.align, 'left'].find(v => v != null);
this.emptyError = '';
this.values = {};
}
dispatch(char, key) {
let choice = this.focused;
let parent = choice.parent || {};
if (!choice.editable && !parent.editable) {
if (char === 'a' || char === 'i') return super[char]();
}
return form.dispatch.call(this, char, key);
}
append(char, key) {
return form.append.call(this, char, key);
}
delete(char, key) {
return form.delete.call(this, char, key);
}
space(char) {
return this.focused.editable ? this.append(char) : super.space();
}
number(char) {
return this.focused.editable ? this.append(char) : super.number(char);
}
next() {
return this.focused.editable ? form.next.call(this) : super.next();
}
prev() {
return this.focused.editable ? form.prev.call(this) : super.prev();
}
async indicator(choice, i) {
let symbol = choice.indicator || '';
let value = choice.editable ? symbol : super.indicator(choice, i);
return await this.resolve(value, this.state, choice, i) || '';
}
indent(choice) {
return choice.role === 'heading' ? '' : (choice.editable ? ' ' : ' ');
}
async renderChoice(choice, i) {
choice.indent = '';
if (choice.editable) return form.renderChoice.call(this, choice, i);
return super.renderChoice(choice, i);
}
error() {
return '';
}
footer() {
return this.state.error;
}
async validate() {
let result = true;
for (let choice of this.choices) {
if (typeof choice.validate !== 'function') {
continue;
}
if (choice.role === 'heading') {
continue;
}
let val = choice.parent ? this.value[choice.parent.name] : this.value;
if (choice.editable) {
val = choice.value === choice.name ? choice.initial || '' : choice.value;
} else if (!this.isDisabled(choice)) {
val = choice.enabled === true;
}
result = await choice.validate(val, this.state);
if (result !== true) {
break;
}
}
if (result !== true) {
this.state.error = typeof result === 'string' ? result : 'Invalid Input';
}
return result;
}
submit() {
if (this.focused.newChoice === true) return super.submit();
if (this.choices.some(ch => ch.newChoice)) {
return this.alert();
}
this.value = {};
for (let choice of this.choices) {
let val = choice.parent ? this.value[choice.parent.name] : this.value;
if (choice.role === 'heading') {
this.value[choice.name] = {};
continue;
}
if (choice.editable) {
val[choice.name] = choice.value === choice.name
? (choice.initial || '')
: choice.value;
} else if (!this.isDisabled(choice)) {
val[choice.name] = choice.enabled === true;
}
}
return this.base.submit.call(this);
}
}
module.exports = Editable;
/***/ }),
/***/ 21826:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const colors = __webpack_require__(53692);
const SelectPrompt = __webpack_require__(13466);
const placeholder = __webpack_require__(12786);
class FormPrompt extends SelectPrompt {
constructor(options) {
super({ ...options, multiple: true });
this.type = 'form';
this.initial = this.options.initial;
this.align = [this.options.align, 'right'].find(v => v != null);
this.emptyError = '';
this.values = {};
}
async reset(first) {
await super.reset();
if (first === true) this._index = this.index;
this.index = this._index;
this.values = {};
this.choices.forEach(choice => choice.reset && choice.reset());
return this.render();
}
dispatch(char) {
return !!char && this.append(char);
}
append(char) {
let choice = this.focused;
if (!choice) return this.alert();
let { cursor, input } = choice;
choice.value = choice.input = input.slice(0, cursor) + char + input.slice(cursor);
choice.cursor++;
return this.render();
}
delete() {
let choice = this.focused;
if (!choice || choice.cursor <= 0) return this.alert();
let { cursor, input } = choice;
choice.value = choice.input = input.slice(0, cursor - 1) + input.slice(cursor);
choice.cursor--;
return this.render();
}
deleteForward() {
let choice = this.focused;
if (!choice) return this.alert();
let { cursor, input } = choice;
if (input[cursor] === void 0) return this.alert();
let str = `${input}`.slice(0, cursor) + `${input}`.slice(cursor + 1);
choice.value = choice.input = str;
return this.render();
}
right() {
let choice = this.focused;
if (!choice) return this.alert();
if (choice.cursor >= choice.input.length) return this.alert();
choice.cursor++;
return this.render();
}
left() {
let choice = this.focused;
if (!choice) return this.alert();
if (choice.cursor <= 0) return this.alert();
choice.cursor--;
return this.render();
}
space(ch, key) {
return this.dispatch(ch, key);
}
number(ch, key) {
return this.dispatch(ch, key);
}
next() {
let ch = this.focused;
if (!ch) return this.alert();
let { initial, input } = ch;
if (initial && initial.startsWith(input) && input !== initial) {
ch.value = ch.input = initial;
ch.cursor = ch.value.length;
return this.render();
}
return super.next();
}
prev() {
let ch = this.focused;
if (!ch) return this.alert();
if (ch.cursor === 0) return super.prev();
ch.value = ch.input = '';
ch.cursor = 0;
return this.render();
}
separator() {
return '';
}
format(value) {
return !this.state.submitted ? super.format(value) : '';
}
pointer() {
return '';
}
indicator(choice) {
return choice.input ? '⦿' : '⊙';
}
async choiceSeparator(choice, i) {
let sep = await this.resolve(choice.separator, this.state, choice, i) || ':';
return sep ? ' ' + this.styles.disabled(sep) : '';
}
async renderChoice(choice, i) {
await this.onChoice(choice, i);
let { state, styles } = this;
let { cursor, initial = '', name, hint, input = '' } = choice;
let { muted, submitted, primary, danger } = styles;
let help = hint;
let focused = this.index === i;
let validate = choice.validate || (() => true);
let sep = await this.choiceSeparator(choice, i);
let msg = choice.message;
if (this.align === 'right') msg = msg.padStart(this.longest + 1, ' ');
if (this.align === 'left') msg = msg.padEnd(this.longest + 1, ' ');
// re-populate the form values (answers) object
let value = this.values[name] = (input || initial);
let color = input ? 'success' : 'dark';
if ((await validate.call(choice, value, this.state)) !== true) {
color = 'danger';
}
let style = styles[color];
let indicator = style(await this.indicator(choice, i)) + (choice.pad || '');
let indent = this.indent(choice);
let line = () => [indent, indicator, msg + sep, input, help].filter(Boolean).join(' ');
if (state.submitted) {
msg = colors.unstyle(msg);
input = submitted(input);
help = '';
return line();
}
if (choice.format) {
input = await choice.format.call(this, input, choice, i);
} else {
let color = this.styles.muted;
let options = { input, initial, pos: cursor, showCursor: focused, color };
input = placeholder(this, options);
}
if (!this.isValue(input)) {
input = this.styles.muted(this.symbols.ellipsis);
}
if (choice.result) {
this.values[name] = await choice.result.call(this, value, choice, i);
}
if (focused) {
msg = primary(msg);
}
if (choice.error) {
input += (input ? ' ' : '') + danger(choice.error.trim());
} else if (choice.hint) {
input += (input ? ' ' : '') + muted(choice.hint.trim());
}
return line();
}
async submit() {
this.value = this.values;
return super.base.submit.call(this);
}
}
module.exports = FormPrompt;
/***/ }),
/***/ 29594:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
const utils = __webpack_require__(83546);
const define = (key, fn) => {
utils.defineExport(exports, key, fn);
utils.defineExport(exports, key.toLowerCase(), fn);
};
define('AutoComplete', () => __webpack_require__(89317));
define('BasicAuth', () => __webpack_require__(7186));
define('Confirm', () => __webpack_require__(31291));
define('Editable', () => __webpack_require__(50848));
define('Form', () => __webpack_require__(21826));
define('Input', () => __webpack_require__(66719));
define('Invisible', () => __webpack_require__(99822));
define('List', () => __webpack_require__(16795));
define('MultiSelect', () => __webpack_require__(91056));
define('Numeral', () => __webpack_require__(17403));
define('Password', () => __webpack_require__(46847));
define('Scale', () => __webpack_require__(17813));
define('Select', () => __webpack_require__(13466));
define('Snippet', () => __webpack_require__(19451));
define('Sort', () => __webpack_require__(7144));
define('Survey', () => __webpack_require__(83755));
define('Text', () => __webpack_require__(5781));
define('Toggle', () => __webpack_require__(10653));
define('Quiz', () => __webpack_require__(92249));
/***/ }),
/***/ 66719:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Prompt = __webpack_require__(43391);
const completer = __webpack_require__(73736);
class Input extends Prompt {
constructor(options) {
super(options);
let history = this.options.history;
if (history && history.store) {
let initial = history.values || this.initial;
this.autosave = !!history.autosave;
this.store = history.store;
this.data = this.store.get('values') || { past: [], present: initial };
this.initial = this.data.present || this.data.past[this.data.past.length - 1];
}
}
completion(action) {
if (!this.store) return this.alert();
this.data = completer(action, this.data, this.input);
if (!this.data.present) return this.alert();
this.input = this.data.present;
this.cursor = this.input.length;
return this.render();
}
altUp() {
return this.completion('prev');
}
altDown() {
return this.completion('next');
}
prev() {
this.save();
return super.prev();
}
save() {
if (!this.store) return;
this.data = completer('save', this.data, this.input);
this.store.set('values', this.data);
}
submit() {
if (this.store && this.autosave === true) {
this.save();
}
return super.submit();
}
}
module.exports = Input;
/***/ }),
/***/ 99822:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const StringPrompt = __webpack_require__(43391);
class InvisiblePrompt extends StringPrompt {
format() {
return '';
}
}
module.exports = InvisiblePrompt;
/***/ }),
/***/ 16795:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const StringPrompt = __webpack_require__(43391);
class ListPrompt extends StringPrompt {
constructor(options = {}) {
super(options);
this.sep = this.options.separator || /, */;
this.initial = options.initial || '';
}
split(input = this.value) {
return input ? String(input).split(this.sep) : [];
}
format() {
let style = this.state.submitted ? this.styles.primary : val => val;
return this.list.map(style).join(', ');
}
async submit(value) {
let result = this.state.error || await this.validate(this.list, this.state);
if (result !== true) {
this.state.error = result;
return super.submit();
}
this.value = this.list;
return super.submit();
}
get list() {
return this.split();
}
}
module.exports = ListPrompt;
/***/ }),
/***/ 91056:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Select = __webpack_require__(13466);
class MultiSelect extends Select {
constructor(options) {
super({ ...options, multiple: true });
}
}
module.exports = MultiSelect;
/***/ }),
/***/ 17403:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = __webpack_require__(45376);
/***/ }),
/***/ 46847:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const StringPrompt = __webpack_require__(43391);
class PasswordPrompt extends StringPrompt {
constructor(options) {
super(options);
this.cursorShow();
}
format(input = this.input) {
if (!this.keypressed) return '';
let color = this.state.submitted ? this.styles.primary : this.styles.muted;
return color(this.symbols.asterisk.repeat(input.length));
}
}
module.exports = PasswordPrompt;
/***/ }),
/***/ 92249:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const SelectPrompt = __webpack_require__(13466);
class Quiz extends SelectPrompt {
constructor(options) {
super(options);
if (typeof this.options.correctChoice !== 'number' || this.options.correctChoice < 0) {
throw new Error('Please specify the index of the correct answer from the list of choices');
}
}
async toChoices(value, parent) {
let choices = await super.toChoices(value, parent);
if (choices.length < 2) {
throw new Error('Please give at least two choices to the user');
}
if (this.options.correctChoice > choices.length) {
throw new Error('Please specify the index of the correct answer from the list of choices');
}
return choices;
}
check(state) {
return state.index === this.options.correctChoice;
}
async result(selected) {
return {
selectedAnswer: selected,
correctAnswer: this.options.choices[this.options.correctChoice].value,
correct: await this.check(this.state)
};
}
}
module.exports = Quiz;
/***/ }),
/***/ 17813:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const colors = __webpack_require__(53692);
const ArrayPrompt = __webpack_require__(98575);
const utils = __webpack_require__(83546);
class LikertScale extends ArrayPrompt {
constructor(options = {}) {
super(options);
this.widths = [].concat(options.messageWidth || 50);
this.align = [].concat(options.align || 'left');
this.linebreak = options.linebreak || false;
this.edgeLength = options.edgeLength || 3;
this.newline = options.newline || '\n ';
let start = options.startNumber || 1;
if (typeof this.scale === 'number') {
this.scaleKey = false;
this.scale = Array(this.scale).fill(0).map((v, i) => ({ name: i + start }));
}
}
async reset() {
this.tableized = false;
await super.reset();
return this.render();
}
tableize() {
if (this.tableized === true) return;
this.tableized = true;
let longest = 0;
for (let ch of this.choices) {
longest = Math.max(longest, ch.message.length);
ch.scaleIndex = ch.initial || 2;
ch.scale = [];
for (let i = 0; i < this.scale.length; i++) {
ch.scale.push({ index: i });
}
}
this.widths[0] = Math.min(this.widths[0], longest + 3);
}
async dispatch(s, key) {
if (this.multiple) {
return this[key.name] ? await this[key.name](s, key) : await super.dispatch(s, key);
}
this.alert();
}
heading(msg, item, i) {
return this.styles.strong(msg);
}
separator() {
return this.styles.muted(this.symbols.ellipsis);
}
right() {
let choice = this.focused;
if (choice.scaleIndex >= this.scale.length - 1) return this.alert();
choice.scaleIndex++;
return this.render();
}
left() {
let choice = this.focused;
if (choice.scaleIndex <= 0) return this.alert();
choice.scaleIndex--;
return this.render();
}
indent() {
return '';
}
format() {
if (this.state.submitted) {
let values = this.choices.map(ch => this.styles.info(ch.index));
return values.join(', ');
}
return '';
}
pointer() {
return '';
}
/**
* Render the scale "Key". Something like:
* @return {String}
*/
renderScaleKey() {
if (this.scaleKey === false) return '';
if (this.state.submitted) return '';
let scale = this.scale.map(item => ` ${item.name} - ${item.message}`);
let key = ['', ...scale].map(item => this.styles.muted(item));
return key.join('\n');
}
/**
* Render the heading row for the scale.
* @return {String}
*/
renderScaleHeading(max) {
let keys = this.scale.map(ele => ele.name);
if (typeof this.options.renderScaleHeading === 'function') {
keys = this.options.renderScaleHeading.call(this, max);
}
let diff = this.scaleLength - keys.join('').length;
let spacing = Math.round(diff / (keys.length - 1));
let names = keys.map(key => this.styles.strong(key));
let headings = names.join(' '.repeat(spacing));
let padding = ' '.repeat(this.widths[0]);
return this.margin[3] + padding + this.margin[1] + headings;
}
/**
* Render a scale indicator => ◯ or ◉ by default
*/
scaleIndicator(choice, item, i) {
if (typeof this.options.scaleIndicator === 'function') {
return this.options.scaleIndicator.call(this, choice, item, i);
}
let enabled = choice.scaleIndex === item.index;
if (item.disabled) return this.styles.hint(this.symbols.radio.disabled);
if (enabled) return this.styles.success(this.symbols.radio.on);
return this.symbols.radio.off;
}
/**
* Render the actual scale => ◯────◯────◉────◯────◯
*/
renderScale(choice, i) {
let scale = choice.scale.map(item => this.scaleIndicator(choice, item, i));
let padding = this.term === 'Hyper' ? '' : ' ';
return scale.join(padding + this.symbols.line.repeat(this.edgeLength));
}
/**
* Render a choice, including scale =>
* "The website is easy to navigate. ◯───◯───◉───◯───◯"
*/
async renderChoice(choice, i) {
await this.onChoice(choice, i);
let focused = this.index === i;
let pointer = await this.pointer(choice, i);
let hint = await choice.hint;
if (hint && !utils.hasColor(hint)) {
hint = this.styles.muted(hint);
}
let pad = str => this.margin[3] + str.replace(/\s+$/, '').padEnd(this.widths[0], ' ');
let newline = this.newline;
let ind = this.indent(choice);
let message = await this.resolve(choice.message, this.state, choice, i);
let scale = await this.renderScale(choice, i);
let margin = this.margin[1] + this.margin[3];
this.scaleLength = colors.unstyle(scale).length;
this.widths[0] = Math.min(this.widths[0], this.width - this.scaleLength - margin.length);
let msg = utils.wordWrap(message, { width: this.widths[0], newline });
let lines = msg.split('\n').map(line => pad(line) + this.margin[1]);
if (focused) {
scale = this.styles.info(scale);
lines = lines.map(line => this.styles.info(line));
}
lines[0] += scale;
if (this.linebreak) lines.push('');
return [ind + pointer, lines.join('\n')].filter(Boolean);
}
async renderChoices() {
if (this.state.submitted) return '';
this.tableize();
let choices = this.visible.map(async(ch, i) => await this.renderChoice(ch, i));
let visible = await Promise.all(choices);
let heading = await this.renderScaleHeading();
return this.margin[0] + [heading, ...visible.map(v => v.join(' '))].join('\n');
}
async render() {
let { submitted, size } = this.state;
let prefix = await this.prefix();
let separator = await this.separator();
let message = await this.message();
let prompt = '';
if (this.options.promptLine !== false) {
prompt = [prefix, message, separator, ''].join(' ');
this.state.prompt = prompt;
}
let header = await this.header();
let output = await this.format();
let key = await this.renderScaleKey();
let help = await this.error() || await this.hint();
let body = await this.renderChoices();
let footer = await this.footer();
let err = this.emptyError;
if (output) prompt += output;
if (help && !prompt.includes(help)) prompt += ' ' + help;
if (submitted && !output && !body.trim() && this.multiple && err != null) {
prompt += this.styles.danger(err);
}
this.clear(size);
this.write([header, prompt, key, body, footer].filter(Boolean).join('\n'));
if (!this.state.submitted) {
this.write(this.margin[2]);
}
this.restore();
}
submit() {
this.value = {};
for (let choice of this.choices) {
this.value[choice.name] = choice.scaleIndex;
}
return this.base.submit.call(this);
}
}
module.exports = LikertScale;
/***/ }),
/***/ 13466:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const ArrayPrompt = __webpack_require__(98575);
const utils = __webpack_require__(83546);
class SelectPrompt extends ArrayPrompt {
constructor(options) {
super(options);
this.emptyError = this.options.emptyError || 'No items were selected';
}
async dispatch(s, key) {
if (this.multiple) {
return this[key.name] ? await this[key.name](s, key) : await super.dispatch(s, key);
}
this.alert();
}
separator() {
if (this.options.separator) return super.separator();
let sep = this.styles.muted(this.symbols.ellipsis);
return this.state.submitted ? super.separator() : sep;
}
pointer(choice, i) {
return (!this.multiple || this.options.pointer) ? super.pointer(choice, i) : '';
}
indicator(choice, i) {
return this.multiple ? super.indicator(choice, i) : '';
}
choiceMessage(choice, i) {
let message = this.resolve(choice.message, this.state, choice, i);
if (choice.role === 'heading' && !utils.hasColor(message)) {
message = this.styles.strong(message);
}
return this.resolve(message, this.state, choice, i);
}
choiceSeparator() {
return ':';
}
async renderChoice(choice, i) {
await this.onChoice(choice, i);
let focused = this.index === i;
let pointer = await this.pointer(choice, i);
let check = await this.indicator(choice, i) + (choice.pad || '');
let hint = await this.resolve(choice.hint, this.state, choice, i);
if (hint && !utils.hasColor(hint)) {
hint = this.styles.muted(hint);
}
let ind = this.indent(choice);
let msg = await this.choiceMessage(choice, i);
let line = () => [this.margin[3], ind + pointer + check, msg, this.margin[1], hint].filter(Boolean).join(' ');
if (choice.role === 'heading') {
return line();
}
if (choice.disabled) {
if (!utils.hasColor(msg)) {
msg = this.styles.disabled(msg);
}
return line();
}
if (focused) {
msg = this.styles.em(msg);
}
return line();
}
async renderChoices() {
if (this.state.loading === 'choices') {
return this.styles.warning('Loading choices');
}
if (this.state.submitted) return '';
let choices = this.visible.map(async(ch, i) => await this.renderChoice(ch, i));
let visible = await Promise.all(choices);
if (!visible.length) visible.push(this.styles.danger('No matching choices'));
let result = this.margin[0] + visible.join('\n');
let header;
if (this.options.choicesHeader) {
header = await this.resolve(this.options.choicesHeader, this.state);
}
return [header, result].filter(Boolean).join('\n');
}
format() {
if (!this.state.submitted || this.state.cancelled) return '';
if (Array.isArray(this.selected)) {
return this.selected.map(choice => this.styles.primary(choice.name)).join(', ');
}
return this.styles.primary(this.selected.name);
}
async render() {
let { submitted, size } = this.state;
let prompt = '';
let header = await this.header();
let prefix = await this.prefix();
let separator = await this.separator();
let message = await this.message();
if (this.options.promptLine !== false) {
prompt = [prefix, message, separator, ''].join(' ');
this.state.prompt = prompt;
}
let output = await this.format();
let help = (await this.error()) || (await this.hint());
let body = await this.renderChoices();
let footer = await this.footer();
if (output) prompt += output;
if (help && !prompt.includes(help)) prompt += ' ' + help;
if (submitted && !output && !body.trim() && this.multiple && this.emptyError != null) {
prompt += this.styles.danger(this.emptyError);
}
this.clear(size);
this.write([header, prompt, body, footer].filter(Boolean).join('\n'));
this.write(this.margin[2]);
this.restore();
}
}
module.exports = SelectPrompt;
/***/ }),
/***/ 19451:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const colors = __webpack_require__(53692);
const interpolate = __webpack_require__(27189);
const Prompt = __webpack_require__(232);
class SnippetPrompt extends Prompt {
constructor(options) {
super(options);
this.cursorHide();
this.reset(true);
}
async initialize() {
this.interpolate = await interpolate(this);
await super.initialize();
}
async reset(first) {
this.state.keys = [];
this.state.invalid = new Map();
this.state.missing = new Set();
this.state.completed = 0;
this.state.values = {};
if (first !== true) {
await this.initialize();
await this.render();
}
}
moveCursor(n) {
let item = this.getItem();
this.cursor += n;
item.cursor += n;
}
dispatch(ch, key) {
if (!key.code && !key.ctrl && ch != null && this.getItem()) {
this.append(ch, key);
return;
}
this.alert();
}
append(ch, key) {
let item = this.getItem();
let prefix = item.input.slice(0, this.cursor);
let suffix = item.input.slice(this.cursor);
this.input = item.input = `${prefix}${ch}${suffix}`;
this.moveCursor(1);
this.render();
}
delete() {
let item = this.getItem();
if (this.cursor <= 0 || !item.input) return this.alert();
let suffix = item.input.slice(this.cursor);
let prefix = item.input.slice(0, this.cursor - 1);
this.input = item.input = `${prefix}${suffix}`;
this.moveCursor(-1);
this.render();
}
increment(i) {
return i >= this.state.keys.length - 1 ? 0 : i + 1;
}
decrement(i) {
return i <= 0 ? this.state.keys.length - 1 : i - 1;
}
first() {
this.state.index = 0;
this.render();
}
last() {
this.state.index = this.state.keys.length - 1;
this.render();
}
right() {
if (this.cursor >= this.input.length) return this.alert();
this.moveCursor(1);
this.render();
}
left() {
if (this.cursor <= 0) return this.alert();
this.moveCursor(-1);
this.render();
}
prev() {
this.state.index = this.decrement(this.state.index);
this.getItem();
this.render();
}
next() {
this.state.index = this.increment(this.state.index);
this.getItem();
this.render();
}
up() {
this.prev();
}
down() {
this.next();
}
format(value) {
let color = this.state.completed < 100 ? this.styles.warning : this.styles.success;
if (this.state.submitted === true && this.state.completed !== 100) {
color = this.styles.danger;
}
return color(`${this.state.completed}% completed`);
}
async render() {
let { index, keys = [], submitted, size } = this.state;
let newline = [this.options.newline, '\n'].find(v => v != null);
let prefix = await this.prefix();
let separator = await this.separator();
let message = await this.message();
let prompt = [prefix, message, separator].filter(Boolean).join(' ');
this.state.prompt = prompt;
let header = await this.header();
let error = (await this.error()) || '';
let hint = (await this.hint()) || '';
let body = submitted ? '' : await this.interpolate(this.state);
let key = this.state.key = keys[index] || '';
let input = await this.format(key);
let footer = await this.footer();
if (input) prompt += ' ' + input;
if (hint && !input && this.state.completed === 0) prompt += ' ' + hint;
this.clear(size);
let lines = [header, prompt, body, footer, error.trim()];
this.write(lines.filter(Boolean).join(newline));
this.restore();
}
getItem(name) {
let { items, keys, index } = this.state;
let item = items.find(ch => ch.name === keys[index]);
if (item && item.input != null) {
this.input = item.input;
this.cursor = item.cursor;
}
return item;
}
async submit() {
if (typeof this.interpolate !== 'function') await this.initialize();
await this.interpolate(this.state, true);
let { invalid, missing, output, values } = this.state;
if (invalid.size) {
let err = '';
for (let [key, value] of invalid) err += `Invalid ${key}: ${value}\n`;
this.state.error = err;
return super.submit();
}
if (missing.size) {
this.state.error = 'Required: ' + [...missing.keys()].join(', ');
return super.submit();
}
let lines = colors.unstyle(output).split('\n');
let result = lines.map(v => v.slice(1)).join('\n');
this.value = { values, result };
return super.submit();
}
}
module.exports = SnippetPrompt;
/***/ }),
/***/ 7144:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const hint = '(Use <shift>+<up/down> to sort)';
const Prompt = __webpack_require__(13466);
class Sort extends Prompt {
constructor(options) {
super({ ...options, reorder: false, sort: true, multiple: true });
this.state.hint = [this.options.hint, hint].find(this.isValue.bind(this));
}
indicator() {
return '';
}
async renderChoice(choice, i) {
let str = await super.renderChoice(choice, i);
let sym = this.symbols.identicalTo + ' ';
let pre = (this.index === i && this.sorting) ? this.styles.muted(sym) : ' ';
if (this.options.drag === false) pre = '';
if (this.options.numbered === true) {
return pre + `${i + 1} - ` + str;
}
return pre + str;
}
get selected() {
return this.choices;
}
submit() {
this.value = this.choices.map(choice => choice.value);
return super.submit();
}
}
module.exports = Sort;
/***/ }),
/***/ 83755:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const ArrayPrompt = __webpack_require__(98575);
class Survey extends ArrayPrompt {
constructor(options = {}) {
super(options);
this.emptyError = options.emptyError || 'No items were selected';
this.term = process.env.TERM_PROGRAM;
if (!this.options.header) {
let header = ['', '4 - Strongly Agree', '3 - Agree', '2 - Neutral', '1 - Disagree', '0 - Strongly Disagree', ''];
header = header.map(ele => this.styles.muted(ele));
this.state.header = header.join('\n ');
}
}
async toChoices(...args) {
if (this.createdScales) return false;
this.createdScales = true;
let choices = await super.toChoices(...args);
for (let choice of choices) {
choice.scale = createScale(5, this.options);
choice.scaleIdx = 2;
}
return choices;
}
dispatch() {
this.alert();
}
space() {
let choice = this.focused;
let ele = choice.scale[choice.scaleIdx];
let selected = ele.selected;
choice.scale.forEach(e => (e.selected = false));
ele.selected = !selected;
return this.render();
}
indicator() {
return '';
}
pointer() {
return '';
}
separator() {
return this.styles.muted(this.symbols.ellipsis);
}
right() {
let choice = this.focused;
if (choice.scaleIdx >= choice.scale.length - 1) return this.alert();
choice.scaleIdx++;
return this.render();
}
left() {
let choice = this.focused;
if (choice.scaleIdx <= 0) return this.alert();
choice.scaleIdx--;
return this.render();
}
indent() {
return ' ';
}
async renderChoice(item, i) {
await this.onChoice(item, i);
let focused = this.index === i;
let isHyper = this.term === 'Hyper';
let n = !isHyper ? 8 : 9;
let s = !isHyper ? ' ' : '';
let ln = this.symbols.line.repeat(n);
let sp = ' '.repeat(n + (isHyper ? 0 : 1));
let dot = enabled => (enabled ? this.styles.success('◉') : '◯') + s;
let num = i + 1 + '.';
let color = focused ? this.styles.heading : this.styles.noop;
let msg = await this.resolve(item.message, this.state, item, i);
let indent = this.indent(item);
let scale = indent + item.scale.map((e, i) => dot(i === item.scaleIdx)).join(ln);
let val = i => i === item.scaleIdx ? color(i) : i;
let next = indent + item.scale.map((e, i) => val(i)).join(sp);
let line = () => [num, msg].filter(Boolean).join(' ');
let lines = () => [line(), scale, next, ' '].filter(Boolean).join('\n');
if (focused) {
scale = this.styles.cyan(scale);
next = this.styles.cyan(next);
}
return lines();
}
async renderChoices() {
if (this.state.submitted) return '';
let choices = this.visible.map(async(ch, i) => await this.renderChoice(ch, i));
let visible = await Promise.all(choices);
if (!visible.length) visible.push(this.styles.danger('No matching choices'));
return visible.join('\n');
}
format() {
if (this.state.submitted) {
let values = this.choices.map(ch => this.styles.info(ch.scaleIdx));
return values.join(', ');
}
return '';
}
async render() {
let { submitted, size } = this.state;
let prefix = await this.prefix();
let separator = await this.separator();
let message = await this.message();
let prompt = [prefix, message, separator].filter(Boolean).join(' ');
this.state.prompt = prompt;
let header = await this.header();
let output = await this.format();
let help = await this.error() || await this.hint();
let body = await this.renderChoices();
let footer = await this.footer();
if (output || !help) prompt += ' ' + output;
if (help && !prompt.includes(help)) prompt += ' ' + help;
if (submitted && !output && !body && this.multiple && this.type !== 'form') {
prompt += this.styles.danger(this.emptyError);
}
this.clear(size);
this.write([prompt, header, body, footer].filter(Boolean).join('\n'));
this.restore();
}
submit() {
this.value = {};
for (let choice of this.choices) {
this.value[choice.name] = choice.scaleIdx;
}
return this.base.submit.call(this);
}
}
function createScale(n, options = {}) {
if (Array.isArray(options.scale)) {
return options.scale.map(ele => ({ ...ele }));
}
let scale = [];
for (let i = 1; i < n + 1; i++) scale.push({ i, selected: false });
return scale;
}
module.exports = Survey;
/***/ }),
/***/ 5781:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = __webpack_require__(66719);
/***/ }),
/***/ 10653:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const BooleanPrompt = __webpack_require__(23838);
class TogglePrompt extends BooleanPrompt {
async initialize() {
await super.initialize();
this.value = this.initial = !!this.options.initial;
this.disabled = this.options.disabled || 'no';
this.enabled = this.options.enabled || 'yes';
await this.render();
}
reset() {
this.value = this.initial;
this.render();
}
delete() {
this.alert();
}
toggle() {
this.value = !this.value;
this.render();
}
enable() {
if (this.value === true) return this.alert();
this.value = true;
this.render();
}
disable() {
if (this.value === false) return this.alert();
this.value = false;
this.render();
}
up() {
this.toggle();
}
down() {
this.toggle();
}
right() {
this.toggle();
}
left() {
this.toggle();
}
next() {
this.toggle();
}
prev() {
this.toggle();
}
dispatch(ch = '', key) {
switch (ch.toLowerCase()) {
case ' ':
return this.toggle();
case '1':
case 'y':
case 't':
return this.enable();
case '0':
case 'n':
case 'f':
return this.disable();
default: {
return this.alert();
}
}
}
format() {
let active = str => this.styles.primary.underline(str);
let value = [
this.value ? this.disabled : active(this.disabled),
this.value ? active(this.enabled) : this.enabled
];
return value.join(this.styles.muted(' / '));
}
async render() {
let { size } = this.state;
let header = await this.header();
let prefix = await this.prefix();
let separator = await this.separator();
let message = await this.message();
let output = await this.format();
let help = (await this.error()) || (await this.hint());
let footer = await this.footer();
let prompt = [prefix, message, separator, output].join(' ');
this.state.prompt = prompt;
if (help && !prompt.includes(help)) prompt += ' ' + help;
this.clear(size);
this.write([header, prompt, footer].filter(Boolean).join('\n'));
this.write(this.margin[2]);
this.restore();
}
}
module.exports = TogglePrompt;
/***/ }),
/***/ 31502:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const utils = __webpack_require__(83546);
const roles = {
default(prompt, choice) {
return choice;
},
checkbox(prompt, choice) {
throw new Error('checkbox role is not implemented yet');
},
editable(prompt, choice) {
throw new Error('editable role is not implemented yet');
},
expandable(prompt, choice) {
throw new Error('expandable role is not implemented yet');
},
heading(prompt, choice) {
choice.disabled = '';
choice.indicator = [choice.indicator, ' '].find(v => v != null);
choice.message = choice.message || '';
return choice;
},
input(prompt, choice) {
throw new Error('input role is not implemented yet');
},
option(prompt, choice) {
return roles.default(prompt, choice);
},
radio(prompt, choice) {
throw new Error('radio role is not implemented yet');
},
separator(prompt, choice) {
choice.disabled = '';
choice.indicator = [choice.indicator, ' '].find(v => v != null);
choice.message = choice.message || prompt.symbols.line.repeat(5);
return choice;
},
spacer(prompt, choice) {
return choice;
}
};
module.exports = (name, options = {}) => {
let role = utils.merge({}, roles, options.roles);
return role[name] || role.default;
};
/***/ }),
/***/ 36873:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const { define, width } = __webpack_require__(83546);
class State {
constructor(prompt) {
let options = prompt.options;
define(this, '_prompt', prompt);
this.type = prompt.type;
this.name = prompt.name;
this.message = '';
this.header = '';
this.footer = '';
this.error = '';
this.hint = '';
this.input = '';
this.cursor = 0;
this.index = 0;
this.lines = 0;
this.tick = 0;
this.prompt = '';
this.buffer = '';
this.width = width(options.stdout || process.stdout);
Object.assign(this, options);
this.name = this.name || this.message;
this.message = this.message || this.name;
this.symbols = prompt.symbols;
this.styles = prompt.styles;
this.required = new Set();
this.cancelled = false;
this.submitted = false;
}
clone() {
let state = { ...this };
state.status = this.status;
state.buffer = Buffer.from(state.buffer);
delete state.clone;
return state;
}
set color(val) {
this._color = val;
}
get color() {
let styles = this.prompt.styles;
if (this.cancelled) return styles.cancelled;
if (this.submitted) return styles.submitted;
let color = this._color || styles[this.status];
return typeof color === 'function' ? color : styles.pending;
}
set loading(value) {
this._loading = value;
}
get loading() {
if (typeof this._loading === 'boolean') return this._loading;
if (this.loadingChoices) return 'choices';
return false;
}
get status() {
if (this.cancelled) return 'cancelled';
if (this.submitted) return 'submitted';
return 'pending';
}
}
module.exports = State;
/***/ }),
/***/ 79217:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const utils = __webpack_require__(83546);
const colors = __webpack_require__(53692);
const styles = {
default: colors.noop,
noop: colors.noop,
/**
* Modifiers
*/
set inverse(custom) {
this._inverse = custom;
},
get inverse() {
return this._inverse || utils.inverse(this.primary);
},
set complement(custom) {
this._complement = custom;
},
get complement() {
return this._complement || utils.complement(this.primary);
},
/**
* Main color
*/
primary: colors.cyan,
/**
* Main palette
*/
success: colors.green,
danger: colors.magenta,
strong: colors.bold,
warning: colors.yellow,
muted: colors.dim,
disabled: colors.gray,
dark: colors.dim.gray,
underline: colors.underline,
set info(custom) {
this._info = custom;
},
get info() {
return this._info || this.primary;
},
set em(custom) {
this._em = custom;
},
get em() {
return this._em || this.primary.underline;
},
set heading(custom) {
this._heading = custom;
},
get heading() {
return this._heading || this.muted.underline;
},
/**
* Statuses
*/
set pending(custom) {
this._pending = custom;
},
get pending() {
return this._pending || this.primary;
},
set submitted(custom) {
this._submitted = custom;
},
get submitted() {
return this._submitted || this.success;
},
set cancelled(custom) {
this._cancelled = custom;
},
get cancelled() {
return this._cancelled || this.danger;
},
/**
* Special styling
*/
set typing(custom) {
this._typing = custom;
},
get typing() {
return this._typing || this.dim;
},
set placeholder(custom) {
this._placeholder = custom;
},
get placeholder() {
return this._placeholder || this.primary.dim;
},
set highlight(custom) {
this._highlight = custom;
},
get highlight() {
return this._highlight || this.inverse;
}
};
styles.merge = (options = {}) => {
if (options.styles && typeof options.styles.enabled === 'boolean') {
colors.enabled = options.styles.enabled;
}
if (options.styles && typeof options.styles.visible === 'boolean') {
colors.visible = options.styles.visible;
}
let result = utils.merge({}, styles, options.styles);
delete result.merge;
for (let key of Object.keys(colors)) {
if (!result.hasOwnProperty(key)) {
Reflect.defineProperty(result, key, { get: () => colors[key] });
}
}
for (let key of Object.keys(colors.styles)) {
if (!result.hasOwnProperty(key)) {
Reflect.defineProperty(result, key, { get: () => colors[key] });
}
}
return result;
};
module.exports = styles;
/***/ }),
/***/ 74739:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const isWindows = process.platform === 'win32';
const colors = __webpack_require__(53692);
const utils = __webpack_require__(83546);
const symbols = {
...colors.symbols,
upDownDoubleArrow: '⇕',
upDownDoubleArrow2: '⬍',
upDownArrow: '↕',
asterisk: '*',
asterism: '⁂',
bulletWhite: '◦',
electricArrow: '⌁',
ellipsisLarge: '⋯',
ellipsisSmall: '…',
fullBlock: '█',
identicalTo: '≡',
indicator: colors.symbols.check,
leftAngle: '‹',
mark: '※',
minus: '−',
multiplication: '×',
obelus: '÷',
percent: '%',
pilcrow: '¶',
pilcrow2: '❡',
pencilUpRight: '✐',
pencilDownRight: '✎',
pencilRight: '✏',
plus: '+',
plusMinus: '±',
pointRight: '☞',
rightAngle: '›',
section: '§',
hexagon: { off: '⬡', on: '⬢', disabled: '⬢' },
ballot: { on: '☑', off: '☐', disabled: '☒' },
stars: { on: '★', off: '☆', disabled: '☆' },
folder: { on: '▼', off: '▶', disabled: '▶' },
prefix: {
pending: colors.symbols.question,
submitted: colors.symbols.check,
cancelled: colors.symbols.cross
},
separator: {
pending: colors.symbols.pointerSmall,
submitted: colors.symbols.middot,
cancelled: colors.symbols.middot
},
radio: {
off: isWindows ? '( )' : '◯',
on: isWindows ? '(*)' : '◉',
disabled: isWindows ? '(|)' : 'Ⓘ'
},
numbers: ['⓪', '①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨', '⑩', '⑪', '⑫', '⑬', '⑭', '⑮', '⑯', '⑰', '⑱', '⑲', '⑳', '㉑', '㉒', '㉓', '㉔', '㉕', '㉖', '㉗', '㉘', '㉙', '㉚', '㉛', '㉜', '㉝', '㉞', '㉟', '㊱', '㊲', '㊳', '㊴', '㊵', '㊶', '㊷', '㊸', '㊹', '㊺', '㊻', '㊼', '㊽', '㊾', '㊿']
};
symbols.merge = options => {
let result = utils.merge({}, colors.symbols, symbols, options.symbols);
delete result.merge;
return result;
};
module.exports = symbols;
/***/ }),
/***/ 39227:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const styles = __webpack_require__(79217);
const symbols = __webpack_require__(74739);
const utils = __webpack_require__(83546);
module.exports = prompt => {
prompt.options = utils.merge({}, prompt.options.theme, prompt.options);
prompt.symbols = symbols.merge(prompt.options);
prompt.styles = styles.merge(prompt.options);
};
/***/ }),
/***/ 33940:
/***/ ((module) => {
"use strict";
module.exports = prompt => {
prompt.timers = prompt.timers || {};
let timers = prompt.options.timers;
if (!timers) return;
for (let key of Object.keys(timers)) {
let opts = timers[key];
if (typeof opts === 'number') {
opts = { interval: opts };
}
create(prompt, key, opts);
}
};
function create(prompt, name, options = {}) {
let timer = prompt.timers[name] = { name, start: Date.now(), ms: 0, tick: 0 };
let ms = options.interval || 120;
timer.frames = options.frames || [];
timer.loading = true;
let interval = setInterval(() => {
timer.ms = Date.now() - timer.start;
timer.tick++;
prompt.render();
}, ms);
timer.stop = () => {
timer.loading = false;
clearInterval(interval);
};
Reflect.defineProperty(timer, 'interval', { value: interval });
prompt.once('close', () => timer.stop());
return timer.stop;
}
/***/ }),
/***/ 98575:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const colors = __webpack_require__(53692);
const Prompt = __webpack_require__(232);
const roles = __webpack_require__(31502);
const utils = __webpack_require__(83546);
const { reorder, scrollUp, scrollDown, isObject, swap } = utils;
class ArrayPrompt extends Prompt {
constructor(options) {
super(options);
this.cursorHide();
this.maxSelected = options.maxSelected || Infinity;
this.multiple = options.multiple || false;
this.initial = options.initial || 0;
this.delay = options.delay || 0;
this.longest = 0;
this.num = '';
}
async initialize() {
if (typeof this.options.initial === 'function') {
this.initial = await this.options.initial.call(this);
}
await this.reset(true);
await super.initialize();
}
async reset() {
let { choices, initial, autofocus, suggest } = this.options;
this.state._choices = [];
this.state.choices = [];
this.choices = await Promise.all(await this.toChoices(choices));
this.choices.forEach(ch => (ch.enabled = false));
if (typeof suggest !== 'function' && this.selectable.length === 0) {
throw new Error('At least one choice must be selectable');
}
if (isObject(initial)) initial = Object.keys(initial);
if (Array.isArray(initial)) {
if (autofocus != null) this.index = this.findIndex(autofocus);
initial.forEach(v => this.enable(this.find(v)));
await this.render();
} else {
if (autofocus != null) initial = autofocus;
if (typeof initial === 'string') initial = this.findIndex(initial);
if (typeof initial === 'number' && initial > -1) {
this.index = Math.max(0, Math.min(initial, this.choices.length));
this.enable(this.find(this.index));
}
}
if (this.isDisabled(this.focused)) {
await this.down();
}
}
async toChoices(value, parent) {
this.state.loadingChoices = true;
let choices = [];
let index = 0;
let toChoices = async(items, parent) => {
if (typeof items === 'function') items = await items.call(this);
if (items instanceof Promise) items = await items;
for (let i = 0; i < items.length; i++) {
let choice = items[i] = await this.toChoice(items[i], index++, parent);
choices.push(choice);
if (choice.choices) {
await toChoices(choice.choices, choice);
}
}
return choices;
};
return toChoices(value, parent)
.then(choices => {
this.state.loadingChoices = false;
return choices;
});
}
async toChoice(ele, i, parent) {
if (typeof ele === 'function') ele = await ele.call(this, this);
if (ele instanceof Promise) ele = await ele;
if (typeof ele === 'string') ele = { name: ele };
if (ele.normalized) return ele;
ele.normalized = true;
let origVal = ele.value;
let role = roles(ele.role, this.options);
ele = role(this, ele);
if (typeof ele.disabled === 'string' && !ele.hint) {
ele.hint = ele.disabled;
ele.disabled = true;
}
if (ele.disabled === true && ele.hint == null) {
ele.hint = '(disabled)';
}
// if the choice was already normalized, return it
if (ele.index != null) return ele;
ele.name = ele.name || ele.key || ele.title || ele.value || ele.message;
ele.message = ele.message || ele.name || '';
ele.value = [ele.value, ele.name].find(this.isValue.bind(this));
ele.input = '';
ele.index = i;
ele.cursor = 0;
utils.define(ele, 'parent', parent);
ele.level = parent ? parent.level + 1 : 1;
if (ele.indent == null) {
ele.indent = parent ? parent.indent + ' ' : (ele.indent || '');
}
ele.path = parent ? parent.path + '.' + ele.name : ele.name;
ele.enabled = !!(this.multiple && !this.isDisabled(ele) && (ele.enabled || this.isSelected(ele)));
if (!this.isDisabled(ele)) {
this.longest = Math.max(this.longest, colors.unstyle(ele.message).length);
}
// shallow clone the choice first
let choice = { ...ele };
// then allow the choice to be reset using the "original" values
ele.reset = (input = choice.input, value = choice.value) => {
for (let key of Object.keys(choice)) ele[key] = choice[key];
ele.input = input;
ele.value = value;
};
if (origVal == null && typeof ele.initial === 'function') {
ele.input = await ele.initial.call(this, this.state, ele, i);
}
return ele;
}
async onChoice(choice, i) {
this.emit('choice', choice, i, this);
if (typeof choice.onChoice === 'function') {
await choice.onChoice.call(this, this.state, choice, i);
}
}
async addChoice(ele, i, parent) {
let choice = await this.toChoice(ele, i, parent);
this.choices.push(choice);
this.index = this.choices.length - 1;
this.limit = this.choices.length;
return choice;
}
async newItem(item, i, parent) {
let ele = { name: 'New choice name?', editable: true, newChoice: true, ...item };
let choice = await this.addChoice(ele, i, parent);
choice.updateChoice = () => {
delete choice.newChoice;
choice.name = choice.message = choice.input;
choice.input = '';
choice.cursor = 0;
};
return this.render();
}
indent(choice) {
if (choice.indent == null) {
return choice.level > 1 ? ' '.repeat(choice.level - 1) : '';
}
return choice.indent;
}
dispatch(s, key) {
if (this.multiple && this[key.name]) return this[key.name]();
this.alert();
}
focus(choice, enabled) {
if (typeof enabled !== 'boolean') enabled = choice.enabled;
if (enabled && !choice.enabled && this.selected.length >= this.maxSelected) {
return this.alert();
}
this.index = choice.index;
choice.enabled = enabled && !this.isDisabled(choice);
return choice;
}
space() {
if (!this.multiple) return this.alert();
this.toggle(this.focused);
return this.render();
}
a() {
if (this.maxSelected < this.choices.length) return this.alert();
let enabled = this.selectable.every(ch => ch.enabled);
this.choices.forEach(ch => (ch.enabled = !enabled));
return this.render();
}
i() {
// don't allow choices to be inverted if it will result in
// more than the maximum number of allowed selected items.
if (this.choices.length - this.selected.length > this.maxSelected) {
return this.alert();
}
this.choices.forEach(ch => (ch.enabled = !ch.enabled));
return this.render();
}
g(choice = this.focused) {
if (!this.choices.some(ch => !!ch.parent)) return this.a();
this.toggle((choice.parent && !choice.choices) ? choice.parent : choice);
return this.render();
}
toggle(choice, enabled) {
if (!choice.enabled && this.selected.length >= this.maxSelected) {
return this.alert();
}
if (typeof enabled !== 'boolean') enabled = !choice.enabled;
choice.enabled = enabled;
if (choice.choices) {
choice.choices.forEach(ch => this.toggle(ch, enabled));
}
let parent = choice.parent;
while (parent) {
let choices = parent.choices.filter(ch => this.isDisabled(ch));
parent.enabled = choices.every(ch => ch.enabled === true);
parent = parent.parent;
}
reset(this, this.choices);
this.emit('toggle', choice, this);
return choice;
}
enable(choice) {
if (this.selected.length >= this.maxSelected) return this.alert();
choice.enabled = !this.isDisabled(choice);
choice.choices && choice.choices.forEach(this.enable.bind(this));
return choice;
}
disable(choice) {
choice.enabled = false;
choice.choices && choice.choices.forEach(this.disable.bind(this));
return choice;
}
number(n) {
this.num += n;
let number = num => {
let i = Number(num);
if (i > this.choices.length - 1) return this.alert();
let focused = this.focused;
let choice = this.choices.find(ch => i === ch.index);
if (!choice.enabled && this.selected.length >= this.maxSelected) {
return this.alert();
}
if (this.visible.indexOf(choice) === -1) {
let choices = reorder(this.choices);
let actualIdx = choices.indexOf(choice);
if (focused.index > actualIdx) {
let start = choices.slice(actualIdx, actualIdx + this.limit);
let end = choices.filter(ch => !start.includes(ch));
this.choices = start.concat(end);
} else {
let pos = actualIdx - this.limit + 1;
this.choices = choices.slice(pos).concat(choices.slice(0, pos));
}
}
this.index = this.choices.indexOf(choice);
this.toggle(this.focused);
return this.render();
};
clearTimeout(this.numberTimeout);
return new Promise(resolve => {
let len = this.choices.length;
let num = this.num;
let handle = (val = false, res) => {
clearTimeout(this.numberTimeout);
if (val) res = number(num);
this.num = '';
resolve(res);
};
if (num === '0' || (num.length === 1 && Number(num + '0') > len)) {
return handle(true);
}
if (Number(num) > len) {
return handle(false, this.alert());
}
this.numberTimeout = setTimeout(() => handle(true), this.delay);
});
}
home() {
this.choices = reorder(this.choices);
this.index = 0;
return this.render();
}
end() {
let pos = this.choices.length - this.limit;
let choices = reorder(this.choices);
this.choices = choices.slice(pos).concat(choices.slice(0, pos));
this.index = this.limit - 1;
return this.render();
}
first() {
this.index = 0;
return this.render();
}
last() {
this.index = this.visible.length - 1;
return this.render();
}
prev() {
if (this.visible.length <= 1) return this.alert();
return this.up();
}
next() {
if (this.visible.length <= 1) return this.alert();
return this.down();
}
right() {
if (this.cursor >= this.input.length) return this.alert();
this.cursor++;
return this.render();
}
left() {
if (this.cursor <= 0) return this.alert();
this.cursor--;
return this.render();
}
up() {
let len = this.choices.length;
let vis = this.visible.length;
let idx = this.index;
if (this.options.scroll === false && idx === 0) {
return this.alert();
}
if (len > vis && idx === 0) {
return this.scrollUp();
}
this.index = ((idx - 1 % len) + len) % len;
if (this.isDisabled()) {
return this.up();
}
return this.render();
}
down() {
let len = this.choices.length;
let vis = this.visible.length;
let idx = this.index;
if (this.options.scroll === false && idx === vis - 1) {
return this.alert();
}
if (len > vis && idx === vis - 1) {
return this.scrollDown();
}
this.index = (idx + 1) % len;
if (this.isDisabled()) {
return this.down();
}
return this.render();
}
scrollUp(i = 0) {
this.choices = scrollUp(this.choices);
this.index = i;
if (this.isDisabled()) {
return this.up();
}
return this.render();
}
scrollDown(i = this.visible.length - 1) {
this.choices = scrollDown(this.choices);
this.index = i;
if (this.isDisabled()) {
return this.down();
}
return this.render();
}
async shiftUp() {
if (this.options.sort === true) {
this.sorting = true;
this.swap(this.index - 1);
await this.up();
this.sorting = false;
return;
}
return this.scrollUp(this.index);
}
async shiftDown() {
if (this.options.sort === true) {
this.sorting = true;
this.swap(this.index + 1);
await this.down();
this.sorting = false;
return;
}
return this.scrollDown(this.index);
}
pageUp() {
if (this.visible.length <= 1) return this.alert();
this.limit = Math.max(this.limit - 1, 0);
this.index = Math.min(this.limit - 1, this.index);
this._limit = this.limit;
if (this.isDisabled()) {
return this.up();
}
return this.render();
}
pageDown() {
if (this.visible.length >= this.choices.length) return this.alert();
this.index = Math.max(0, this.index);
this.limit = Math.min(this.limit + 1, this.choices.length);
this._limit = this.limit;
if (this.isDisabled()) {
return this.down();
}
return this.render();
}
swap(pos) {
swap(this.choices, this.index, pos);
}
isDisabled(choice = this.focused) {
let keys = ['disabled', 'collapsed', 'hidden', 'completing', 'readonly'];
if (choice && keys.some(key => choice[key] === true)) {
return true;
}
return choice && choice.role === 'heading';
}
isEnabled(choice = this.focused) {
if (Array.isArray(choice)) return choice.every(ch => this.isEnabled(ch));
if (choice.choices) {
let choices = choice.choices.filter(ch => !this.isDisabled(ch));
return choice.enabled && choices.every(ch => this.isEnabled(ch));
}
return choice.enabled && !this.isDisabled(choice);
}
isChoice(choice, value) {
return choice.name === value || choice.index === Number(value);
}
isSelected(choice) {
if (Array.isArray(this.initial)) {
return this.initial.some(value => this.isChoice(choice, value));
}
return this.isChoice(choice, this.initial);
}
map(names = [], prop = 'value') {
return [].concat(names || []).reduce((acc, name) => {
acc[name] = this.find(name, prop);
return acc;
}, {});
}
filter(value, prop) {
let isChoice = (ele, i) => [ele.name, i].includes(value);
let fn = typeof value === 'function' ? value : isChoice;
let choices = this.options.multiple ? this.state._choices : this.choices;
let result = choices.filter(fn);
if (prop) {
return result.map(ch => ch[prop]);
}
return result;
}
find(value, prop) {
if (isObject(value)) return prop ? value[prop] : value;
let isChoice = (ele, i) => [ele.name, i].includes(value);
let fn = typeof value === 'function' ? value : isChoice;
let choice = this.choices.find(fn);
if (choice) {
return prop ? choice[prop] : choice;
}
}
findIndex(value) {
return this.choices.indexOf(this.find(value));
}
async submit() {
let choice = this.focused;
if (!choice) return this.alert();
if (choice.newChoice) {
if (!choice.input) return this.alert();
choice.updateChoice();
return this.render();
}
if (this.choices.some(ch => ch.newChoice)) {
return this.alert();
}
let { reorder, sort } = this.options;
let multi = this.multiple === true;
let value = this.selected;
if (value === void 0) {
return this.alert();
}
// re-sort choices to original order
if (Array.isArray(value) && reorder !== false && sort !== true) {
value = utils.reorder(value);
}
this.value = multi ? value.map(ch => ch.name) : value.name;
return super.submit();
}
set choices(choices = []) {
this.state._choices = this.state._choices || [];
this.state.choices = choices;
for (let choice of choices) {
if (!this.state._choices.some(ch => ch.name === choice.name)) {
this.state._choices.push(choice);
}
}
if (!this._initial && this.options.initial) {
this._initial = true;
let init = this.initial;
if (typeof init === 'string' || typeof init === 'number') {
let choice = this.find(init);
if (choice) {
this.initial = choice.index;
this.focus(choice, true);
}
}
}
}
get choices() {
return reset(this, this.state.choices || []);
}
set visible(visible) {
this.state.visible = visible;
}
get visible() {
return (this.state.visible || this.choices).slice(0, this.limit);
}
set limit(num) {
this.state.limit = num;
}
get limit() {
let { state, options, choices } = this;
let limit = state.limit || this._limit || options.limit || choices.length;
return Math.min(limit, this.height);
}
set value(value) {
super.value = value;
}
get value() {
if (typeof super.value !== 'string' && super.value === this.initial) {
return this.input;
}
return super.value;
}
set index(i) {
this.state.index = i;
}
get index() {
return Math.max(0, this.state ? this.state.index : 0);
}
get enabled() {
return this.filter(this.isEnabled.bind(this));
}
get focused() {
let choice = this.choices[this.index];
if (choice && this.state.submitted && this.multiple !== true) {
choice.enabled = true;
}
return choice;
}
get selectable() {
return this.choices.filter(choice => !this.isDisabled(choice));
}
get selected() {
return this.multiple ? this.enabled : this.focused;
}
}
function reset(prompt, choices) {
if (choices instanceof Promise) return choices;
if (typeof choices === 'function') {
if (utils.isAsyncFn(choices)) return choices;
choices = choices.call(prompt, prompt);
}
for (let choice of choices) {
if (Array.isArray(choice.choices)) {
let items = choice.choices.filter(ch => !prompt.isDisabled(ch));
choice.enabled = items.every(ch => ch.enabled === true);
}
if (prompt.isDisabled(choice) === true) {
delete choice.enabled;
}
}
return choices;
}
module.exports = ArrayPrompt;
/***/ }),
/***/ 66926:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const FormPrompt = __webpack_require__(21826);
const defaultAuthenticate = () => {
throw new Error('expected prompt to have a custom authenticate method');
};
const factory = (authenticate = defaultAuthenticate) => {
class AuthPrompt extends FormPrompt {
constructor(options) {
super(options);
}
async submit() {
this.value = await authenticate.call(this, this.values, this.state);
super.base.submit.call(this);
}
static create(authenticate) {
return factory(authenticate);
}
}
return AuthPrompt;
};
module.exports = factory();
/***/ }),
/***/ 23838:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Prompt = __webpack_require__(232);
const { isPrimitive, hasColor } = __webpack_require__(83546);
class BooleanPrompt extends Prompt {
constructor(options) {
super(options);
this.cursorHide();
}
async initialize() {
let initial = await this.resolve(this.initial, this.state);
this.input = await this.cast(initial);
await super.initialize();
}
dispatch(ch) {
if (!this.isValue(ch)) return this.alert();
this.input = ch;
return this.submit();
}
format(value) {
let { styles, state } = this;
return !state.submitted ? styles.primary(value) : styles.success(value);
}
cast(input) {
return this.isTrue(input);
}
isTrue(input) {
return /^[ty1]/i.test(input);
}
isFalse(input) {
return /^[fn0]/i.test(input);
}
isValue(value) {
return isPrimitive(value) && (this.isTrue(value) || this.isFalse(value));
}
async hint() {
if (this.state.status === 'pending') {
let hint = await this.element('hint');
if (!hasColor(hint)) {
return this.styles.muted(hint);
}
return hint;
}
}
async render() {
let { input, size } = this.state;
let prefix = await this.prefix();
let sep = await this.separator();
let msg = await this.message();
let hint = this.styles.muted(this.default);
let promptLine = [prefix, msg, hint, sep].filter(Boolean).join(' ');
this.state.prompt = promptLine;
let header = await this.header();
let value = this.value = this.cast(input);
let output = await this.format(value);
let help = (await this.error()) || (await this.hint());
let footer = await this.footer();
if (help && !promptLine.includes(help)) output += ' ' + help;
promptLine += ' ' + output;
this.clear(size);
this.write([header, promptLine, footer].filter(Boolean).join('\n'));
this.restore();
}
set value(value) {
super.value = value;
}
get value() {
return this.cast(super.value);
}
}
module.exports = BooleanPrompt;
/***/ }),
/***/ 29920:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = {
ArrayPrompt: __webpack_require__(98575),
AuthPrompt: __webpack_require__(66926),
BooleanPrompt: __webpack_require__(23838),
NumberPrompt: __webpack_require__(45376),
StringPrompt: __webpack_require__(43391)
};
/***/ }),
/***/ 45376:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const StringPrompt = __webpack_require__(43391);
class NumberPrompt extends StringPrompt {
constructor(options = {}) {
super({ style: 'number', ...options });
this.min = this.isValue(options.min) ? this.toNumber(options.min) : -Infinity;
this.max = this.isValue(options.max) ? this.toNumber(options.max) : Infinity;
this.delay = options.delay != null ? options.delay : 1000;
this.float = options.float !== false;
this.round = options.round === true || options.float === false;
this.major = options.major || 10;
this.minor = options.minor || 1;
this.initial = options.initial != null ? options.initial : '';
this.input = String(this.initial);
this.cursor = this.input.length;
this.cursorShow();
}
append(ch) {
if (!/[-+.]/.test(ch) || (ch === '.' && this.input.includes('.'))) {
return this.alert('invalid number');
}
return super.append(ch);
}
number(ch) {
return super.append(ch);
}
next() {
if (this.input && this.input !== this.initial) return this.alert();
if (!this.isValue(this.initial)) return this.alert();
this.input = this.initial;
this.cursor = String(this.initial).length;
return this.render();
}
up(number) {
let step = number || this.minor;
let num = this.toNumber(this.input);
if (num > this.max + step) return this.alert();
this.input = `${num + step}`;
return this.render();
}
down(number) {
let step = number || this.minor;
let num = this.toNumber(this.input);
if (num < this.min - step) return this.alert();
this.input = `${num - step}`;
return this.render();
}
shiftDown() {
return this.down(this.major);
}
shiftUp() {
return this.up(this.major);
}
format(input = this.input) {
if (typeof this.options.format === 'function') {
return this.options.format.call(this, input);
}
return this.styles.info(input);
}
toNumber(value = '') {
return this.float ? +value : Math.round(+value);
}
isValue(value) {
return /^[-+]?[0-9]+((\.)|(\.[0-9]+))?$/.test(value);
}
submit() {
let value = [this.input, this.initial].find(v => this.isValue(v));
this.value = this.toNumber(value || 0);
return super.submit();
}
}
module.exports = NumberPrompt;
/***/ }),
/***/ 43391:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const Prompt = __webpack_require__(232);
const placeholder = __webpack_require__(12786);
const { isPrimitive } = __webpack_require__(83546);
class StringPrompt extends Prompt {
constructor(options) {
super(options);
this.initial = isPrimitive(this.initial) ? String(this.initial) : '';
if (this.initial) this.cursorHide();
this.state.prevCursor = 0;
this.state.clipboard = [];
}
async keypress(input, key = {}) {
let prev = this.state.prevKeypress;
this.state.prevKeypress = key;
if (this.options.multiline === true && key.name === 'return') {
if (!prev || prev.name !== 'return') {
return this.append('\n', key);
}
}
return super.keypress(input, key);
}
moveCursor(n) {
this.cursor += n;
}
reset() {
this.input = this.value = '';
this.cursor = 0;
return this.render();
}
dispatch(ch, key) {
if (!ch || key.ctrl || key.code) return this.alert();
this.append(ch);
}
append(ch) {
let { cursor, input } = this.state;
this.input = `${input}`.slice(0, cursor) + ch + `${input}`.slice(cursor);
this.moveCursor(String(ch).length);
this.render();
}
insert(str) {
this.append(str);
}
delete() {
let { cursor, input } = this.state;
if (cursor <= 0) return this.alert();
this.input = `${input}`.slice(0, cursor - 1) + `${input}`.slice(cursor);
this.moveCursor(-1);
this.render();
}
deleteForward() {
let { cursor, input } = this.state;
if (input[cursor] === void 0) return this.alert();
this.input = `${input}`.slice(0, cursor) + `${input}`.slice(cursor + 1);
this.render();
}
cutForward() {
let pos = this.cursor;
if (this.input.length <= pos) return this.alert();
this.state.clipboard.push(this.input.slice(pos));
this.input = this.input.slice(0, pos);
this.render();
}
cutLeft() {
let pos = this.cursor;
if (pos === 0) return this.alert();
let before = this.input.slice(0, pos);
let after = this.input.slice(pos);
let words = before.split(' ');
this.state.clipboard.push(words.pop());
this.input = words.join(' ');
this.cursor = this.input.length;
this.input += after;
this.render();
}
paste() {
if (!this.state.clipboard.length) return this.alert();
this.insert(this.state.clipboard.pop());
this.render();
}
toggleCursor() {
if (this.state.prevCursor) {
this.cursor = this.state.prevCursor;
this.state.prevCursor = 0;
} else {
this.state.prevCursor = this.cursor;
this.cursor = 0;
}
this.render();
}
first() {
this.cursor = 0;
this.render();
}
last() {
this.cursor = this.input.length - 1;
this.render();
}
next() {
let init = this.initial != null ? String(this.initial) : '';
if (!init || !init.startsWith(this.input)) return this.alert();
this.input = this.initial;
this.cursor = this.initial.length;
this.render();
}
prev() {
if (!this.input) return this.alert();
this.reset();
}
backward() {
return this.left();
}
forward() {
return this.right();
}
right() {
if (this.cursor >= this.input.length) return this.alert();
this.moveCursor(1);
return this.render();
}
left() {
if (this.cursor <= 0) return this.alert();
this.moveCursor(-1);
return this.render();
}
isValue(value) {
return !!value;
}
async format(input = this.value) {
let initial = await this.resolve(this.initial, this.state);
if (!this.state.submitted) {
return placeholder(this, { input, initial, pos: this.cursor });
}
return this.styles.submitted(input || initial);
}
async render() {
let size = this.state.size;
let prefix = await this.prefix();
let separator = await this.separator();
let message = await this.message();
let prompt = [prefix, message, separator].filter(Boolean).join(' ');
this.state.prompt = prompt;
let header = await this.header();
let output = await this.format();
let help = (await this.error()) || (await this.hint());
let footer = await this.footer();
if (help && !output.includes(help)) output += ' ' + help;
prompt += ' ' + output;
this.clear(size);
this.write([header, prompt, footer].filter(Boolean).join('\n'));
this.restore();
}
}
module.exports = StringPrompt;
/***/ }),
/***/ 83546:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
const toString = Object.prototype.toString;
const colors = __webpack_require__(53692);
let called = false;
let fns = [];
const complements = {
'yellow': 'blue',
'cyan': 'red',
'green': 'magenta',
'black': 'white',
'blue': 'yellow',
'red': 'cyan',
'magenta': 'green',
'white': 'black'
};
exports.longest = (arr, prop) => {
return arr.reduce((a, v) => Math.max(a, prop ? v[prop].length : v.length), 0);
};
exports.hasColor = str => !!str && colors.hasColor(str);
const isObject = exports.isObject = val => {
return val !== null && typeof val === 'object' && !Array.isArray(val);
};
exports.nativeType = val => {
return toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, '');
};
exports.isAsyncFn = val => {
return exports.nativeType(val) === 'asyncfunction';
};
exports.isPrimitive = val => {
return val != null && typeof val !== 'object' && typeof val !== 'function';
};
exports.resolve = (context, value, ...rest) => {
if (typeof value === 'function') {
return value.call(context, ...rest);
}
return value;
};
exports.scrollDown = (choices = []) => [...choices.slice(1), choices[0]];
exports.scrollUp = (choices = []) => [choices.pop(), ...choices];
exports.reorder = (arr = []) => {
let res = arr.slice();
res.sort((a, b) => {
if (a.index > b.index) return 1;
if (a.index < b.index) return -1;
return 0;
});
return res;
};
exports.swap = (arr, index, pos) => {
let len = arr.length;
let idx = pos === len ? 0 : pos < 0 ? len - 1 : pos;
let choice = arr[index];
arr[index] = arr[idx];
arr[idx] = choice;
};
exports.width = (stream, fallback = 80) => {
let columns = (stream && stream.columns) ? stream.columns : fallback;
if (stream && typeof stream.getWindowSize === 'function') {
columns = stream.getWindowSize()[0];
}
if (process.platform === 'win32') {
return columns - 1;
}
return columns;
};
exports.height = (stream, fallback = 20) => {
let rows = (stream && stream.rows) ? stream.rows : fallback;
if (stream && typeof stream.getWindowSize === 'function') {
rows = stream.getWindowSize()[1];
}
return rows;
};
exports.wordWrap = (str, options = {}) => {
if (!str) return str;
if (typeof options === 'number') {
options = { width: options };
}
let { indent = '', newline = ('\n' + indent), width = 80 } = options;
let spaces = (newline + indent).match(/[^\S\n]/g) || [];
width -= spaces.length;
let source = `.{1,${width}}([\\s\\u200B]+|$)|[^\\s\\u200B]+?([\\s\\u200B]+|$)`;
let output = str.trim();
let regex = new RegExp(source, 'g');
let lines = output.match(regex) || [];
lines = lines.map(line => line.replace(/\n$/, ''));
if (options.padEnd) lines = lines.map(line => line.padEnd(width, ' '));
if (options.padStart) lines = lines.map(line => line.padStart(width, ' '));
return indent + lines.join(newline);
};
exports.unmute = color => {
let name = color.stack.find(n => colors.keys.color.includes(n));
if (name) {
return colors[name];
}
let bg = color.stack.find(n => n.slice(2) === 'bg');
if (bg) {
return colors[name.slice(2)];
}
return str => str;
};
exports.pascal = str => str ? str[0].toUpperCase() + str.slice(1) : '';
exports.inverse = color => {
if (!color || !color.stack) return color;
let name = color.stack.find(n => colors.keys.color.includes(n));
if (name) {
let col = colors['bg' + exports.pascal(name)];
return col ? col.black : color;
}
let bg = color.stack.find(n => n.slice(0, 2) === 'bg');
if (bg) {
return colors[bg.slice(2).toLowerCase()] || color;
}
return colors.none;
};
exports.complement = color => {
if (!color || !color.stack) return color;
let name = color.stack.find(n => colors.keys.color.includes(n));
let bg = color.stack.find(n => n.slice(0, 2) === 'bg');
if (name && !bg) {
return colors[complements[name] || name];
}
if (bg) {
let lower = bg.slice(2).toLowerCase();
let comp = complements[lower];
if (!comp) return color;
return colors['bg' + exports.pascal(comp)] || color;
}
return colors.none;
};
exports.meridiem = date => {
let hours = date.getHours();
let minutes = date.getMinutes();
let ampm = hours >= 12 ? 'pm' : 'am';
hours = hours % 12;
let hrs = hours === 0 ? 12 : hours;
let min = minutes < 10 ? '0' + minutes : minutes;
return hrs + ':' + min + ' ' + ampm;
};
/**
* Set a value on the given object.
* @param {Object} obj
* @param {String} prop
* @param {any} value
*/
exports.set = (obj = {}, prop = '', val) => {
return prop.split('.').reduce((acc, k, i, arr) => {
let value = arr.length - 1 > i ? (acc[k] || {}) : val;
if (!exports.isObject(value) && i < arr.length - 1) value = {};
return (acc[k] = value);
}, obj);
};
/**
* Get a value from the given object.
* @param {Object} obj
* @param {String} prop
*/
exports.get = (obj = {}, prop = '', fallback) => {
let value = obj[prop] == null
? prop.split('.').reduce((acc, k) => acc && acc[k], obj)
: obj[prop];
return value == null ? fallback : value;
};
exports.mixin = (target, b) => {
if (!isObject(target)) return b;
if (!isObject(b)) return target;
for (let key of Object.keys(b)) {
let desc = Object.getOwnPropertyDescriptor(b, key);
if (desc.hasOwnProperty('value')) {
if (target.hasOwnProperty(key) && isObject(desc.value)) {
let existing = Object.getOwnPropertyDescriptor(target, key);
if (isObject(existing.value)) {
target[key] = exports.merge({}, target[key], b[key]);
} else {
Reflect.defineProperty(target, key, desc);
}
} else {
Reflect.defineProperty(target, key, desc);
}
} else {
Reflect.defineProperty(target, key, desc);
}
}
return target;
};
exports.merge = (...args) => {
let target = {};
for (let ele of args) exports.mixin(target, ele);
return target;
};
exports.mixinEmitter = (obj, emitter) => {
let proto = emitter.constructor.prototype;
for (let key of Object.keys(proto)) {
let val = proto[key];
if (typeof val === 'function') {
exports.define(obj, key, val.bind(emitter));
} else {
exports.define(obj, key, val);
}
}
};
exports.onExit = callback => {
const onExit = (quit, code) => {
if (called) return;
called = true;
fns.forEach(fn => fn());
if (quit === true) {
process.exit(128 + code);
}
};
if (fns.length === 0) {
process.once('SIGTERM', onExit.bind(null, true, 15));
process.once('SIGINT', onExit.bind(null, true, 2));
process.once('exit', onExit);
}
fns.push(callback);
};
exports.define = (obj, key, value) => {
Reflect.defineProperty(obj, key, { value });
};
exports.defineExport = (obj, key, fn) => {
let custom;
Reflect.defineProperty(obj, key, {
enumerable: true,
configurable: true,
set(val) {
custom = val;
},
get() {
return custom ? custom() : fn();
}
});
};
/***/ })
};
;
//# sourceMappingURL=31.index.js.map