@quilted/create 0.1.55 → 0.1.57

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

@@ -0,0 +1,191 @@
+'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 select;
+var hasRequiredSelect;
+
+function requireSelect () {
+	if (hasRequiredSelect) return select;
+	hasRequiredSelect = 1;
+
+	const color = index.__require();
+	const Prompt = prompt.__require();
+	const { style, clear, figures, wrap, entriesToDisplay } = index$1.__require();
+	const { cursor } = index$2.__require();
+
+	/**
+	 * 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 { startIndex, endIndex } = entriesToDisplay(this.cursor, this.choices.length, this.optionsPerPage);
+
+	    // 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;
+}
+
+exports.__require = requireSelect;

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

@@ -0,0 +1,225 @@
+'use strict';
+
+var index = require('../../../../../kleur@3.0.3/node_modules/kleur/index.cjs');
+var prompt = require('./prompt.cjs');
+var index$2 = require('../../../../../sisteransi@1.0.5/node_modules/sisteransi/src/index.cjs');
+var index$1 = require('../util/index.cjs');
+
+var text;
+var hasRequiredText;
+
+function requireText () {
+	if (hasRequiredText) return text;
+	hasRequiredText = 1;
+	const color = index.__require();
+	const Prompt = prompt.__require();
+	const { erase, cursor } = index$2.__require();
+	const { style, clear, lines, figures } = index$1.__require();
+
+	/**
+	 * TextPrompt Base Element
+	 * @param {Object} opts Options
+	 * @param {String} opts.message Message
+	 * @param {String} [opts.style='default'] Render style
+	 * @param {String} [opts.initial] Default value
+	 * @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 TextPrompt extends Prompt {
+	  constructor(opts={}) {
+	    super(opts);
+	    this.transform = style.render(opts.style);
+	    this.scale = this.transform.scale;
+	    this.msg = opts.message;
+	    this.initial = opts.initial || ``;
+	    this.validator = opts.validate || (() => true);
+	    this.value = ``;
+	    this.errorMsg = opts.error || `Please Enter A Valid Value`;
+	    this.cursor = Number(!!this.initial);
+	    this.cursorOffset = 0;
+	    this.clear = clear(``, this.out.columns);
+	    this.render();
+	  }
+
+	  set value(v) {
+	    if (!v && this.initial) {
+	      this.placeholder = true;
+	      this.rendered = color.gray(this.transform.render(this.initial));
+	    } else {
+	      this.placeholder = false;
+	      this.rendered = this.transform.render(v);
+	    }
+	    this._value = v;
+	    this.fire();
+	  }
+
+	  get value() {
+	    return this._value;
+	  }
+
+	  reset() {
+	    this.value = ``;
+	    this.cursor = Number(!!this.initial);
+	    this.cursorOffset = 0;
+	    this.fire();
+	    this.render();
+	  }
+
+	  exit() {
+	    this.abort();
+	  }
+
+	  abort() {
+	    this.value = this.value || this.initial;
+	    this.done = this.aborted = true;
+	    this.error = false;
+	    this.red = 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() {
+	    this.value = this.value || this.initial;
+	    this.cursorOffset = 0;
+	    this.cursor = this.rendered.length;
+	    await this.validate();
+	    if (this.error) {
+	      this.red = true;
+	      this.fire();
+	      this.render();
+	      return;
+	    }
+	    this.done = true;
+	    this.aborted = false;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  next() {
+	    if (!this.placeholder) return this.bell();
+	    this.value = this.initial;
+	    this.cursor = this.rendered.length;
+	    this.fire();
+	    this.render();
+	  }
+
+	  moveCursor(n) {
+	    if (this.placeholder) return;
+	    this.cursor = this.cursor+n;
+	    this.cursorOffset += n;
+	  }
+
+	  _(c, key) {
+	    let s1 = this.value.slice(0, this.cursor);
+	    let s2 = this.value.slice(this.cursor);
+	    this.value = `${s1}${c}${s2}`;
+	    this.red = false;
+	    this.cursor = this.placeholder ? 0 : s1.length+1;
+	    this.render();
+	  }
+
+	  delete() {
+	    if (this.isCursorAtStart()) return this.bell();
+	    let s1 = this.value.slice(0, this.cursor-1);
+	    let s2 = this.value.slice(this.cursor);
+	    this.value = `${s1}${s2}`;
+	    this.red = false;
+	    if (this.isCursorAtStart()) {
+	      this.cursorOffset = 0;
+	    } else {
+	      this.cursorOffset++;
+	      this.moveCursor(-1);
+	    }
+	    this.render();
+	  }
+
+	  deleteForward() {
+	    if(this.cursor*this.scale >= this.rendered.length || this.placeholder) return this.bell();
+	    let s1 = this.value.slice(0, this.cursor);
+	    let s2 = this.value.slice(this.cursor+1);
+	    this.value = `${s1}${s2}`;
+	    this.red = false;
+	    if (this.isCursorAtEnd()) {
+	      this.cursorOffset = 0;
+	    } else {
+	      this.cursorOffset++;
+	    }
+	    this.render();
+	  }
+
+	  first() {
+	    this.cursor = 0;
+	    this.render();
+	  }
+
+	  last() {
+	    this.cursor = this.value.length;
+	    this.render();
+	  }
+
+	  left() {
+	    if (this.cursor <= 0 || this.placeholder) return this.bell();
+	    this.moveCursor(-1);
+	    this.render();
+	  }
+
+	  right() {
+	    if (this.cursor*this.scale >= this.rendered.length || this.placeholder) return this.bell();
+	    this.moveCursor(1);
+	    this.render();
+	  }
+
+	  isCursorAtStart() {
+	    return this.cursor === 0 || (this.placeholder && this.cursor === 1);
+	  }
+
+	  isCursorAtEnd() {
+	    return this.cursor === this.rendered.length || (this.placeholder && this.cursor === this.rendered.length + 1)
+	  }
+
+	  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 = '';
+
+	    this.outputText = [
+	      style.symbol(this.done, this.aborted),
+	      color.bold(this.msg),
+	      style.delimiter(this.done),
+	      this.red ? color.red(this.rendered) : this.rendered
+	    ].join(` `);
+
+	    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 + cursor.move(this.cursorOffset, 0));
+	  }
+	}
+
+	text = TextPrompt;
+	return text;
+}
+
+exports.__require = requireText;

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

@@ -0,0 +1,135 @@
+'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 toggle;
+var hasRequiredToggle;
+
+function requireToggle () {
+	if (hasRequiredToggle) return toggle;
+	hasRequiredToggle = 1;
+	const color = index.__require();
+	const Prompt = prompt.__require();
+	const { style, clear } = index$1.__require();
+	const { cursor, erase } = index$2.__require();
+
+	/**
+	 * TogglePrompt Base Element
+	 * @param {Object} opts Options
+	 * @param {String} opts.message Message
+	 * @param {Boolean} [opts.initial=false] Default value
+	 * @param {String} [opts.active='no'] Active label
+	 * @param {String} [opts.inactive='off'] Inactive label
+	 * @param {Stream} [opts.stdin] The Readable stream to listen to
+	 * @param {Stream} [opts.stdout] The Writable stream to write readline data to
+	 */
+	class TogglePrompt extends Prompt {
+	  constructor(opts={}) {
+	    super(opts);
+	    this.msg = opts.message;
+	    this.value = !!opts.initial;
+	    this.active = opts.active || 'on';
+	    this.inactive = opts.inactive || 'off';
+	    this.initialValue = this.value;
+	    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.done = true;
+	    this.aborted = false;
+	    this.fire();
+	    this.render();
+	    this.out.write('\n');
+	    this.close();
+	  }
+
+	  deactivate() {
+	    if (this.value === false) return this.bell();
+	    this.value = false;
+	    this.render();
+	  }
+
+	  activate() {
+	    if (this.value === true) return this.bell();
+	    this.value = true;
+	    this.render();
+	  }
+
+	  delete() {
+	    this.deactivate();
+	  }
+	  left() {
+	    this.deactivate();
+	  }
+	  right() {
+	    this.activate();
+	  }
+	  down() {
+	    this.deactivate();
+	  }
+	  up() {
+	    this.activate();
+	  }
+
+	  next() {
+	    this.value = !this.value;
+	    this.fire();
+	    this.render();
+	  }
+
+	  _(c, key) {
+	    if (c === ' ') {
+	      this.value = !this.value;
+	    } else if (c === '1') {
+	      this.value = true;
+	    } else if (c === '0') {
+	      this.value = false;
+	    } else return this.bell();
+	    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();
+
+	    this.outputText = [
+	      style.symbol(this.done, this.aborted),
+	      color.bold(this.msg),
+	      style.delimiter(this.done),
+	      this.value ? this.inactive : color.cyan().underline(this.inactive),
+	      color.gray('/'),
+	      this.value ? color.cyan().underline(this.active) : this.active
+	    ].join(' ');
+
+	    this.out.write(erase.line + cursor.to(0) + this.outputText);
+	  }
+	}
+
+	toggle = TogglePrompt;
+	return toggle;
+}
+
+exports.__require = requireToggle;

package/build/cjs/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/index.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+var prompts = require('./prompts.cjs');
+
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+
+	const prompts$1 = prompts.__require();
+
+	const passOn = ['suggest', 'format', 'onState', 'validate', 'onRender', 'type'];
+	const noop = () => {};
+
+	/**
+	 * Prompt for a series of questions
+	 * @param {Array|Object} questions Single question object or Array of question objects
+	 * @param {Function} [onSubmit] Callback function called on prompt submit
+	 * @param {Function} [onCancel] Callback function called on cancel/abort
+	 * @returns {Object} Object with values from user input
+	 */
+	async function prompt(questions=[], { onSubmit=noop, onCancel=noop }={}) {
+	  const answers = {};
+	  const override = prompt._override || {};
+	  questions = [].concat(questions);
+	  let answer, question, quit, name, type, lastPrompt;
+
+	  const getFormattedAnswer = async (question, answer, skipValidation = false) => {
+	    if (!skipValidation && question.validate && question.validate(answer) !== true) {
+	      return;
+	    }
+	    return question.format ? await question.format(answer, answers) : answer
+	  };
+
+	  for (question of questions) {
+	    ({ name, type } = question);
+
+	    // evaluate type first and skip if type is a falsy value
+	    if (typeof type === 'function') {
+	      type = await type(answer, { ...answers }, question);
+	      question['type'] = type;
+	    }
+	    if (!type) continue;
+
+	    // if property is a function, invoke it unless it's a special function
+	    for (let key in question) {
+	      if (passOn.includes(key)) continue;
+	      let value = question[key];
+	      question[key] = typeof value === 'function' ? await value(answer, { ...answers }, lastPrompt) : value;
+	    }
+
+	    lastPrompt = question;
+
+	    if (typeof question.message !== 'string') {
+	      throw new Error('prompt message is required');
+	    }
+
+	    // update vars in case they changed
+	    ({ name, type } = question);
+
+	    if (prompts$1[type] === void 0) {
+	      throw new Error(`prompt type (${type}) is not defined`);
+	    }
+
+	    if (override[question.name] !== undefined) {
+	      answer = await getFormattedAnswer(question, override[question.name]);
+	      if (answer !== undefined) {
+	        answers[name] = answer;
+	        continue;
+	      }
+	    }
+
+	    try {
+	      // Get the injected answer if there is one or prompt the user
+	      answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts$1[type](question);
+	      answers[name] = answer = await getFormattedAnswer(question, answer, true);
+	      quit = await onSubmit(question, answer, answers);
+	    } catch (err) {
+	      quit = !(await onCancel(question, answers));
+	    }
+
+	    if (quit) return answers;
+	  }
+
+	  return answers;
+	}
+
+	function getInjectedAnswer(injected, deafultValue) {
+	  const answer = injected.shift();
+	    if (answer instanceof Error) {
+	      throw answer;
+	    }
+
+	    return (answer === undefined) ? deafultValue : answer;
+	}
+
+	function inject(answers) {
+	  prompt._injected = (prompt._injected || []).concat(answers);
+	}
+
+	function override(answers) {
+	  prompt._override = Object.assign({}, answers);
+	}
+
+	lib = Object.assign(prompt, { prompt, prompts: prompts$1, inject, override });
+	return lib;
+}
+
+exports.__require = requireLib;