@quilted/create 0.1.55 → 0.1.57

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocompleteMultiselect.cjs

@@ -0,0 +1,210 @@
+'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 multiselect = require('./multiselect.cjs');
+var index$1 = require('../util/index.cjs');
+
+var autocompleteMultiselect;
+var hasRequiredAutocompleteMultiselect;
+
+function requireAutocompleteMultiselect () {
+	if (hasRequiredAutocompleteMultiselect) return autocompleteMultiselect;
+	hasRequiredAutocompleteMultiselect = 1;
+
+	const color = index.__require();
+	const { cursor } = index$2.__require();
+	const MultiselectPrompt = multiselect.__require();
+	const { clear, style, figures } = index$1.__require();
+	/**
+	 * 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 {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 */
+	class AutocompleteMultiselectPrompt extends MultiselectPrompt {
+	  constructor(opts={}) {
+	    opts.overrideRender = true;
+	    super(opts);
+	    this.inputValue = '';
+	    this.clear = clear('', this.out.columns);
+	    this.filteredOptions = this.value;
+	    this.render();
+	  }
+
+	  last() {
+	    this.cursor = this.filteredOptions.length - 1;
+	    this.render();
+	  }
+	  next() {
+	    this.cursor = (this.cursor + 1) % this.filteredOptions.length;
+	    this.render();
+	  }
+
+	  up() {
+	    if (this.cursor === 0) {
+	      this.cursor = this.filteredOptions.length - 1;
+	    } else {
+	      this.cursor--;
+	    }
+	    this.render();
+	  }
+
+	  down() {
+	    if (this.cursor === this.filteredOptions.length - 1) {
+	      this.cursor = 0;
+	    } else {
+	      this.cursor++;
+	    }
+	    this.render();
+	  }
+
+	  left() {
+	    this.filteredOptions[this.cursor].selected = false;
+	    this.render();
+	  }
+
+	  right() {
+	    if (this.value.filter(e => e.selected).length >= this.maxChoices) return this.bell();
+	    this.filteredOptions[this.cursor].selected = true;
+	    this.render();
+	  }
+
+	  delete() {
+	    if (this.inputValue.length) {
+	      this.inputValue = this.inputValue.substr(0, this.inputValue.length - 1);
+	      this.updateFilteredOptions();
+	    }
+	  }
+
+	  updateFilteredOptions() {
+	    const currentHighlight = this.filteredOptions[this.cursor];
+	    this.filteredOptions = this.value
+	      .filter(v => {
+	        if (this.inputValue) {
+	          if (typeof v.title === 'string') {
+	            if (v.title.toLowerCase().includes(this.inputValue.toLowerCase())) {
+	              return true;
+	            }
+	          }
+	          if (typeof v.value === 'string') {
+	            if (v.value.toLowerCase().includes(this.inputValue.toLowerCase())) {
+	              return true;
+	            }
+	          }
+	          return false;
+	        }
+	        return true;
+	      });
+	    const newHighlightIndex = this.filteredOptions.findIndex(v => v === currentHighlight);
+	    this.cursor = newHighlightIndex < 0 ? 0 : newHighlightIndex;
+	    this.render();
+	  }
+
+	  handleSpaceToggle() {
+	    const v = this.filteredOptions[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();
+	    }
+	  }
+
+	  handleInputChange(c) {
+	    this.inputValue = this.inputValue + c;
+	    this.updateFilteredOptions();
+	  }
+
+	  _(c, key) {
+	    if (c === ' ') {
+	      this.handleSpaceToggle();
+	    } else {
+	      this.handleInputChange(c);
+	    }
+	  }
+
+	  renderInstructions() {
+	    if (this.instructions === undefined || this.instructions) {
+	      if (typeof this.instructions === 'string') {
+	        return this.instructions;
+	      }
+	      return `
+Instructions:
+    ${figures.arrowUp}/${figures.arrowDown}: Highlight option
+    ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
+    [a,b,c]/delete: Filter choices
+    enter/return: Complete answer
+`;
+	    }
+	    return '';
+	  }
+
+	  renderCurrentInput() {
+	    return `
+Filtered results for: ${this.inputValue ? this.inputValue : color.gray('Enter something to filter')}\n`;
+	  }
+
+	  renderOption(cursor, v, i) {
+	    let title;
+	    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;
+	    return (v.selected ? color.green(figures.radioOn) : figures.radioOff) + '  ' + title
+	  }
+
+	  renderDoneOrInstructions() {
+	    if (this.done) {
+	      return this.value
+	        .filter(e => e.selected)
+	        .map(v => v.title)
+	        .join(', ');
+	    }
+
+	    const output = [color.gray(this.hint), this.renderInstructions(), this.renderCurrentInput()];
+
+	    if (this.filteredOptions.length && this.filteredOptions[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.filteredOptions);
+
+	    this.out.write(this.clear + prompt);
+	    this.clear = clear(prompt, this.out.columns);
+	  }
+	}
+
+	autocompleteMultiselect = AutocompleteMultiselectPrompt;
+	return autocompleteMultiselect;
+}
+
+exports.__require = requireAutocompleteMultiselect;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/confirm.cjs

@@ -0,0 +1,106 @@
+'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 confirm;
+var hasRequiredConfirm;
+
+function requireConfirm () {
+	if (hasRequiredConfirm) return confirm;
+	hasRequiredConfirm = 1;
+	const color = index.__require();
+	const Prompt = prompt.__require();
+	const { style, clear } = index$1.__require();
+	const { erase, cursor } = index$2.__require();
+
+	/**
+	 * ConfirmPrompt Base Element
+	 * @param {Object} opts Options
+	 * @param {String} opts.message Message
+	 * @param {Boolean} [opts.initial] Default value (true/false)
+	 * @param {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 * @param {String} [opts.yes] The "Yes" label
+	 * @param {String} [opts.yesOption] The "Yes" option when choosing between yes/no
+	 * @param {String} [opts.no] The "No" label
+	 * @param {String} [opts.noOption] The "No" option when choosing between yes/no
+	 */
+	class ConfirmPrompt extends Prompt {
+	  constructor(opts={}) {
+	    super(opts);
+	    this.msg = opts.message;
+	    this.value = opts.initial;
+	    this.initialValue = !!opts.initial;
+	    this.yesMsg = opts.yes || 'yes';
+	    this.yesOption = opts.yesOption || '(Y/n)';
+	    this.noMsg = opts.no || 'no';
+	    this.noOption = opts.noOption || '(y/N)';
+	    this.render();
+	  }
+
+	  reset() {
+	    this.value = this.initialValue;
+	    this.fire();
+	    this.render();
+	  }
+
+	  exit() {
+	    this.abort();
+	  }
+
+	  abort() {
+	    this.done = this.aborted = true;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  submit() {
+	    this.value = this.value || false;
+	    this.done = true;
+	    this.aborted = false;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  _(c, key) {
+	    if (c.toLowerCase() === 'y') {
+	      this.value = true;
+	      return this.submit();
+	    }
+	    if (c.toLowerCase() === 'n') {
+	      this.value = false;
+	      return this.submit();
+	    }
+	    return this.bell();
+	  }
+
+	  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();
+
+	    this.outputText = [
+	      style.symbol(this.done, this.aborted),
+	      color.bold(this.msg),
+	      style.delimiter(this.done),
+	      this.done ? (this.value ? this.yesMsg : this.noMsg)
+	          : color.gray(this.initialValue ? this.yesOption : this.noOption)
+	    ].join(' ');
+
+	    this.out.write(erase.line + cursor.to(0) + this.outputText);
+	  }
+	}
+
+	confirm = ConfirmPrompt;
+	return confirm;
+}
+
+exports.__require = requireConfirm;

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

@@ -0,0 +1,226 @@
+'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;
+
+	const color = index.__require();
+	const Prompt = prompt.__require();
+	const { style, clear, figures } = index$1.__require();
+	const { erase, cursor } = index$2.__require();
+	const { DatePart, Meridiem, Day, Hours, Milliseconds, Minutes, Month, Seconds, Year } = index$3.__require();
+
+	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();
+	  }
+
+	  async validate() {
+	    let valid = await this.validator(this.value);
+	    if (typeof valid === 'string') {
+	      this.errorMsg = valid;
+	      valid = false;
+	    }
+	    this.error = !valid;
+	  }
+
+	  async submit() {
+	    await this.validate();
+	    if (this.error) {
+	      this.color = 'red';
+	      this.fire();
+	      this.render();
+	      return;
+	    }
+	    this.done = true;
+	    this.aborted = false;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.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/lib/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;