@dotenvx/next-env 1.74.2 → 1.74.3

package/node_modules/enquirer/index.d.ts

@@ -0,0 +1,156 @@
+import { EventEmitter } from "events";
+
+interface BasePromptOptions {
+  name: string | (() => string)
+  type: string | (() => string)
+  message: string | (() => string) | (() => Promise<string>)
+  prefix?: string
+  initial?: any
+  required?: boolean
+  enabled?: boolean | string
+  disabled?: boolean | string
+  format?(value: string): string | Promise<string>
+  result?(value: string): string | Promise<string>
+  skip?: ((state: object) => boolean | Promise<boolean>) | boolean
+  validate?(value: string): boolean | string | Promise<boolean | string>
+  onSubmit?(name: string, value: any, prompt: Enquirer.Prompt): boolean | Promise<boolean>
+  onCancel?(name: string, value: any, prompt: Enquirer.Prompt): boolean | Promise<boolean>
+  stdin?: NodeJS.ReadStream
+  stdout?: NodeJS.WriteStream
+}
+
+interface Choice {
+  name: string
+  message?: string
+  value?: unknown
+  hint?: string
+  role?: string
+  enabled?: boolean
+  disabled?: boolean | string
+}
+
+interface ArrayPromptOptions extends BasePromptOptions {
+  type:
+    | 'autocomplete'
+    | 'editable'
+    | 'form'
+    | 'multiselect'
+    | 'select'
+    | 'survey'
+    | 'list'
+    | 'scale'
+  choices: (string | Choice)[]
+  maxChoices?: number
+  multiple?: boolean
+  initial?: number
+  delay?: number
+  separator?: boolean
+  sort?: boolean
+  linebreak?: boolean
+  edgeLength?: number
+  align?: 'left' | 'right'
+  scroll?: boolean
+}
+
+interface BooleanPromptOptions extends BasePromptOptions {
+  type: 'confirm'
+  initial?: boolean
+}
+
+interface StringPromptOptions extends BasePromptOptions {
+  type: 'input' | 'invisible' | 'list' | 'password' | 'text'
+  initial?: string
+  multiline?: boolean
+}
+
+interface NumberPromptOptions extends BasePromptOptions {
+  type: 'numeral'
+  min?: number
+  max?: number
+  delay?: number
+  float?: boolean
+  round?: boolean
+  major?: number
+  minor?: number
+  initial?: number
+}
+
+interface SnippetPromptOptions extends BasePromptOptions {
+  type: 'snippet'
+  newline?: string
+  template?: string
+}
+
+interface SortPromptOptions extends BasePromptOptions {
+  type: 'sort'
+  hint?: string
+  drag?: boolean
+  numbered?: boolean
+}
+
+type PromptOptions =
+  | BasePromptOptions
+  | ArrayPromptOptions
+  | BooleanPromptOptions
+  | StringPromptOptions
+  | NumberPromptOptions
+  | SnippetPromptOptions
+  | SortPromptOptions
+
+declare class BasePrompt extends EventEmitter {
+    constructor(options?: PromptOptions);
+
+    render(): void;
+
+    run(): Promise<any>;
+  }
+
+declare class Enquirer<T = object> extends EventEmitter {
+  constructor(options?: object, answers?: T);
+
+  /**
+   * Register a custom prompt type.
+   *
+   * @param type
+   * @param fn `Prompt` class, or a function that returns a `Prompt` class.
+   */
+  register(type: string, fn: typeof BasePrompt | (() => typeof BasePrompt)): this;
+
+  /**
+   * Register a custom prompt type.
+   */
+  register(type: { [key: string]: typeof BasePrompt | (() => typeof BasePrompt) }): this;
+
+  /**
+   * Prompt function that takes a "question" object or array of question objects,
+   * and returns an object with responses from the user.
+   *
+   * @param questions Options objects for one or more prompts to run.
+   */
+  prompt(
+    questions:
+      | PromptOptions
+      | ((this: Enquirer) => PromptOptions)
+      | (PromptOptions | ((this: Enquirer) => PromptOptions))[]
+  ): Promise<T>;
+
+  /**
+   * Use an enquirer plugin.
+   *
+   * @param plugin Plugin function that takes an instance of Enquirer.
+   */
+  use(plugin: (this: this, enquirer: this) => void): this;
+}
+
+declare namespace Enquirer {
+  function prompt<T = object>(
+    questions:
+      | PromptOptions
+      | ((this: Enquirer) => PromptOptions)
+      | (PromptOptions | ((this: Enquirer) => PromptOptions))[]
+  ): Promise<T>;
+
+  class Prompt extends BasePrompt {}
+}
+
+export = Enquirer;

package/node_modules/enquirer/index.js

@@ -0,0 +1,254 @@
+'use strict';
+
+const assert = require('assert');
+const Events = require('events');
+const utils = require('./lib/utils');
+
+/**
+ * Create an instance of `Enquirer`.
+ *
+ * ```js
+ * const Enquirer = require('enquirer');
+ * const enquirer = new Enquirer();
+ * ```
+ * @name Enquirer
+ * @param {Object} `options` (optional) Options to use with all prompts.
+ * @param {Object} `answers` (optional) Answers object to initialize with.
+ * @api public
+ */
+
+class Enquirer extends Events {
+  constructor(options, answers) {
+    super();
+    this.options = utils.merge({}, options);
+    this.answers = { ...answers };
+  }
+
+  /**
+   * Register a custom prompt type.
+   *
+   * ```js
+   * const Enquirer = require('enquirer');
+   * const enquirer = new Enquirer();
+   * enquirer.register('customType', require('./custom-prompt'));
+   * ```
+   * @name register()
+   * @param {String} `type`
+   * @param {Function|Prompt} `fn` `Prompt` class, or a function that returns a `Prompt` class.
+   * @return {Object} Returns the Enquirer instance
+   * @api public
+   */
+
+  register(type, fn) {
+    if (utils.isObject(type)) {
+      for (let key of Object.keys(type)) this.register(key, type[key]);
+      return this;
+    }
+
+    assert.equal(typeof fn, 'function', 'expected a function');
+    const name = type.toLowerCase();
+
+    if (fn.prototype instanceof this.Prompt) {
+      this.prompts[name] = fn;
+    } else {
+      this.prompts[name] = fn(this.Prompt, this);
+    }
+
+    return this;
+  }
+
+  /**
+   * Prompt function that takes a "question" object or array of question objects,
+   * and returns an object with responses from the user.
+   *
+   * ```js
+   * const Enquirer = require('enquirer');
+   * const enquirer = new Enquirer();
+   *
+   * const response = await enquirer.prompt({
+   *   type: 'input',
+   *   name: 'username',
+   *   message: 'What is your username?'
+   * });
+   * console.log(response);
+   * ```
+   * @name prompt()
+   * @param {Array|Object} `questions` Options objects for one or more prompts to run.
+   * @return {Promise} Promise that returns an "answers" object with the user's responses.
+   * @api public
+   */
+
+  async prompt(questions = []) {
+    for (let question of [].concat(questions)) {
+      try {
+        if (typeof question === 'function') question = await question.call(this);
+        await this.ask(utils.merge({}, this.options, question));
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+    return this.answers;
+  }
+
+  async ask(question) {
+    if (typeof question === 'function') {
+      question = await question.call(this);
+    }
+
+    let opts = utils.merge({}, this.options, question);
+    let { type, name } = question;
+    let { set, get } = utils;
+
+    if (typeof type === 'function') {
+      type = await type.call(this, question, this.answers);
+    }
+
+    if (!type) return this.answers[name];
+    if (type === 'number') type = 'numeral';
+
+    assert(this.prompts[type], `Prompt "${type}" is not registered`);
+
+    let prompt = new this.prompts[type](opts);
+    let value = get(this.answers, name);
+
+    prompt.state.answers = this.answers;
+    prompt.enquirer = this;
+
+    if (name) {
+      prompt.on('submit', value => {
+        this.emit('answer', name, value, prompt);
+        set(this.answers, name, value);
+      });
+    }
+
+    // bubble events
+    let emit = prompt.emit.bind(prompt);
+    prompt.emit = (...args) => {
+      this.emit.call(this, ...args);
+      return emit(...args);
+    };
+
+    this.emit('prompt', prompt, this);
+
+    if (opts.autofill && value != null) {
+      prompt.value = prompt.input = value;
+
+      // if "autofill=show" render the prompt, otherwise stay "silent"
+      if (opts.autofill === 'show') {
+        await prompt.submit();
+      }
+    } else {
+      value = prompt.value = await prompt.run();
+    }
+
+    return value;
+  }
+
+  /**
+   * Use an enquirer plugin.
+   *
+   * ```js
+   * const Enquirer = require('enquirer');
+   * const enquirer = new Enquirer();
+   * const plugin = enquirer => {
+   *   // do stuff to enquire instance
+   * };
+   * enquirer.use(plugin);
+   * ```
+   * @name use()
+   * @param {Function} `plugin` Plugin function that takes an instance of Enquirer.
+   * @return {Object} Returns the Enquirer instance.
+   * @api public
+   */
+
+  use(plugin) {
+    plugin.call(this, this);
+    return this;
+  }
+
+  set Prompt(value) {
+    this._Prompt = value;
+  }
+  get Prompt() {
+    return this._Prompt || this.constructor.Prompt;
+  }
+
+  get prompts() {
+    return this.constructor.prompts;
+  }
+
+  static set Prompt(value) {
+    this._Prompt = value;
+  }
+  static get Prompt() {
+    return this._Prompt || require('./lib/prompt');
+  }
+
+  static get prompts() {
+    return require('./lib/prompts');
+  }
+
+  static get types() {
+    return require('./lib/types');
+  }
+
+  /**
+   * Prompt function that takes a "question" object or array of question objects,
+   * and returns an object with responses from the user.
+   *
+   * ```js
+   * const { prompt } = require('enquirer');
+   * const response = await prompt({
+   *   type: 'input',
+   *   name: 'username',
+   *   message: 'What is your username?'
+   * });
+   * console.log(response);
+   * ```
+   * @name Enquirer#prompt
+   * @param {Array|Object} `questions` Options objects for one or more prompts to run.
+   * @return {Promise} Promise that returns an "answers" object with the user's responses.
+   * @api public
+   */
+
+  static get prompt() {
+    const fn = (questions, ...rest) => {
+      let enquirer = new this(...rest);
+      let emit = enquirer.emit.bind(enquirer);
+      enquirer.emit = (...args) => {
+        fn.emit(...args);
+        return emit(...args);
+      };
+      return enquirer.prompt(questions);
+    };
+    utils.mixinEmitter(fn, new Events());
+    return fn;
+  }
+}
+
+utils.mixinEmitter(Enquirer, new Events());
+const prompts = Enquirer.prompts;
+
+for (let name of Object.keys(prompts)) {
+  let key = name.toLowerCase();
+
+  let run = options => new prompts[name](options).run();
+  Enquirer.prompt[key] = run;
+  Enquirer[key] = run;
+
+  if (!Enquirer[name]) {
+    Reflect.defineProperty(Enquirer, name, { get: () => prompts[name] });
+  }
+}
+
+const define = name => {
+  utils.defineExport(Enquirer, name, () => Enquirer.types[name]);
+};
+
+define('ArrayPrompt');
+define('AuthPrompt');
+define('BooleanPrompt');
+define('NumberPrompt');
+define('StringPrompt');
+
+module.exports = Enquirer;

package/node_modules/enquirer/lib/ansi.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const isTerm = process.env.TERM_PROGRAM === 'Apple_Terminal';
+const stripAnsi = require('strip-ansi');
+const utils = require('./utils');
+const ansi = module.exports = exports;
+const ESC = '\u001b[';
+const BEL = '\u0007';
+let hidden = false;
+
+const code = ansi.code = {
+  bell: BEL,
+  beep: BEL,
+  beginning: `${ESC}G`,
+  down: `${ESC}J`,
+  esc: ESC,
+  getPosition: `${ESC}6n`,
+  hide: `${ESC}?25l`,
+  line: `${ESC}2K`,
+  lineEnd: `${ESC}K`,
+  lineStart: `${ESC}1K`,
+  restorePosition: ESC + (isTerm ? '8' : 'u'),
+  savePosition: ESC + (isTerm ? '7' : 's'),
+  screen: `${ESC}2J`,
+  show: `${ESC}?25h`,
+  up: `${ESC}1J`
+};
+
+const cursor = ansi.cursor = {
+  get hidden() {
+    return hidden;
+  },
+
+  hide() {
+    hidden = true;
+    return code.hide;
+  },
+  show() {
+    hidden = false;
+    return code.show;
+  },
+
+  forward: (count = 1) => `${ESC}${count}C`,
+  backward: (count = 1) => `${ESC}${count}D`,
+  nextLine: (count = 1) => `${ESC}E`.repeat(count),
+  prevLine: (count = 1) => `${ESC}F`.repeat(count),
+
+  up: (count = 1) => count ? `${ESC}${count}A` : '',
+  down: (count = 1) => count ? `${ESC}${count}B` : '',
+  right: (count = 1) => count ? `${ESC}${count}C` : '',
+  left: (count = 1) => count ? `${ESC}${count}D` : '',
+
+  to(x, y) {
+    return y ? `${ESC}${y + 1};${x + 1}H` : `${ESC}${x + 1}G`;
+  },
+
+  move(x = 0, y = 0) {
+    let res = '';
+    res += (x < 0) ? cursor.left(-x) : (x > 0) ? cursor.right(x) : '';
+    res += (y < 0) ? cursor.up(-y) : (y > 0) ? cursor.down(y) : '';
+    return res;
+  },
+  strLen(str) {
+    // to suport chinese
+    var realLength = 0, len = str.length, charCode = -1;
+    for (var i = 0; i < len; i++) {
+      charCode = str.charCodeAt(i);
+      if (charCode >= 0 && charCode <= 128) realLength += 1;
+      else realLength += 2;
+    }
+    return realLength;
+  },
+  restore(state = {}) {
+    let { after, cursor, initial, input, prompt, size, value } = state;
+    initial = utils.isPrimitive(initial) ? String(initial) : '';
+    input = utils.isPrimitive(input) ? String(input) : '';
+    value = utils.isPrimitive(value) ? String(value) : '';
+
+    if (size) {
+      let codes = ansi.cursor.up(size) + ansi.cursor.to(this.strLen(prompt));
+      let diff = input.length - cursor;
+      if (diff > 0) {
+        codes += ansi.cursor.left(diff);
+      }
+      return codes;
+    }
+
+    if (value || after) {
+      let pos = (!input && !!initial) ? - this.strLen(initial) : -this.strLen(input) + cursor;
+      if (after) pos -= this.strLen(after);
+      if (input === '' && initial && !prompt.includes(initial)) {
+        pos += this.strLen(initial);
+      }
+      return ansi.cursor.move(pos);
+    }
+  }
+};
+
+const erase = ansi.erase = {
+  screen: code.screen,
+  up: code.up,
+  down: code.down,
+  line: code.line,
+  lineEnd: code.lineEnd,
+  lineStart: code.lineStart,
+  lines(n) {
+    let str = '';
+    for (let i = 0; i < n; i++) {
+      str += ansi.erase.line + (i < n - 1 ? ansi.cursor.up(1) : '');
+    }
+    if (n) str += ansi.code.beginning;
+    return str;
+  }
+};
+
+ansi.clear = (input = '', columns = process.stdout.columns) => {
+  if (!columns) return erase.line + cursor.to(0);
+  let width = str => [...stripAnsi(str)].length;
+  let lines = input.split(/\r?\n/);
+  let rows = 0;
+  for (let line of lines) {
+    rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / columns);
+  }
+  return (erase.line + cursor.prevLine()).repeat(rows - 1) + erase.line + cursor.to(0);
+};

package/node_modules/enquirer/lib/combos.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * Actions are mappings from keypress event names to method names
+ * in the prompts.
+ */
+
+exports.ctrl = {
+  a: 'first',
+  b: 'backward',
+  c: 'cancel',
+  d: 'deleteForward',
+  e: 'last',
+  f: 'forward',
+  g: 'reset',
+  i: 'tab',
+  k: 'cutForward',
+  l: 'reset',
+  n: 'newItem',
+  m: 'cancel',
+  j: 'submit',
+  p: 'search',
+  r: 'remove',
+  s: 'save',
+  u: 'undo',
+  w: 'cutLeft',
+  x: 'toggleCursor',
+  v: 'paste'
+};
+
+exports.shift = {
+  up: 'shiftUp',
+  down: 'shiftDown',
+  left: 'shiftLeft',
+  right: 'shiftRight',
+  tab: 'prev'
+};
+
+exports.fn = {
+  up: 'pageUp',
+  down: 'pageDown',
+  left: 'pageLeft',
+  right: 'pageRight',
+  delete: 'deleteForward'
+};
+
+// <alt> on Windows
+exports.option = {
+  b: 'backward',
+  f: 'forward',
+  d: 'cutRight',
+  left: 'cutLeft',
+  up: 'altUp',
+  down: 'altDown'
+};
+
+exports.keys = {
+  pageup: 'pageUp', // <fn>+<up> (mac), <Page Up> (windows)
+  pagedown: 'pageDown', // <fn>+<down> (mac), <Page Down> (windows)
+  home: 'home', // <fn>+<left> (mac), <home> (windows)
+  end: 'end', // <fn>+<right> (mac), <end> (windows)
+  cancel: 'cancel',
+  delete: 'deleteForward',
+  backspace: 'delete',
+  down: 'down',
+  enter: 'submit',
+  escape: 'cancel',
+  left: 'left',
+  space: 'space',
+  number: 'number',
+  return: 'submit',
+  right: 'right',
+  tab: 'next',
+  up: 'up'
+};

package/node_modules/enquirer/lib/completer.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const unique = arr => arr.filter((v, i) => arr.lastIndexOf(v) === i);
+const compact = arr => unique(arr).filter(Boolean);
+
+module.exports = (action, data = {}, value = '') => {
+  let { past = [], present = '' } = data;
+  let rest, prev;
+
+  switch (action) {
+    case 'prev':
+    case 'undo':
+      rest = past.slice(0, past.length - 1);
+      prev = past[past.length - 1] || '';
+      return {
+        past: compact([value, ...rest]),
+        present: prev
+      };
+
+    case 'next':
+    case 'redo':
+      rest = past.slice(1);
+      prev = past[0] || '';
+      return {
+        past: compact([...rest, value]),
+        present: prev
+      };
+
+    case 'save':
+      return {
+        past: compact([...past, value]),
+        present: ''
+      };
+
+    case 'remove':
+      prev = compact(past.filter(v => v !== value));
+      present = '';
+
+      if (prev.length) {
+        present = prev.pop();
+      }
+
+      return {
+        past: prev,
+        present
+      };
+
+    default: {
+      throw new Error(`Invalid action: "${action}"`);
+    }
+  }
+};