@quilted/create 0.1.56 → 0.1.57

package/build/esnext/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/number.esnext

@@ -0,0 +1,264 @@
+import { __require as requireKleur } from '../../../../../kleur@3.0.3/node_modules/kleur/index.esnext';
+import { __require as requirePrompt } from './prompt.esnext';
+import { __require as requireSrc } from '../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.esnext';
+import { __require as requireUtil } from '../util/index.esnext';
+
+var number;
+var hasRequiredNumber;
+
+function requireNumber () {
+	if (hasRequiredNumber) return number;
+	hasRequiredNumber = 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 = requireKleur();
+
+	const Prompt = requirePrompt();
+
+	const _require = requireSrc(),
+	      cursor = _require.cursor,
+	      erase = _require.erase;
+
+	const _require2 = requireUtil(),
+	      style = _require2.style,
+	      figures = _require2.figures,
+	      clear = _require2.clear,
+	      lines = _require2.lines;
+
+	const isNumber = /[0-9]/;
+
+	const isDef = any => any !== undefined;
+
+	const round = (number, precision) => {
+	  let factor = Math.pow(10, precision);
+	  return Math.round(number * factor) / factor;
+	};
+	/**
+	 * NumberPrompt Base Element
+	 * @param {Object} opts Options
+	 * @param {String} opts.message Message
+	 * @param {String} [opts.style='default'] Render style
+	 * @param {Number} [opts.initial] Default value
+	 * @param {Number} [opts.max=+Infinity] Max value
+	 * @param {Number} [opts.min=-Infinity] Min value
+	 * @param {Boolean} [opts.float=false] Parse input as floats
+	 * @param {Number} [opts.round=2] Round floats to x decimals
+	 * @param {Number} [opts.increment=1] Number to increment by when using arrow-keys
+	 * @param {Function} [opts.validate] Validate function
+	 * @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.error] The invalid error label
+	 */
+
+
+	class NumberPrompt extends Prompt {
+	  constructor(opts = {}) {
+	    super(opts);
+	    this.transform = style.render(opts.style);
+	    this.msg = opts.message;
+	    this.initial = isDef(opts.initial) ? opts.initial : '';
+	    this.float = !!opts.float;
+	    this.round = opts.round || 2;
+	    this.inc = opts.increment || 1;
+	    this.min = isDef(opts.min) ? opts.min : -Infinity;
+	    this.max = isDef(opts.max) ? opts.max : Infinity;
+	    this.errorMsg = opts.error || `Please Enter A Valid Value`;
+
+	    this.validator = opts.validate || (() => true);
+
+	    this.color = `cyan`;
+	    this.value = ``;
+	    this.typed = ``;
+	    this.lastHit = 0;
+	    this.render();
+	  }
+
+	  set value(v) {
+	    if (!v && v !== 0) {
+	      this.placeholder = true;
+	      this.rendered = color.gray(this.transform.render(`${this.initial}`));
+	      this._value = ``;
+	    } else {
+	      this.placeholder = false;
+	      this.rendered = this.transform.render(`${round(v, this.round)}`);
+	      this._value = round(v, this.round);
+	    }
+
+	    this.fire();
+	  }
+
+	  get value() {
+	    return this._value;
+	  }
+
+	  parse(x) {
+	    return this.float ? parseFloat(x) : parseInt(x);
+	  }
+
+	  valid(c) {
+	    return c === `-` || c === `.` && this.float || isNumber.test(c);
+	  }
+
+	  reset() {
+	    this.typed = ``;
+	    this.value = ``;
+	    this.fire();
+	    this.render();
+	  }
+
+	  exit() {
+	    this.abort();
+	  }
+
+	  abort() {
+	    let x = this.value;
+	    this.value = x !== `` ? x : this.initial;
+	    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;
+	      }
+
+	      let x = _this2.value;
+	      _this2.value = x !== `` ? x : _this2.initial;
+	      _this2.done = true;
+	      _this2.aborted = false;
+	      _this2.error = false;
+
+	      _this2.fire();
+
+	      _this2.render();
+
+	      _this2.out.write(`\n`);
+
+	      _this2.close();
+	    })();
+	  }
+
+	  up() {
+	    this.typed = ``;
+
+	    if (this.value === '') {
+	      this.value = this.min - this.inc;
+	    }
+
+	    if (this.value >= this.max) return this.bell();
+	    this.value += this.inc;
+	    this.color = `cyan`;
+	    this.fire();
+	    this.render();
+	  }
+
+	  down() {
+	    this.typed = ``;
+
+	    if (this.value === '') {
+	      this.value = this.min + this.inc;
+	    }
+
+	    if (this.value <= this.min) return this.bell();
+	    this.value -= this.inc;
+	    this.color = `cyan`;
+	    this.fire();
+	    this.render();
+	  }
+
+	  delete() {
+	    let val = this.value.toString();
+	    if (val.length === 0) return this.bell();
+	    this.value = this.parse(val = val.slice(0, -1)) || ``;
+
+	    if (this.value !== '' && this.value < this.min) {
+	      this.value = this.min;
+	    }
+
+	    this.color = `cyan`;
+	    this.fire();
+	    this.render();
+	  }
+
+	  next() {
+	    this.value = this.initial;
+	    this.fire();
+	    this.render();
+	  }
+
+	  _(c, key) {
+	    if (!this.valid(c)) return this.bell();
+	    const now = Date.now();
+	    if (now - this.lastHit > 1000) this.typed = ``; // 1s elapsed
+
+	    this.typed += c;
+	    this.lastHit = now;
+	    this.color = `cyan`;
+	    if (c === `.`) return this.fire();
+	    this.value = Math.min(this.parse(this.typed), this.max);
+	    if (this.value > this.max) this.value = this.max;
+	    if (this.value < this.min) this.value = this.min;
+	    this.fire();
+	    this.render();
+	  }
+
+	  render() {
+	    if (this.closed) return;
+
+	    if (!this.firstRender) {
+	      if (this.outputError) this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
+	      this.out.write(clear(this.outputText, this.out.columns));
+	    }
+
+	    super.render();
+	    this.outputError = ''; // Print prompt
+
+	    this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), !this.done || !this.done && !this.placeholder ? color[this.color]().underline(this.rendered) : this.rendered].join(` `); // Print error
+
+	    if (this.error) {
+	      this.outputError += 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 + cursor.save + this.outputError + cursor.restore);
+	  }
+
+	}
+
+	number = NumberPrompt;
+	return number;
+}
+
+export { requireNumber as __require };

package/build/esnext/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/prompt.esnext

@@ -0,0 +1,97 @@
+import require$$0 from 'node:readline';
+import { __require as requireUtil } from '../util/index.esnext';
+import require$$2 from 'node:events';
+import { __require as requireSrc } from '../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.esnext';
+import { __require as requireKleur } from '../../../../../kleur@3.0.3/node_modules/kleur/index.esnext';
+
+var prompt;
+var hasRequiredPrompt;
+
+function requirePrompt () {
+	if (hasRequiredPrompt) return prompt;
+	hasRequiredPrompt = 1;
+
+	const readline = require$$0;
+
+	const _require = requireUtil(),
+	      action = _require.action;
+
+	const EventEmitter = require$$2;
+
+	const _require2 = requireSrc(),
+	      beep = _require2.beep,
+	      cursor = _require2.cursor;
+
+	const color = requireKleur();
+	/**
+	 * Base prompt skeleton
+	 * @param {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 */
+
+
+	class Prompt extends EventEmitter {
+	  constructor(opts = {}) {
+	    super();
+	    this.firstRender = true;
+	    this.in = opts.stdin || process.stdin;
+	    this.out = opts.stdout || process.stdout;
+
+	    this.onRender = (opts.onRender || (() => void 0)).bind(this);
+
+	    const rl = readline.createInterface({
+	      input: this.in,
+	      escapeCodeTimeout: 50
+	    });
+	    readline.emitKeypressEvents(this.in, rl);
+	    if (this.in.isTTY) this.in.setRawMode(true);
+	    const isSelect = ['SelectPrompt', 'MultiselectPrompt'].indexOf(this.constructor.name) > -1;
+
+	    const keypress = (str, key) => {
+	      let a = action(key, isSelect);
+
+	      if (a === false) {
+	        this._ && this._(str, key);
+	      } else if (typeof this[a] === 'function') {
+	        this[a](key);
+	      } else {
+	        this.bell();
+	      }
+	    };
+
+	    this.close = () => {
+	      this.out.write(cursor.show);
+	      this.in.removeListener('keypress', keypress);
+	      if (this.in.isTTY) this.in.setRawMode(false);
+	      rl.close();
+	      this.emit(this.aborted ? 'abort' : this.exited ? 'exit' : 'submit', this.value);
+	      this.closed = true;
+	    };
+
+	    this.in.on('keypress', keypress);
+	  }
+
+	  fire() {
+	    this.emit('state', {
+	      value: this.value,
+	      aborted: !!this.aborted,
+	      exited: !!this.exited
+	    });
+	  }
+
+	  bell() {
+	    this.out.write(beep);
+	  }
+
+	  render() {
+	    this.onRender(color);
+	    if (this.firstRender) this.firstRender = false;
+	  }
+
+	}
+
+	prompt = Prompt;
+	return prompt;
+}
+
+export { requirePrompt as __require };

package/build/esnext/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/select.esnext

@@ -0,0 +1,204 @@
+import { __require as requireKleur } from '../../../../../kleur@3.0.3/node_modules/kleur/index.esnext';
+import { __require as requirePrompt } from './prompt.esnext';
+import { __require as requireUtil } from '../util/index.esnext';
+import { __require as requireSrc } from '../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.esnext';
+
+var select;
+var hasRequiredSelect;
+
+function requireSelect () {
+	if (hasRequiredSelect) return select;
+	hasRequiredSelect = 1;
+
+	const color = requireKleur();
+
+	const Prompt = requirePrompt();
+
+	const _require = requireUtil(),
+	      style = _require.style,
+	      clear = _require.clear,
+	      figures = _require.figures,
+	      wrap = _require.wrap,
+	      entriesToDisplay = _require.entriesToDisplay;
+
+	const _require2 = requireSrc(),
+	      cursor = _require2.cursor;
+	/**
+	 * SelectPrompt 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 {Number} [opts.initial] Index of default value
+	 * @param {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 * @param {Number} [opts.optionsPerPage=10] Max options to display at once
+	 */
+
+
+	class SelectPrompt extends Prompt {
+	  constructor(opts = {}) {
+	    super(opts);
+	    this.msg = opts.message;
+	    this.hint = opts.hint || '- Use arrow-keys. Return to submit.';
+	    this.warn = opts.warn || '- This option is disabled';
+	    this.cursor = opts.initial || 0;
+	    this.choices = opts.choices.map((ch, idx) => {
+	      if (typeof ch === 'string') ch = {
+	        title: ch,
+	        value: idx
+	      };
+	      return {
+	        title: ch && (ch.title || ch.value || ch),
+	        value: ch && (ch.value === undefined ? idx : ch.value),
+	        description: ch && ch.description,
+	        selected: ch && ch.selected,
+	        disabled: ch && ch.disabled
+	      };
+	    });
+	    this.optionsPerPage = opts.optionsPerPage || 10;
+	    this.value = (this.choices[this.cursor] || {}).value;
+	    this.clear = clear('', this.out.columns);
+	    this.render();
+	  }
+
+	  moveCursor(n) {
+	    this.cursor = n;
+	    this.value = this.choices[n].value;
+	    this.fire();
+	  }
+
+	  reset() {
+	    this.moveCursor(0);
+	    this.fire();
+	    this.render();
+	  }
+
+	  exit() {
+	    this.abort();
+	  }
+
+	  abort() {
+	    this.done = this.aborted = true;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  submit() {
+	    if (!this.selection.disabled) {
+	      this.done = true;
+	      this.aborted = false;
+	      this.fire();
+	      this.render();
+	      this.out.write('\n');
+	      this.close();
+	    } else this.bell();
+	  }
+
+	  first() {
+	    this.moveCursor(0);
+	    this.render();
+	  }
+
+	  last() {
+	    this.moveCursor(this.choices.length - 1);
+	    this.render();
+	  }
+
+	  up() {
+	    if (this.cursor === 0) {
+	      this.moveCursor(this.choices.length - 1);
+	    } else {
+	      this.moveCursor(this.cursor - 1);
+	    }
+
+	    this.render();
+	  }
+
+	  down() {
+	    if (this.cursor === this.choices.length - 1) {
+	      this.moveCursor(0);
+	    } else {
+	      this.moveCursor(this.cursor + 1);
+	    }
+
+	    this.render();
+	  }
+
+	  next() {
+	    this.moveCursor((this.cursor + 1) % this.choices.length);
+	    this.render();
+	  }
+
+	  _(c, key) {
+	    if (c === ' ') return this.submit();
+	  }
+
+	  get selection() {
+	    return this.choices[this.cursor];
+	  }
+
+	  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();
+
+	    let _entriesToDisplay = entriesToDisplay(this.cursor, this.choices.length, this.optionsPerPage),
+	        startIndex = _entriesToDisplay.startIndex,
+	        endIndex = _entriesToDisplay.endIndex; // Print prompt
+
+
+	    this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.done ? this.selection.title : this.selection.disabled ? color.yellow(this.warn) : color.gray(this.hint)].join(' '); // Print choices
+
+	    if (!this.done) {
+	      this.outputText += '\n';
+
+	      for (let i = startIndex; i < endIndex; i++) {
+	        let title,
+	            prefix,
+	            desc = '',
+	            v = this.choices[i]; // Determine whether to display "more choices" indicators
+
+	        if (i === startIndex && startIndex > 0) {
+	          prefix = figures.arrowUp;
+	        } else if (i === endIndex - 1 && endIndex < this.choices.length) {
+	          prefix = figures.arrowDown;
+	        } else {
+	          prefix = ' ';
+	        }
+
+	        if (v.disabled) {
+	          title = this.cursor === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+	          prefix = (this.cursor === i ? color.bold().gray(figures.pointer) + ' ' : '  ') + prefix;
+	        } else {
+	          title = this.cursor === i ? color.cyan().underline(v.title) : v.title;
+	          prefix = (this.cursor === i ? color.cyan(figures.pointer) + ' ' : '  ') + prefix;
+
+	          if (v.description && this.cursor === i) {
+	            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: 3,
+	                width: this.out.columns
+	              });
+	            }
+	          }
+	        }
+
+	        this.outputText += `${prefix} ${title}${color.gray(desc)}\n`;
+	      }
+	    }
+
+	    this.out.write(this.outputText);
+	  }
+
+	}
+
+	select = SelectPrompt;
+	return select;
+}
+
+export { requireSelect as __require };