--- /dev/null
+'use strict';
+
+const colors = require('ansi-colors');
+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));
+ };
+}
projects / dotfiles / .git / blobdiff