@quilted/create 0.1.56 → 0.1.57

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/date.cjs

@@ -0,0 +1,267 @@
+'use strict';
+
+var index = require('../../../../../kleur@3.0.3/node_modules/kleur/index.cjs');
+var prompt = require('./prompt.cjs');
+var index$1 = require('../util/index.cjs');
+var index$2 = require('../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.cjs');
+var index$3 = require('../dateparts/index.cjs');
+
+var date;
+var hasRequiredDate;
+
+function requireDate () {
+	if (hasRequiredDate) return date;
+	hasRequiredDate = 1;
+
+	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+	function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+	const color = index.__require();
+
+	const Prompt = prompt.__require();
+
+	const _require = index$1.__require(),
+	      style = _require.style,
+	      clear = _require.clear,
+	      figures = _require.figures;
+
+	const _require2 = index$2.__require(),
+	      erase = _require2.erase,
+	      cursor = _require2.cursor;
+
+	const _require3 = index$3.__require(),
+	      DatePart = _require3.DatePart,
+	      Meridiem = _require3.Meridiem,
+	      Day = _require3.Day,
+	      Hours = _require3.Hours,
+	      Milliseconds = _require3.Milliseconds,
+	      Minutes = _require3.Minutes,
+	      Month = _require3.Month,
+	      Seconds = _require3.Seconds,
+	      Year = _require3.Year;
+
+	const regex = /\\(.)|"((?:\\["\\]|[^"])+)"|(D[Do]?|d{3,4}|d)|(M{1,4})|(YY(?:YY)?)|([aA])|([Hh]{1,2})|(m{1,2})|(s{1,2})|(S{1,4})|./g;
+	const regexGroups = {
+	  1: ({
+	    token
+	  }) => token.replace(/\\(.)/g, '$1'),
+	  2: opts => new Day(opts),
+	  // Day // TODO
+	  3: opts => new Month(opts),
+	  // Month
+	  4: opts => new Year(opts),
+	  // Year
+	  5: opts => new Meridiem(opts),
+	  // AM/PM // TODO (special)
+	  6: opts => new Hours(opts),
+	  // Hours
+	  7: opts => new Minutes(opts),
+	  // Minutes
+	  8: opts => new Seconds(opts),
+	  // Seconds
+	  9: opts => new Milliseconds(opts) // Fractional seconds
+
+	};
+	const dfltLocales = {
+	  months: 'January,February,March,April,May,June,July,August,September,October,November,December'.split(','),
+	  monthsShort: 'Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec'.split(','),
+	  weekdays: 'Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday'.split(','),
+	  weekdaysShort: 'Sun,Mon,Tue,Wed,Thu,Fri,Sat'.split(',')
+	};
+	/**
+	 * DatePrompt Base Element
+	 * @param {Object} opts Options
+	 * @param {String} opts.message Message
+	 * @param {Number} [opts.initial] Index of default value
+	 * @param {String} [opts.mask] The format mask
+	 * @param {object} [opts.locales] The date locales
+	 * @param {String} [opts.error] The error message shown on invalid value
+	 * @param {Function} [opts.validate] Function to validate the submitted value
+	 * @param {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 */
+
+	class DatePrompt extends Prompt {
+	  constructor(opts = {}) {
+	    super(opts);
+	    this.msg = opts.message;
+	    this.cursor = 0;
+	    this.typed = '';
+	    this.locales = Object.assign(dfltLocales, opts.locales);
+	    this._date = opts.initial || new Date();
+	    this.errorMsg = opts.error || 'Please Enter A Valid Value';
+
+	    this.validator = opts.validate || (() => true);
+
+	    this.mask = opts.mask || 'YYYY-MM-DD HH:mm:ss';
+	    this.clear = clear('', this.out.columns);
+	    this.render();
+	  }
+
+	  get value() {
+	    return this.date;
+	  }
+
+	  get date() {
+	    return this._date;
+	  }
+
+	  set date(date) {
+	    if (date) this._date.setTime(date.getTime());
+	  }
+
+	  set mask(mask) {
+	    let result;
+	    this.parts = [];
+
+	    while (result = regex.exec(mask)) {
+	      let match = result.shift();
+	      let idx = result.findIndex(gr => gr != null);
+	      this.parts.push(idx in regexGroups ? regexGroups[idx]({
+	        token: result[idx] || match,
+	        date: this.date,
+	        parts: this.parts,
+	        locales: this.locales
+	      }) : result[idx] || match);
+	    }
+
+	    let parts = this.parts.reduce((arr, i) => {
+	      if (typeof i === 'string' && typeof arr[arr.length - 1] === 'string') arr[arr.length - 1] += i;else arr.push(i);
+	      return arr;
+	    }, []);
+	    this.parts.splice(0);
+	    this.parts.push(...parts);
+	    this.reset();
+	  }
+
+	  moveCursor(n) {
+	    this.typed = '';
+	    this.cursor = n;
+	    this.fire();
+	  }
+
+	  reset() {
+	    this.moveCursor(this.parts.findIndex(p => p instanceof DatePart));
+	    this.fire();
+	    this.render();
+	  }
+
+	  exit() {
+	    this.abort();
+	  }
+
+	  abort() {
+	    this.done = this.aborted = true;
+	    this.error = false;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  validate() {
+	    var _this = this;
+
+	    return _asyncToGenerator(function* () {
+	      let valid = yield _this.validator(_this.value);
+
+	      if (typeof valid === 'string') {
+	        _this.errorMsg = valid;
+	        valid = false;
+	      }
+
+	      _this.error = !valid;
+	    })();
+	  }
+
+	  submit() {
+	    var _this2 = this;
+
+	    return _asyncToGenerator(function* () {
+	      yield _this2.validate();
+
+	      if (_this2.error) {
+	        _this2.color = 'red';
+
+	        _this2.fire();
+
+	        _this2.render();
+
+	        return;
+	      }
+
+	      _this2.done = true;
+	      _this2.aborted = false;
+
+	      _this2.fire();
+
+	      _this2.render();
+
+	      _this2.out.write('\n');
+
+	      _this2.close();
+	    })();
+	  }
+
+	  up() {
+	    this.typed = '';
+	    this.parts[this.cursor].up();
+	    this.render();
+	  }
+
+	  down() {
+	    this.typed = '';
+	    this.parts[this.cursor].down();
+	    this.render();
+	  }
+
+	  left() {
+	    let prev = this.parts[this.cursor].prev();
+	    if (prev == null) return this.bell();
+	    this.moveCursor(this.parts.indexOf(prev));
+	    this.render();
+	  }
+
+	  right() {
+	    let next = this.parts[this.cursor].next();
+	    if (next == null) return this.bell();
+	    this.moveCursor(this.parts.indexOf(next));
+	    this.render();
+	  }
+
+	  next() {
+	    let next = this.parts[this.cursor].next();
+	    this.moveCursor(next ? this.parts.indexOf(next) : this.parts.findIndex(part => part instanceof DatePart));
+	    this.render();
+	  }
+
+	  _(c) {
+	    if (/\d/.test(c)) {
+	      this.typed += c;
+	      this.parts[this.cursor].setTo(this.typed);
+	      this.render();
+	    }
+	  }
+
+	  render() {
+	    if (this.closed) return;
+	    if (this.firstRender) this.out.write(cursor.hide);else this.out.write(clear(this.outputText, this.out.columns));
+	    super.render(); // Print prompt
+
+	    this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.parts.reduce((arr, p, idx) => arr.concat(idx === this.cursor && !this.done ? color.cyan().underline(p.toString()) : p), []).join('')].join(' '); // Print error
+
+	    if (this.error) {
+	      this.outputText += this.errorMsg.split('\n').reduce((a, l, i) => a + `\n${i ? ` ` : figures.pointerSmall} ${color.red().italic(l)}`, ``);
+	    }
+
+	    this.out.write(erase.line + cursor.to(0) + this.outputText);
+	  }
+
+	}
+
+	date = DatePrompt;
+	return date;
+}
+
+exports.__require = requireDate;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/index.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var text = require('./text.cjs');
+var select = require('./select.cjs');
+var toggle = require('./toggle.cjs');
+var date = require('./date.cjs');
+var number = require('./number.cjs');
+var multiselect = require('./multiselect.cjs');
+var autocomplete = require('./autocomplete.cjs');
+var autocompleteMultiselect = require('./autocompleteMultiselect.cjs');
+var confirm = require('./confirm.cjs');
+
+var elements;
+var hasRequiredElements;
+
+function requireElements () {
+	if (hasRequiredElements) return elements;
+	hasRequiredElements = 1;
+
+	elements = {
+	  TextPrompt: text.__require(),
+	  SelectPrompt: select.__require(),
+	  TogglePrompt: toggle.__require(),
+	  DatePrompt: date.__require(),
+	  NumberPrompt: number.__require(),
+	  MultiselectPrompt: multiselect.__require(),
+	  AutocompletePrompt: autocomplete.__require(),
+	  AutocompleteMultiselectPrompt: autocompleteMultiselect.__require(),
+	  ConfirmPrompt: confirm.__require()
+	};
+	return elements;
+}
+
+exports.__require = requireElements;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/multiselect.cjs

@@ -0,0 +1,305 @@
+'use strict';
+
+var index = require('../../../../../kleur@3.0.3/node_modules/kleur/index.cjs');
+var index$2 = require('../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.cjs');
+var prompt = require('./prompt.cjs');
+var index$1 = require('../util/index.cjs');
+
+var multiselect;
+var hasRequiredMultiselect;
+
+function requireMultiselect () {
+	if (hasRequiredMultiselect) return multiselect;
+	hasRequiredMultiselect = 1;
+
+	const color = index.__require();
+
+	const _require = index$2.__require(),
+	      cursor = _require.cursor;
+
+	const Prompt = prompt.__require();
+
+	const _require2 = index$1.__require(),
+	      clear = _require2.clear,
+	      figures = _require2.figures,
+	      style = _require2.style,
+	      wrap = _require2.wrap,
+	      entriesToDisplay = _require2.entriesToDisplay;
+	/**
+	 * MultiselectPrompt Base Element
+	 * @param {Object} opts Options
+	 * @param {String} opts.message Message
+	 * @param {Array} opts.choices Array of choice objects
+	 * @param {String} [opts.hint] Hint to display
+	 * @param {String} [opts.warn] Hint shown for disabled choices
+	 * @param {Number} [opts.max] Max choices
+	 * @param {Number} [opts.cursor=0] Cursor start position
+	 * @param {Number} [opts.optionsPerPage=10] Max options to display at once
+	 * @param {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 */
+
+
+	class MultiselectPrompt extends Prompt {
+	  constructor(opts = {}) {
+	    super(opts);
+	    this.msg = opts.message;
+	    this.cursor = opts.cursor || 0;
+	    this.scrollIndex = opts.cursor || 0;
+	    this.hint = opts.hint || '';
+	    this.warn = opts.warn || '- This option is disabled -';
+	    this.minSelected = opts.min;
+	    this.showMinError = false;
+	    this.maxChoices = opts.max;
+	    this.instructions = opts.instructions;
+	    this.optionsPerPage = opts.optionsPerPage || 10;
+	    this.value = opts.choices.map((ch, idx) => {
+	      if (typeof ch === 'string') ch = {
+	        title: ch,
+	        value: idx
+	      };
+	      return {
+	        title: ch && (ch.title || ch.value || ch),
+	        description: ch && ch.description,
+	        value: ch && (ch.value === undefined ? idx : ch.value),
+	        selected: ch && ch.selected,
+	        disabled: ch && ch.disabled
+	      };
+	    });
+	    this.clear = clear('', this.out.columns);
+
+	    if (!opts.overrideRender) {
+	      this.render();
+	    }
+	  }
+
+	  reset() {
+	    this.value.map(v => !v.selected);
+	    this.cursor = 0;
+	    this.fire();
+	    this.render();
+	  }
+
+	  selected() {
+	    return this.value.filter(v => v.selected);
+	  }
+
+	  exit() {
+	    this.abort();
+	  }
+
+	  abort() {
+	    this.done = this.aborted = true;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  submit() {
+	    const selected = this.value.filter(e => e.selected);
+
+	    if (this.minSelected && selected.length < this.minSelected) {
+	      this.showMinError = true;
+	      this.render();
+	    } else {
+	      this.done = true;
+	      this.aborted = false;
+	      this.fire();
+	      this.render();
+	      this.out.write('\n');
+	      this.close();
+	    }
+	  }
+
+	  first() {
+	    this.cursor = 0;
+	    this.render();
+	  }
+
+	  last() {
+	    this.cursor = this.value.length - 1;
+	    this.render();
+	  }
+
+	  next() {
+	    this.cursor = (this.cursor + 1) % this.value.length;
+	    this.render();
+	  }
+
+	  up() {
+	    if (this.cursor === 0) {
+	      this.cursor = this.value.length - 1;
+	    } else {
+	      this.cursor--;
+	    }
+
+	    this.render();
+	  }
+
+	  down() {
+	    if (this.cursor === this.value.length - 1) {
+	      this.cursor = 0;
+	    } else {
+	      this.cursor++;
+	    }
+
+	    this.render();
+	  }
+
+	  left() {
+	    this.value[this.cursor].selected = false;
+	    this.render();
+	  }
+
+	  right() {
+	    if (this.value.filter(e => e.selected).length >= this.maxChoices) return this.bell();
+	    this.value[this.cursor].selected = true;
+	    this.render();
+	  }
+
+	  handleSpaceToggle() {
+	    const v = this.value[this.cursor];
+
+	    if (v.selected) {
+	      v.selected = false;
+	      this.render();
+	    } else if (v.disabled || this.value.filter(e => e.selected).length >= this.maxChoices) {
+	      return this.bell();
+	    } else {
+	      v.selected = true;
+	      this.render();
+	    }
+	  }
+
+	  toggleAll() {
+	    if (this.maxChoices !== undefined || this.value[this.cursor].disabled) {
+	      return this.bell();
+	    }
+
+	    const newSelected = !this.value[this.cursor].selected;
+	    this.value.filter(v => !v.disabled).forEach(v => v.selected = newSelected);
+	    this.render();
+	  }
+
+	  _(c, key) {
+	    if (c === ' ') {
+	      this.handleSpaceToggle();
+	    } else if (c === 'a') {
+	      this.toggleAll();
+	    } else {
+	      return this.bell();
+	    }
+	  }
+
+	  renderInstructions() {
+	    if (this.instructions === undefined || this.instructions) {
+	      if (typeof this.instructions === 'string') {
+	        return this.instructions;
+	      }
+
+	      return '\nInstructions:\n' + `    ${figures.arrowUp}/${figures.arrowDown}: Highlight option\n` + `    ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection\n` + (this.maxChoices === undefined ? `    a: Toggle all\n` : '') + `    enter/return: Complete answer`;
+	    }
+
+	    return '';
+	  }
+
+	  renderOption(cursor, v, i, arrowIndicator) {
+	    const prefix = (v.selected ? color.green(figures.radioOn) : figures.radioOff) + ' ' + arrowIndicator + ' ';
+	    let title, desc;
+
+	    if (v.disabled) {
+	      title = cursor === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+	    } else {
+	      title = cursor === i ? color.cyan().underline(v.title) : v.title;
+
+	      if (cursor === i && v.description) {
+	        desc = ` - ${v.description}`;
+
+	        if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+	          desc = '\n' + wrap(v.description, {
+	            margin: prefix.length,
+	            width: this.out.columns
+	          });
+	        }
+	      }
+	    }
+
+	    return prefix + title + color.gray(desc || '');
+	  } // shared with autocompleteMultiselect
+
+
+	  paginateOptions(options) {
+	    if (options.length === 0) {
+	      return color.red('No matches for this query.');
+	    }
+
+	    let _entriesToDisplay = entriesToDisplay(this.cursor, options.length, this.optionsPerPage),
+	        startIndex = _entriesToDisplay.startIndex,
+	        endIndex = _entriesToDisplay.endIndex;
+
+	    let prefix,
+	        styledOptions = [];
+
+	    for (let i = startIndex; i < endIndex; i++) {
+	      if (i === startIndex && startIndex > 0) {
+	        prefix = figures.arrowUp;
+	      } else if (i === endIndex - 1 && endIndex < options.length) {
+	        prefix = figures.arrowDown;
+	      } else {
+	        prefix = ' ';
+	      }
+
+	      styledOptions.push(this.renderOption(this.cursor, options[i], i, prefix));
+	    }
+
+	    return '\n' + styledOptions.join('\n');
+	  } // shared with autocomleteMultiselect
+
+
+	  renderOptions(options) {
+	    if (!this.done) {
+	      return this.paginateOptions(options);
+	    }
+
+	    return '';
+	  }
+
+	  renderDoneOrInstructions() {
+	    if (this.done) {
+	      return this.value.filter(e => e.selected).map(v => v.title).join(', ');
+	    }
+
+	    const output = [color.gray(this.hint), this.renderInstructions()];
+
+	    if (this.value[this.cursor].disabled) {
+	      output.push(color.yellow(this.warn));
+	    }
+
+	    return output.join(' ');
+	  }
+
+	  render() {
+	    if (this.closed) return;
+	    if (this.firstRender) this.out.write(cursor.hide);
+	    super.render(); // print prompt
+
+	    let prompt = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.renderDoneOrInstructions()].join(' ');
+
+	    if (this.showMinError) {
+	      prompt += color.red(`You must select a minimum of ${this.minSelected} choices.`);
+	      this.showMinError = false;
+	    }
+
+	    prompt += this.renderOptions(this.value);
+	    this.out.write(this.clear + prompt);
+	    this.clear = clear(prompt, this.out.columns);
+	  }
+
+	}
+
+	multiselect = MultiselectPrompt;
+	return multiselect;
+}
+
+exports.__require = requireMultiselect;