truffle
Version:
Truffle - Simple development framework for Ethereum
2,176 lines (1,709 loc) • 80 kB
JavaScript
#!/usr/bin/env node
exports.id = 5346;
exports.ids = [5346];
exports.modules = {
/***/ 85346:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* Inquirer.js
* A collection of common interactive command line user interfaces.
*/
const inquirer = module.exports;
/**
* Client interfaces
*/
inquirer.prompts = {};
inquirer.Separator = __webpack_require__(35617);
inquirer.ui = {
BottomBar: __webpack_require__(56115),
Prompt: __webpack_require__(97874),
};
/**
* Create a new self-contained prompt module.
*/
inquirer.createPromptModule = function (opt) {
const promptModule = function (questions, answers) {
let ui;
try {
ui = new inquirer.ui.Prompt(promptModule.prompts, opt);
} catch (error) {
return Promise.reject(error);
}
const promise = ui.run(questions, answers);
// Monkey patch the UI on the promise object so
// that it remains publicly accessible.
promise.ui = ui;
return promise;
};
promptModule.prompts = {};
/**
* Register a prompt type
* @param {String} name Prompt type name
* @param {Function} prompt Prompt constructor
* @return {inquirer}
*/
promptModule.registerPrompt = function (name, prompt) {
promptModule.prompts[name] = prompt;
return this;
};
/**
* Register the defaults provider prompts
*/
promptModule.restoreDefaultPrompts = function () {
this.registerPrompt('list', __webpack_require__(20278));
this.registerPrompt('input', __webpack_require__(12662));
this.registerPrompt('number', __webpack_require__(6022));
this.registerPrompt('confirm', __webpack_require__(11907));
this.registerPrompt('rawlist', __webpack_require__(18722));
this.registerPrompt('expand', __webpack_require__(80724));
this.registerPrompt('checkbox', __webpack_require__(55066));
this.registerPrompt('password', __webpack_require__(58769));
this.registerPrompt('editor', __webpack_require__(56601));
};
promptModule.restoreDefaultPrompts();
return promptModule;
};
/**
* Public CLI helper interface
* @param {Array|Object|Rx.Observable} questions - Questions settings array
* @param {Function} cb - Callback being passed the user answers
* @return {inquirer.ui.Prompt}
*/
inquirer.prompt = inquirer.createPromptModule();
// Expose helper functions on the top level for easiest usage by common users
inquirer.registerPrompt = function (name, prompt) {
inquirer.prompt.registerPrompt(name, prompt);
};
inquirer.restoreDefaultPrompts = function () {
inquirer.prompt.restoreDefaultPrompts();
};
/***/ }),
/***/ 65328:
/***/ ((module) => {
"use strict";
/**
* Choice object
* Normalize input as choice object
* @constructor
* @param {Number|String|Object} val Choice value. If an object is passed, it should contains
* at least one of `value` or `name` property
*/
module.exports = class Choice {
constructor(val, answers) {
// Don't process Choice and Separator object
if (val instanceof Choice || val.type === 'separator') {
// eslint-disable-next-line no-constructor-return
return val;
}
if (typeof val === 'string' || typeof val === 'number') {
this.name = String(val);
this.value = val;
this.short = String(val);
} else {
Object.assign(this, val, {
name: val.name || val.value,
value: 'value' in val ? val.value : val.name,
short: val.short || val.name || val.value,
});
}
if (typeof val.disabled === 'function') {
this.disabled = val.disabled(answers);
} else {
this.disabled = val.disabled;
}
}
};
/***/ }),
/***/ 64744:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const assert = __webpack_require__(39491);
const _ = {
filter: __webpack_require__(63105),
map: __webpack_require__(35161),
};
const Separator = __webpack_require__(35617);
const Choice = __webpack_require__(65328);
/**
* Choices collection
* Collection of multiple `choice` object
*/
module.exports = class Choices {
/** @param {Array} choices All `choice` to keep in the collection */
constructor(choices, answers) {
this.choices = choices.map((val) => {
if (val.type === 'separator') {
if (!(val instanceof Separator)) {
val = new Separator(val.line);
}
return val;
}
return new Choice(val, answers);
});
this.realChoices = this.choices
.filter(Separator.exclude)
.filter((item) => !item.disabled);
Object.defineProperty(this, 'length', {
get() {
return this.choices.length;
},
set(val) {
this.choices.length = val;
},
});
Object.defineProperty(this, 'realLength', {
get() {
return this.realChoices.length;
},
set() {
throw new Error('Cannot set `realLength` of a Choices collection');
},
});
}
/**
* Get a valid choice from the collection
* @param {Number} selector The selected choice index
* @return {Choice|Undefined} Return the matched choice or undefined
*/
getChoice(selector) {
assert(typeof selector === 'number');
return this.realChoices[selector];
}
/**
* Get a raw element from the collection
* @param {Number} selector The selected index value
* @return {Choice|Undefined} Return the matched choice or undefined
*/
get(selector) {
assert(typeof selector === 'number');
return this.choices[selector];
}
/**
* Match the valid choices against a where clause
* @param {Object} whereClause Lodash `where` clause
* @return {Array} Matching choices or empty array
*/
where(whereClause) {
return _.filter(this.realChoices, whereClause);
}
/**
* Pluck a particular key from the choices
* @param {String} propertyName Property name to select
* @return {Array} Selected properties
*/
pluck(propertyName) {
return _.map(this.realChoices, propertyName);
}
// Expose usual Array methods
indexOf(...args) {
return this.choices.indexOf(...args);
}
forEach(...args) {
return this.choices.forEach(...args);
}
filter(...args) {
return this.choices.filter(...args);
}
reduce(...args) {
return this.choices.reduce(...args);
}
find(func) {
return this.choices.find(func);
}
push(...args) {
const objs = args.map((val) => new Choice(val));
this.choices.push(...objs);
this.realChoices = this.choices
.filter(Separator.exclude)
.filter((item) => !item.disabled);
return this.choices;
}
};
/***/ }),
/***/ 35617:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const chalk = __webpack_require__(34061);
const figures = __webpack_require__(91254);
/**
* Separator object
* Used to space/separate choices group
* @constructor
* @param {String} line Separation line content (facultative)
*/
class Separator {
constructor(line) {
this.type = 'separator';
this.line = chalk.dim(line || new Array(15).join(figures.line));
}
/**
* Stringify separator
* @return {String} the separator display string
*/
toString() {
return this.line;
}
}
/**
* Helper function returning false if object is a separator
* @param {Object} obj object to test against
* @return {Boolean} `false` if object is a separator
*/
Separator.exclude = function (obj) {
return obj.type !== 'separator';
};
module.exports = Separator;
/***/ }),
/***/ 64549:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* Base prompt implementation
* Should be extended by prompt types.
*/
const _ = {
defaults: __webpack_require__(91747),
clone: __webpack_require__(66678),
};
const chalk = __webpack_require__(34061);
const runAsync = __webpack_require__(14709);
const { filter, flatMap, share, take, takeUntil } = __webpack_require__(14857);
const Choices = __webpack_require__(64744);
const ScreenManager = __webpack_require__(38473);
class Prompt {
constructor(question, rl, answers) {
// Setup instance defaults property
Object.assign(this, {
answers,
status: 'pending',
});
// Set defaults prompt options
this.opt = _.defaults(_.clone(question), {
validate: () => true,
validatingText: '',
filter: (val) => val,
filteringText: '',
when: () => true,
suffix: '',
prefix: chalk.green('?'),
});
// Make sure name is present
if (!this.opt.name) {
this.throwParamError('name');
}
// Set default message if no message defined
if (!this.opt.message) {
this.opt.message = this.opt.name + ':';
}
// Normalize choices
if (Array.isArray(this.opt.choices)) {
this.opt.choices = new Choices(this.opt.choices, answers);
}
this.rl = rl;
this.screen = new ScreenManager(this.rl);
}
/**
* Start the Inquiry session and manage output value filtering
* @return {Promise}
*/
run() {
return new Promise((resolve, reject) => {
this._run(
(value) => resolve(value),
(error) => reject(error)
);
});
}
// Default noop (this one should be overwritten in prompts)
_run(cb) {
cb();
}
/**
* Throw an error telling a required parameter is missing
* @param {String} name Name of the missing param
* @return {Throw Error}
*/
throwParamError(name) {
throw new Error('You must provide a `' + name + '` parameter');
}
/**
* Called when the UI closes. Override to do any specific cleanup necessary
*/
close() {
this.screen.releaseCursor();
}
/**
* Run the provided validation method each time a submit event occur.
* @param {Rx.Observable} submit - submit event flow
* @return {Object} Object containing two observables: `success` and `error`
*/
handleSubmitEvents(submit) {
const self = this;
const validate = runAsync(this.opt.validate);
const asyncFilter = runAsync(this.opt.filter);
const validation = submit.pipe(
flatMap((value) => {
this.startSpinner(value, this.opt.filteringText);
return asyncFilter(value, self.answers).then(
(filteredValue) => {
this.startSpinner(filteredValue, this.opt.validatingText);
return validate(filteredValue, self.answers).then(
(isValid) => ({ isValid, value: filteredValue }),
(err) => ({ isValid: err, value: filteredValue })
);
},
(err) => ({ isValid: err })
);
}),
share()
);
const success = validation.pipe(
filter((state) => state.isValid === true),
take(1)
);
const error = validation.pipe(
filter((state) => state.isValid !== true),
takeUntil(success)
);
return {
success,
error,
};
}
startSpinner(value, bottomContent) {
value = this.getSpinningValue(value);
// If the question will spin, cut off the prefix (for layout purposes)
const content = bottomContent
? this.getQuestion() + value
: this.getQuestion().slice(this.opt.prefix.length + 1) + value;
this.screen.renderWithSpinner(content, bottomContent);
}
/**
* Allow override, e.g. for password prompts
* See: https://github.com/SBoudrias/Inquirer.js/issues/1022
*
* @return {String} value to display while spinning
*/
getSpinningValue(value) {
return value;
}
/**
* Generate the prompt question string
* @return {String} prompt question string
*/
getQuestion() {
let message =
(this.opt.prefix ? this.opt.prefix + ' ' : '') +
chalk.bold(this.opt.message) +
this.opt.suffix +
chalk.reset(' ');
// Append the default if available, and if question isn't touched/answered
if (
this.opt.default != null &&
this.status !== 'touched' &&
this.status !== 'answered'
) {
// If default password is supplied, hide it
if (this.opt.type === 'password') {
message += chalk.italic.dim('[hidden] ');
} else {
message += chalk.dim('(' + this.opt.default + ') ');
}
}
return message;
}
}
module.exports = Prompt;
/***/ }),
/***/ 55066:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `list` type prompt
*/
const chalk = __webpack_require__(34061);
const cliCursor = __webpack_require__(23909);
const figures = __webpack_require__(91254);
const { map, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const observe = __webpack_require__(39707);
const Paginator = __webpack_require__(1201);
const incrementListIndex = __webpack_require__(13289);
class CheckboxPrompt extends Base {
constructor(questions, rl, answers) {
super(questions, rl, answers);
if (!this.opt.choices) {
this.throwParamError('choices');
}
if (Array.isArray(this.opt.default)) {
this.opt.choices.forEach(function (choice) {
if (this.opt.default.indexOf(choice.value) >= 0) {
choice.checked = true;
}
}, this);
}
this.pointer = 0;
// Make sure no default is set (so it won't be printed)
this.opt.default = null;
const shouldLoop = this.opt.loop === undefined ? true : this.opt.loop;
this.paginator = new Paginator(this.screen, { isInfinite: shouldLoop });
}
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
const events = observe(this.rl);
const validation = this.handleSubmitEvents(
events.line.pipe(map(this.getCurrentValue.bind(this)))
);
validation.success.forEach(this.onEnd.bind(this));
validation.error.forEach(this.onError.bind(this));
events.normalizedUpKey
.pipe(takeUntil(validation.success))
.forEach(this.onUpKey.bind(this));
events.normalizedDownKey
.pipe(takeUntil(validation.success))
.forEach(this.onDownKey.bind(this));
events.numberKey
.pipe(takeUntil(validation.success))
.forEach(this.onNumberKey.bind(this));
events.spaceKey
.pipe(takeUntil(validation.success))
.forEach(this.onSpaceKey.bind(this));
events.aKey.pipe(takeUntil(validation.success)).forEach(this.onAllKey.bind(this));
events.iKey.pipe(takeUntil(validation.success)).forEach(this.onInverseKey.bind(this));
// Init the prompt
cliCursor.hide();
this.render();
this.firstRender = false;
return this;
}
/**
* Render the prompt to screen
* @return {CheckboxPrompt} self
*/
render(error) {
// Render question
let message = this.getQuestion();
let bottomContent = '';
if (!this.dontShowHints) {
message +=
'(Press ' +
chalk.cyan.bold('<space>') +
' to select, ' +
chalk.cyan.bold('<a>') +
' to toggle all, ' +
chalk.cyan.bold('<i>') +
' to invert selection, and ' +
chalk.cyan.bold('<enter>') +
' to proceed)';
}
// Render choices or answer depending on the state
if (this.status === 'answered') {
message += chalk.cyan(this.selection.join(', '));
} else {
const choicesStr = renderChoices(this.opt.choices, this.pointer);
const indexPosition = this.opt.choices.indexOf(
this.opt.choices.getChoice(this.pointer)
);
const realIndexPosition =
this.opt.choices.reduce((acc, value, i) => {
// Dont count lines past the choice we are looking at
if (i > indexPosition) {
return acc;
}
// Add line if it's a separator
if (value.type === 'separator') {
return acc + 1;
}
let l = value.name;
// Non-strings take up one line
if (typeof l !== 'string') {
return acc + 1;
}
// Calculate lines taken up by string
l = l.split('\n');
return acc + l.length;
}, 0) - 1;
message +=
'\n' + this.paginator.paginate(choicesStr, realIndexPosition, this.opt.pageSize);
}
if (error) {
bottomContent = chalk.red('>> ') + error;
}
this.screen.render(message, bottomContent);
}
/**
* When user press `enter` key
*/
onEnd(state) {
this.status = 'answered';
this.dontShowHints = true;
// Rerender prompt (and clean subline error)
this.render();
this.screen.done();
cliCursor.show();
this.done(state.value);
}
onError(state) {
this.render(state.isValid);
}
getCurrentValue() {
const choices = this.opt.choices.filter(
(choice) => Boolean(choice.checked) && !choice.disabled
);
this.selection = choices.map((choice) => choice.short);
return choices.map((choice) => choice.value);
}
onUpKey() {
this.pointer = incrementListIndex(this.pointer, 'up', this.opt);
this.render();
}
onDownKey() {
this.pointer = incrementListIndex(this.pointer, 'down', this.opt);
this.render();
}
onNumberKey(input) {
if (input <= this.opt.choices.realLength) {
this.pointer = input - 1;
this.toggleChoice(this.pointer);
}
this.render();
}
onSpaceKey() {
this.toggleChoice(this.pointer);
this.render();
}
onAllKey() {
const shouldBeChecked = Boolean(
this.opt.choices.find((choice) => choice.type !== 'separator' && !choice.checked)
);
this.opt.choices.forEach((choice) => {
if (choice.type !== 'separator') {
choice.checked = shouldBeChecked;
}
});
this.render();
}
onInverseKey() {
this.opt.choices.forEach((choice) => {
if (choice.type !== 'separator') {
choice.checked = !choice.checked;
}
});
this.render();
}
toggleChoice(index) {
const item = this.opt.choices.getChoice(index);
if (item !== undefined) {
this.opt.choices.getChoice(index).checked = !item.checked;
}
}
}
/**
* Function for rendering checkbox choices
* @param {Number} pointer Position of the pointer
* @return {String} Rendered content
*/
function renderChoices(choices, pointer) {
let output = '';
let separatorOffset = 0;
choices.forEach((choice, i) => {
if (choice.type === 'separator') {
separatorOffset++;
output += ' ' + choice + '\n';
return;
}
if (choice.disabled) {
separatorOffset++;
output += ' - ' + choice.name;
output += ` (${
typeof choice.disabled === 'string' ? choice.disabled : 'Disabled'
})`;
} else {
const line = getCheckbox(choice.checked) + ' ' + choice.name;
if (i - separatorOffset === pointer) {
output += chalk.cyan(figures.pointer + line);
} else {
output += ' ' + line;
}
}
output += '\n';
});
return output.replace(/\n$/, '');
}
/**
* Get the checkbox
* @param {Boolean} checked - add a X or not to the checkbox
* @return {String} Composited checkbox string
*/
function getCheckbox(checked) {
return checked ? chalk.green(figures.radioOn) : figures.radioOff;
}
module.exports = CheckboxPrompt;
/***/ }),
/***/ 11907:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `confirm` type prompt
*/
const chalk = __webpack_require__(34061);
const { take, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const observe = __webpack_require__(39707);
class ConfirmPrompt extends Base {
constructor(questions, rl, answers) {
super(questions, rl, answers);
let rawDefault = true;
Object.assign(this.opt, {
filter(input) {
let value = rawDefault;
if (input != null && input !== '') {
value = /^y(es)?/i.test(input);
}
return value;
},
});
if (this.opt.default != null) {
rawDefault = Boolean(this.opt.default);
}
this.opt.default = rawDefault ? 'Y/n' : 'y/N';
}
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
// Once user confirm (enter key)
const events = observe(this.rl);
events.keypress.pipe(takeUntil(events.line)).forEach(this.onKeypress.bind(this));
events.line.pipe(take(1)).forEach(this.onEnd.bind(this));
// Init
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {ConfirmPrompt} self
*/
render(answer) {
let message = this.getQuestion();
if (typeof answer === 'boolean') {
message += chalk.cyan(answer ? 'Yes' : 'No');
} else {
message += this.rl.line;
}
this.screen.render(message);
return this;
}
/**
* When user press `enter` key
*/
onEnd(input) {
this.status = 'answered';
const output = this.opt.filter(input);
this.render(output);
this.screen.done();
this.done(output);
}
/**
* When user press a key
*/
onKeypress() {
this.render();
}
}
module.exports = ConfirmPrompt;
/***/ }),
/***/ 56601:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `editor` type prompt
*/
const chalk = __webpack_require__(34061);
const { editAsync } = __webpack_require__(72134);
const Base = __webpack_require__(64549);
const observe = __webpack_require__(39707);
const { Subject } = __webpack_require__(72872);
class EditorPrompt extends Base {
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
this.editorResult = new Subject();
// Open Editor on "line" (Enter Key)
const events = observe(this.rl);
this.lineSubscription = events.line.subscribe(this.startExternalEditor.bind(this));
// Trigger Validation when editor closes
const validation = this.handleSubmitEvents(this.editorResult);
validation.success.forEach(this.onEnd.bind(this));
validation.error.forEach(this.onError.bind(this));
// Prevents default from being printed on screen (can look weird with multiple lines)
this.currentText = this.opt.default;
this.opt.default = null;
// Init
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {EditorPrompt} self
*/
render(error) {
let bottomContent = '';
let message = this.getQuestion();
if (this.status === 'answered') {
message += chalk.dim('Received');
} else {
message += chalk.dim('Press <enter> to launch your preferred editor.');
}
if (error) {
bottomContent = chalk.red('>> ') + error;
}
this.screen.render(message, bottomContent);
}
/**
* Launch $EDITOR on user press enter
*/
startExternalEditor() {
// Pause Readline to prevent stdin and stdout from being modified while the editor is showing
this.rl.pause();
editAsync(this.currentText, this.endExternalEditor.bind(this));
}
endExternalEditor(error, result) {
this.rl.resume();
if (error) {
this.editorResult.error(error);
} else {
this.editorResult.next(result);
}
}
onEnd(state) {
this.editorResult.unsubscribe();
this.lineSubscription.unsubscribe();
this.answer = state.value;
this.status = 'answered';
// Re-render prompt
this.render();
this.screen.done();
this.done(this.answer);
}
onError(state) {
this.render(state.isValid);
}
}
module.exports = EditorPrompt;
/***/ }),
/***/ 80724:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `rawlist` type prompt
*/
const chalk = __webpack_require__(34061);
const { map, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const Separator = __webpack_require__(35617);
const observe = __webpack_require__(39707);
const Paginator = __webpack_require__(1201);
class ExpandPrompt extends Base {
constructor(questions, rl, answers) {
super(questions, rl, answers);
if (!this.opt.choices) {
this.throwParamError('choices');
}
this.validateChoices(this.opt.choices);
// Add the default `help` (/expand) option
this.opt.choices.push({
key: 'h',
name: 'Help, list all options',
value: 'help',
});
this.opt.validate = (choice) => {
if (choice == null) {
return 'Please enter a valid command';
}
return choice !== 'help';
};
// Setup the default string (capitalize the default key)
this.opt.default = this.generateChoicesString(this.opt.choices, this.opt.default);
this.paginator = new Paginator(this.screen);
}
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
// Save user answer and update prompt to show selected option.
const events = observe(this.rl);
const validation = this.handleSubmitEvents(
events.line.pipe(map(this.getCurrentValue.bind(this)))
);
validation.success.forEach(this.onSubmit.bind(this));
validation.error.forEach(this.onError.bind(this));
this.keypressObs = events.keypress
.pipe(takeUntil(validation.success))
.forEach(this.onKeypress.bind(this));
// Init the prompt
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {ExpandPrompt} self
*/
render(error, hint) {
let message = this.getQuestion();
let bottomContent = '';
if (this.status === 'answered') {
message += chalk.cyan(this.answer);
} else if (this.status === 'expanded') {
const choicesStr = renderChoices(this.opt.choices, this.selectedKey);
message += this.paginator.paginate(choicesStr, this.selectedKey, this.opt.pageSize);
message += '\n Answer: ';
}
message += this.rl.line;
if (error) {
bottomContent = chalk.red('>> ') + error;
}
if (hint) {
bottomContent = chalk.cyan('>> ') + hint;
}
this.screen.render(message, bottomContent);
}
getCurrentValue(input) {
if (!input) {
input = this.rawDefault;
}
const selected = this.opt.choices.where({ key: input.toLowerCase().trim() })[0];
if (!selected) {
return null;
}
return selected.value;
}
/**
* Generate the prompt choices string
* @return {String} Choices string
*/
getChoices() {
let output = '';
this.opt.choices.forEach((choice) => {
output += '\n ';
if (choice.type === 'separator') {
output += ' ' + choice;
return;
}
let choiceStr = choice.key + ') ' + choice.name;
if (this.selectedKey === choice.key) {
choiceStr = chalk.cyan(choiceStr);
}
output += choiceStr;
});
return output;
}
onError(state) {
if (state.value === 'help') {
this.selectedKey = '';
this.status = 'expanded';
this.render();
return;
}
this.render(state.isValid);
}
/**
* When user press `enter` key
*/
onSubmit(state) {
this.status = 'answered';
const choice = this.opt.choices.where({ value: state.value })[0];
this.answer = choice.short || choice.name;
// Re-render prompt
this.render();
this.screen.done();
this.done(state.value);
}
/**
* When user press a key
*/
onKeypress() {
this.selectedKey = this.rl.line.toLowerCase();
const selected = this.opt.choices.where({ key: this.selectedKey })[0];
if (this.status === 'expanded') {
this.render();
} else {
this.render(null, selected ? selected.name : null);
}
}
/**
* Validate the choices
* @param {Array} choices
*/
validateChoices(choices) {
let formatError;
const errors = [];
const keymap = {};
choices.filter(Separator.exclude).forEach((choice) => {
if (!choice.key || choice.key.length !== 1) {
formatError = true;
}
choice.key = String(choice.key).toLowerCase();
if (keymap[choice.key]) {
errors.push(choice.key);
}
keymap[choice.key] = true;
});
if (formatError) {
throw new Error(
'Format error: `key` param must be a single letter and is required.'
);
}
if (keymap.h) {
throw new Error(
'Reserved key error: `key` param cannot be `h` - this value is reserved.'
);
}
if (errors.length) {
throw new Error(
'Duplicate key error: `key` param must be unique. Duplicates: ' +
[...new Set(errors)].join(',')
);
}
}
/**
* Generate a string out of the choices keys
* @param {Array} choices
* @param {Number|String} default - the choice index or name to capitalize
* @return {String} The rendered choices key string
*/
generateChoicesString(choices, defaultChoice) {
let defIndex = choices.realLength - 1;
if (typeof defaultChoice === 'number' && this.opt.choices.getChoice(defaultChoice)) {
defIndex = defaultChoice;
} else if (typeof defaultChoice === 'string') {
const index = choices.realChoices.findIndex(({ value }) => value === defaultChoice);
defIndex = index === -1 ? defIndex : index;
}
const defStr = this.opt.choices.pluck('key');
this.rawDefault = defStr[defIndex];
defStr[defIndex] = String(defStr[defIndex]).toUpperCase();
return defStr.join('');
}
}
/**
* Function for rendering checkbox choices
* @param {String} pointer Selected key
* @return {String} Rendered content
*/
function renderChoices(choices, pointer) {
let output = '';
choices.forEach((choice) => {
output += '\n ';
if (choice.type === 'separator') {
output += ' ' + choice;
return;
}
let choiceStr = choice.key + ') ' + choice.name;
if (pointer === choice.key) {
choiceStr = chalk.cyan(choiceStr);
}
output += choiceStr;
});
return output;
}
module.exports = ExpandPrompt;
/***/ }),
/***/ 12662:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `input` type prompt
*/
const chalk = __webpack_require__(34061);
const { map, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const observe = __webpack_require__(39707);
class InputPrompt extends Base {
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
// Once user confirm (enter key)
const events = observe(this.rl);
const submit = events.line.pipe(map(this.filterInput.bind(this)));
const validation = this.handleSubmitEvents(submit);
validation.success.forEach(this.onEnd.bind(this));
validation.error.forEach(this.onError.bind(this));
events.keypress
.pipe(takeUntil(validation.success))
.forEach(this.onKeypress.bind(this));
// Init
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {InputPrompt} self
*/
render(error) {
let bottomContent = '';
let appendContent = '';
let message = this.getQuestion();
const { transformer } = this.opt;
const isFinal = this.status === 'answered';
if (isFinal) {
appendContent = this.answer;
} else {
appendContent = this.rl.line;
}
if (transformer) {
message += transformer(appendContent, this.answers, { isFinal });
} else {
message += isFinal ? chalk.cyan(appendContent) : appendContent;
}
if (error) {
bottomContent = chalk.red('>> ') + error;
}
this.screen.render(message, bottomContent);
}
/**
* When user press `enter` key
*/
filterInput(input) {
if (!input) {
return this.opt.default == null ? '' : this.opt.default;
}
return input;
}
onEnd(state) {
this.answer = state.value;
this.status = 'answered';
// Re-render prompt
this.render();
this.screen.done();
this.done(state.value);
}
onError({ value = '', isValid }) {
this.rl.line += value;
this.rl.cursor += value.length;
this.render(isValid);
}
/**
* When user press a key
*/
onKeypress() {
this.state = 'touched';
this.render();
}
}
module.exports = InputPrompt;
/***/ }),
/***/ 20278:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `list` type prompt
*/
const chalk = __webpack_require__(34061);
const figures = __webpack_require__(91254);
const cliCursor = __webpack_require__(23909);
const runAsync = __webpack_require__(14709);
const { flatMap, map, take, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const observe = __webpack_require__(39707);
const Paginator = __webpack_require__(1201);
const incrementListIndex = __webpack_require__(13289);
class ListPrompt extends Base {
constructor(questions, rl, answers) {
super(questions, rl, answers);
if (!this.opt.choices) {
this.throwParamError('choices');
}
this.firstRender = true;
this.selected = 0;
const def = this.opt.default;
// If def is a Number, then use as index. Otherwise, check for value.
if (typeof def === 'number' && def >= 0 && def < this.opt.choices.realLength) {
this.selected = def;
} else if (typeof def !== 'number' && def != null) {
const index = this.opt.choices.realChoices.findIndex(({ value }) => value === def);
this.selected = Math.max(index, 0);
}
// Make sure no default is set (so it won't be printed)
this.opt.default = null;
const shouldLoop = this.opt.loop === undefined ? true : this.opt.loop;
this.paginator = new Paginator(this.screen, { isInfinite: shouldLoop });
}
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
const self = this;
const events = observe(this.rl);
events.normalizedUpKey.pipe(takeUntil(events.line)).forEach(this.onUpKey.bind(this));
events.normalizedDownKey
.pipe(takeUntil(events.line))
.forEach(this.onDownKey.bind(this));
events.numberKey.pipe(takeUntil(events.line)).forEach(this.onNumberKey.bind(this));
events.line
.pipe(
take(1),
map(this.getCurrentValue.bind(this)),
flatMap((value) =>
runAsync(self.opt.filter)(value, self.answers).catch((err) => err)
)
)
.forEach(this.onSubmit.bind(this));
// Init the prompt
cliCursor.hide();
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {ListPrompt} self
*/
render() {
// Render question
let message = this.getQuestion();
if (this.firstRender) {
message += chalk.dim('(Use arrow keys)');
}
// Render choices or answer depending on the state
if (this.status === 'answered') {
message += chalk.cyan(this.opt.choices.getChoice(this.selected).short);
} else {
const choicesStr = listRender(this.opt.choices, this.selected);
const indexPosition = this.opt.choices.indexOf(
this.opt.choices.getChoice(this.selected)
);
const realIndexPosition =
this.opt.choices.reduce((acc, value, i) => {
// Dont count lines past the choice we are looking at
if (i > indexPosition) {
return acc;
}
// Add line if it's a separator
if (value.type === 'separator') {
return acc + 1;
}
let l = value.name;
// Non-strings take up one line
if (typeof l !== 'string') {
return acc + 1;
}
// Calculate lines taken up by string
l = l.split('\n');
return acc + l.length;
}, 0) - 1;
message +=
'\n' + this.paginator.paginate(choicesStr, realIndexPosition, this.opt.pageSize);
}
this.firstRender = false;
this.screen.render(message);
}
/**
* When user press `enter` key
*/
onSubmit(value) {
this.status = 'answered';
// Rerender prompt
this.render();
this.screen.done();
cliCursor.show();
this.done(value);
}
getCurrentValue() {
return this.opt.choices.getChoice(this.selected).value;
}
/**
* When user press a key
*/
onUpKey() {
this.selected = incrementListIndex(this.selected, 'up', this.opt);
this.render();
}
onDownKey() {
this.selected = incrementListIndex(this.selected, 'down', this.opt);
this.render();
}
onNumberKey(input) {
if (input <= this.opt.choices.realLength) {
this.selected = input - 1;
}
this.render();
}
}
/**
* Function for rendering list choices
* @param {Number} pointer Position of the pointer
* @return {String} Rendered content
*/
function listRender(choices, pointer) {
let output = '';
let separatorOffset = 0;
choices.forEach((choice, i) => {
if (choice.type === 'separator') {
separatorOffset++;
output += ' ' + choice + '\n';
return;
}
if (choice.disabled) {
separatorOffset++;
output += ' - ' + choice.name;
output += ` (${
typeof choice.disabled === 'string' ? choice.disabled : 'Disabled'
})`;
output += '\n';
return;
}
const isSelected = i - separatorOffset === pointer;
let line = (isSelected ? figures.pointer + ' ' : ' ') + choice.name;
if (isSelected) {
line = chalk.cyan(line);
}
output += line + ' \n';
});
return output.replace(/\n$/, '');
}
module.exports = ListPrompt;
/***/ }),
/***/ 6022:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `input` type prompt
*/
const Input = __webpack_require__(12662);
/**
* Extention of the Input prompt specifically for use with number inputs.
*/
class NumberPrompt extends Input {
filterInput(input) {
if (input && typeof input === 'string') {
input = input.trim();
// Match a number in the input
const numberMatch = input.match(/(^-?\d+|^\d+\.\d*|^\d*\.\d+)(e\d+)?$/);
// If a number is found, return that input.
if (numberMatch) {
return Number(numberMatch[0]);
}
}
// If the input was invalid return the default value.
return this.opt.default == null ? NaN : this.opt.default;
}
}
module.exports = NumberPrompt;
/***/ }),
/***/ 58769:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `password` type prompt
*/
const chalk = __webpack_require__(34061);
const { map, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const observe = __webpack_require__(39707);
function mask(input, maskChar) {
input = String(input);
maskChar = typeof maskChar === 'string' ? maskChar : '*';
if (input.length === 0) {
return '';
}
return new Array(input.length + 1).join(maskChar);
}
class PasswordPrompt extends Base {
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
const events = observe(this.rl);
// Once user confirm (enter key)
const submit = events.line.pipe(map(this.filterInput.bind(this)));
const validation = this.handleSubmitEvents(submit);
validation.success.forEach(this.onEnd.bind(this));
validation.error.forEach(this.onError.bind(this));
events.keypress
.pipe(takeUntil(validation.success))
.forEach(this.onKeypress.bind(this));
// Init
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {PasswordPrompt} self
*/
render(error) {
let message = this.getQuestion();
let bottomContent = '';
if (this.status === 'answered') {
message += this.getMaskedValue(this.answer);
} else {
message += this.getMaskedValue(this.rl.line || '');
}
if (error) {
bottomContent = '\n' + chalk.red('>> ') + error;
}
this.screen.render(message, bottomContent);
}
getMaskedValue(value) {
if (this.status === 'answered') {
return this.opt.mask
? chalk.cyan(mask(value, this.opt.mask))
: chalk.italic.dim('[hidden]');
}
return this.opt.mask
? mask(value, this.opt.mask)
: chalk.italic.dim('[input is hidden] ');
}
/**
* Mask value during async filter/validation.
*/
getSpinningValue(value) {
return this.getMaskedValue(value);
}
/**
* When user press `enter` key
*/
filterInput(input) {
if (!input) {
return this.opt.default == null ? '' : this.opt.default;
}
return input;
}
onEnd(state) {
this.status = 'answered';
this.answer = state.value;
// Re-render prompt
this.render();
this.screen.done();
this.done(state.value);
}
onError(state) {
this.render(state.isValid);
}
onKeypress() {
// If user press a key, just clear the default value
if (this.opt.default) {
this.opt.default = undefined;
}
this.render();
}
}
module.exports = PasswordPrompt;
/***/ }),
/***/ 18722:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* `rawlist` type prompt
*/
const chalk = __webpack_require__(34061);
const { map, takeUntil } = __webpack_require__(14857);
const Base = __webpack_require__(64549);
const Separator = __webpack_require__(35617);
const observe = __webpack_require__(39707);
const Paginator = __webpack_require__(1201);
const incrementListIndex = __webpack_require__(13289);
class RawListPrompt extends Base {
constructor(questions, rl, answers) {
super(questions, rl, answers);
this.hiddenLine = '';
this.lastKey = '';
if (!this.opt.choices) {
this.throwParamError('choices');
}
this.opt.validChoices = this.opt.choices.filter(Separator.exclude);
this.selected = 0;
this.rawDefault = 0;
Object.assign(this.opt, {
validate(val) {
return val != null;
},
});
const def = this.opt.default;
if (typeof def === 'number' && def >= 0 && def < this.opt.choices.realLength) {
this.selected = def;
this.rawDefault = def;
} else if (typeof def !== 'number' && def != null) {
const index = this.opt.choices.realChoices.findIndex(({ value }) => value === def);
const safeIndex = Math.max(index, 0);
this.selected = safeIndex;
this.rawDefault = safeIndex;
}
// Make sure no default is set (so it won't be printed)
this.opt.default = null;
const shouldLoop = this.opt.loop === undefined ? true : this.opt.loop;
this.paginator = new Paginator(undefined, { isInfinite: shouldLoop });
}
/**
* Start the Inquiry session
* @param {Function} cb Callback when prompt is done
* @return {this}
*/
_run(cb) {
this.done = cb;
// Once user confirm (enter key)
const events = observe(this.rl);
const submit = events.line.pipe(map(this.getCurrentValue.bind(this)));
const validation = this.handleSubmitEvents(submit);
validation.success.forEach(this.onEnd.bind(this));
validation.error.forEach(this.onError.bind(this));
events.normalizedUpKey
.pipe(takeUntil(validation.success))
.forEach(this.onUpKey.bind(this));
events.normalizedDownKey
.pipe(takeUntil(validation.success))
.forEach(this.onDownKey.bind(this));
events.keypress
.pipe(takeUntil(validation.success))
.forEach(this.onKeypress.bind(this));
// Init the prompt
this.render();
return this;
}
/**
* Render the prompt to screen
* @return {RawListPrompt} self
*/
render(error) {
// Render question
let message = this.getQuestion();
let bottomContent = '';
if (this.status === 'answered') {
message += chalk.cyan(this.opt.choices.getChoice(this.selected).short);
} else {
const choicesStr = renderChoices(this.opt.choices, this.selected);
message +=
'\n' + this.paginator.paginate(choicesStr, this.selected, this.opt.pageSize);
message += '\n Answer: ';
}
message += this.rl.line;
if (error) {
bottomContent = '\n' + chalk.red('>> ') + error;
}
this.screen.render(message, bottomContent);
}
/**
* When user press `enter` key
*/
getCurrentValue(index) {
if (index == null) {
index = this.rawDefault;
} else if (index === '') {
this.selected = this.selected === undefined ? -1 : this.selected;
index = this.selected;
} else {
index -= 1;
}
const choice = this.opt.choices.getChoice(index);
return choice ? choice.value : null;
}
onEnd(state) {
this.status = 'answered';
this.answer = state.value;
// Re-render prompt
this.render();
this.screen.done();
this.done(state.value);
}
onError() {
this.render('Please enter a valid index');
}
/**
* When user press a key
*/
onKeypress() {
let index;
if (this.lastKey === 'arrow') {
index = this.hiddenLine.length ? Number(this.hiddenLine) - 1 : 0;
} else {
index = this.rl.line.length ? Number(this.rl.line) - 1 : 0;
}
this.lastKey = '';
if (this.opt.choices.getChoice(index)) {
this.selected = index;
} else {
this.selected = undefined;
}
this.render();
}
/**
* When user press up key
*/
onUpKey() {
this.onArrowKey('up');
}
/**
* When user press down key
*/
onDownKey() {
this.onArrowKey('down');
}
/**
* When user press up or down key
* @param {String} type Arrow type: up or down
*/
onArrowKey(type) {
this.selected = incrementListIndex(this.selected, type, this.opt) || 0;
this.hiddenLine = String(this.selected + 1);
this.rl.line = '';
this.lastKey = 'arrow';
}
}
/**
* Function for rendering list choices
* @param {Number} pointer Position of the pointer
* @return {String} Rendered content
*/
function renderChoices(choices, pointer) {
let output = '';
let separatorOffset = 0;
choices.forEach((choice, i) => {
output += output ? '\n ' : ' ';
if (choice.type === 'separator') {
separatorOffset++;
output += ' ' + choice;
return;
}
const index = i - separatorOffset;
let display = index + 1 + ') ' + choice.name;
if (index === pointer) {
display = chalk.cyan(display);
}
output += display;
});
return output;
}
module.exports = RawListPrompt;
/***/ }),
/***/ 90877:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
const MuteStream = __webpack_require__(42954);
const readline = __webpack_require__(14521);
/**
* Base interface class other can inherits from
*/
class UI {
constructor(opt) {
// Instantiate the Readline interface
// @Note: Don't reassign if already present (allow test to override the Stream)
if (!this.rl) {
this.rl = readline.createInterface(setupReadlineOptions(opt));
}
this.rl.resume();
this.onForceClose = this.onForceClose.bind(this);
// Make sure new prompt start on a newline when closing
process.on('exit', this.onForceClose);
// Terminate process on SIGINT (which will call process.on('exit') in return)
this.rl.on('SIGINT', this.onForceClose);
}
/**
* Handle the ^C exit
* @return {null}
*/
onForceClose() {
this.close();
process.kill(process.pid, 'SIGINT');
console.log('');
}
/**
* Close the interface and cleanup listeners
*/
close() {
// Remove events listeners
this.rl.removeListener('SIGINT', this.onForceClose);
process.removeListener('exit', this.onForceClose);
this.rl.output.unmute();
if (this.activePrompt && typeof this.activePrompt.close === 'function') {
this.activePrompt.close();
}
// Close the readline
this.rl.output.end();
this.rl.pause();
this.rl.close();
}
}
function setupReadlineOptions(opt = {}) {
// Inquirer 8.x:
// opt.skipTTYChecks = opt.skipTTYChecks === undefined ? opt.input !== undefined : opt.skipTTYChecks;
opt.skipTTYChecks = opt.skipTTYChecks === undefined ? true : opt.skipTTYChecks;
// Default `input` to stdin
const input = opt.input || process.stdin;
// Check if prompt is being called in TTY environment
// If it isn't return a failed promise
if (!opt.skipTTYChecks && !input.isTTY) {
const nonTtyError = new Error(
'Prompts can not be meaningfully rendered in non-TTY environments'
);
nonTtyError.isTtyError = true;
throw nonTtyError;
}
// Add mute capabilities to the output
const ms = new MuteStream();
ms.pipe(opt.output || process.stdout);
const output = ms;
return {
terminal: true,
...opt,
input,
output,
};
}
module.exports = UI;
/***/ }),
/***/ 56115:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
/**
* Sticky bottom bar user interface
*/
const through = __webpack_require__(26547);
const Base = __webpack_require__(90877);
const rlUtils = __webpack_require__(29191);
class BottomBar extends Base {
constructor(opt = {}) {
super(opt);
this.log = through(this.writeLog.bind(this));
this.bottomBar = opt.bottomBar || '';
this.render();
}
/**
* Render the prompt to screen
* @return {BottomBar} self
*/
render() {
this.write(this.bottomBar);
return this;
}
clean() {
rlUtils.clearLine(this.rl, this.bottomBar.split('\n').length);
return this;
}
/**
* Update the bottom bar content and rerender
* @param {String} bottomB