--- /dev/null
+'use strict';
+
+const Events = require('events');
+const colors = require('ansi-colors');
+const keypress = require('./keypress');
+const timer = require('./timer');
+const State = require('./state');
+const theme = require('./theme');
+const utils = require('./utils');
+const ansi = require('./ansi');
+
+/**
+ * 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;
projects / dotfiles / .git / blobdiff