@dotenvx/next-env 1.74.2 → 1.74.3

package/node_modules/enquirer/lib/types/auth.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const FormPrompt = require('../prompts/form');
+
+const defaultAuthenticate = () => {
+  throw new Error('expected prompt to have a custom authenticate method');
+};
+
+const factory = (authenticate = defaultAuthenticate) => {
+
+  class AuthPrompt extends FormPrompt {
+    constructor(options) {
+      super(options);
+    }
+
+    async submit() {
+      this.value = await authenticate.call(this, this.values, this.state);
+      super.base.submit.call(this);
+    }
+
+    static create(authenticate) {
+      return factory(authenticate);
+    }
+  }
+
+  return AuthPrompt;
+};
+
+module.exports = factory();

package/node_modules/enquirer/lib/types/boolean.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const Prompt = require('../prompt');
+const { isPrimitive, hasColor } = require('../utils');
+
+class BooleanPrompt extends Prompt {
+  constructor(options) {
+    super(options);
+    this.cursorHide();
+  }
+
+  async initialize() {
+    let initial = await this.resolve(this.initial, this.state);
+    this.input = await this.cast(initial);
+    await super.initialize();
+  }
+
+  dispatch(ch) {
+    if (!this.isValue(ch)) return this.alert();
+    this.input = ch;
+    return this.submit();
+  }
+
+  format(value) {
+    let { styles, state } = this;
+    return !state.submitted ? styles.primary(value) : styles.success(value);
+  }
+
+  cast(input) {
+    return this.isTrue(input);
+  }
+
+  isTrue(input) {
+    return /^[ty1]/i.test(input);
+  }
+
+  isFalse(input) {
+    return /^[fn0]/i.test(input);
+  }
+
+  isValue(value) {
+    return isPrimitive(value) && (this.isTrue(value) || this.isFalse(value));
+  }
+
+  async hint() {
+    if (this.state.status === 'pending') {
+      let hint = await this.element('hint');
+      if (!hasColor(hint)) {
+        return this.styles.muted(hint);
+      }
+      return hint;
+    }
+  }
+
+  async render() {
+    let { input, size } = this.state;
+
+    let prefix = await this.prefix();
+    let sep = await this.separator();
+    let msg = await this.message();
+    let hint = this.styles.muted(this.default);
+
+    let promptLine = [prefix, msg, hint, sep].filter(Boolean).join(' ');
+    this.state.prompt = promptLine;
+
+    let header = await this.header();
+    let value = this.value = this.cast(input);
+    let output = await this.format(value);
+    let help = (await this.error()) || (await this.hint());
+    let footer = await this.footer();
+
+    if (help && !promptLine.includes(help)) output += ' ' + help;
+    promptLine += ' ' + output;
+
+    this.clear(size);
+    this.write([header, promptLine, footer].filter(Boolean).join('\n'));
+    this.restore();
+  }
+
+  set value(value) {
+    super.value = value;
+  }
+  get value() {
+    return this.cast(super.value);
+  }
+}
+
+module.exports = BooleanPrompt;

package/node_modules/enquirer/lib/types/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  ArrayPrompt: require('./array'),
+  AuthPrompt: require('./auth'),
+  BooleanPrompt: require('./boolean'),
+  NumberPrompt: require('./number'),
+  StringPrompt: require('./string')
+};

package/node_modules/enquirer/lib/types/number.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const StringPrompt = require('./string');
+
+class NumberPrompt extends StringPrompt {
+  constructor(options = {}) {
+    super({ style: 'number', ...options });
+    this.min = this.isValue(options.min) ? this.toNumber(options.min) : -Infinity;
+    this.max = this.isValue(options.max) ? this.toNumber(options.max) : Infinity;
+    this.delay = options.delay != null ? options.delay : 1000;
+    this.float = options.float !== false;
+    this.round = options.round === true || options.float === false;
+    this.major = options.major || 10;
+    this.minor = options.minor || 1;
+    this.initial = options.initial != null ? options.initial : '';
+    this.input = String(this.initial);
+    this.cursor = this.input.length;
+    this.cursorShow();
+  }
+
+  append(ch) {
+    if (!/[-+.]/.test(ch) || (ch === '.' && this.input.includes('.'))) {
+      return this.alert('invalid number');
+    }
+    return super.append(ch);
+  }
+
+  number(ch) {
+    return super.append(ch);
+  }
+
+  next() {
+    if (this.input && this.input !== this.initial) return this.alert();
+    if (!this.isValue(this.initial)) return this.alert();
+    this.input = this.initial;
+    this.cursor = String(this.initial).length;
+    return this.render();
+  }
+
+  up(number) {
+    let step = number || this.minor;
+    let num = this.toNumber(this.input);
+    if (num > this.max + step) return this.alert();
+    this.input = `${num + step}`;
+    return this.render();
+  }
+
+  down(number) {
+    let step = number || this.minor;
+    let num = this.toNumber(this.input);
+    if (num < this.min - step) return this.alert();
+    this.input = `${num - step}`;
+    return this.render();
+  }
+
+  shiftDown() {
+    return this.down(this.major);
+  }
+
+  shiftUp() {
+    return this.up(this.major);
+  }
+
+  format(input = this.input) {
+    if (typeof this.options.format === 'function') {
+      return this.options.format.call(this, input);
+    }
+    return this.styles.info(input);
+  }
+
+  toNumber(value = '') {
+    return this.float ? +value : Math.round(+value);
+  }
+
+  isValue(value) {
+    return /^[-+]?[0-9]+((\.)|(\.[0-9]+))?$/.test(value);
+  }
+
+  submit() {
+    let value = [this.input, this.initial].find(v => this.isValue(v));
+    this.value = this.toNumber(value || 0);
+    return super.submit();
+  }
+}
+
+module.exports = NumberPrompt;

package/node_modules/enquirer/lib/types/string.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const Prompt = require('../prompt');
+const keypress = require('../keypress');
+const placeholder = require('../placeholder');
+const { isPrimitive } = require('../utils');
+
+class StringPrompt extends Prompt {
+  constructor(options) {
+    super(options);
+    this.initial = isPrimitive(this.initial) ? String(this.initial) : '';
+    if (this.initial) this.cursorHide();
+    this.state.prevCursor = 0;
+    this.state.clipboard = [];
+    this.keypressTimeout =
+      this.options.keypressTimeout !== undefined
+        ? this.options.keypressTimeout
+        : null;
+  }
+
+  async keypress(input, key = input ? keypress(input, {}) : {}) {
+    const now = Date.now();
+    const elapsed = now - this.lastKeypress;
+    this.lastKeypress = now;
+
+    const isEnterKey = key.name === 'return' || key.name === 'enter';
+    let prev = this.state.prevKeypress;
+    let append;
+    this.state.prevKeypress = key;
+
+    if (this.keypressTimeout != null && isEnterKey) {
+      if (elapsed < this.keypressTimeout) {
+        return this.submit();
+      }
+
+      this.state.multilineBuffer = this.state.multilineBuffer || '';
+      this.state.multilineBuffer += input;
+      append = true;
+      prev = null;
+    }
+
+    if (append || (this.options.multiline && isEnterKey)) {
+      if (!prev || prev.name !== 'return') {
+        return this.append('\n', key);
+      }
+    }
+
+    return super.keypress(input, key);
+  }
+
+  moveCursor(n) {
+    this.cursor += n;
+  }
+
+  reset() {
+    this.input = this.value = '';
+    this.cursor = 0;
+    return this.render();
+  }
+
+  dispatch(ch, key) {
+    if (!ch || key.ctrl || key.code) return this.alert();
+    this.append(ch);
+  }
+
+  append(ch) {
+    let { cursor, input } = this.state;
+    this.input = `${input}`.slice(0, cursor) + ch + `${input}`.slice(cursor);
+    this.moveCursor(String(ch).length);
+    this.render();
+  }
+
+  insert(str) {
+    this.append(str);
+  }
+
+  delete() {
+    let { cursor, input } = this.state;
+    if (cursor <= 0) return this.alert();
+    this.input = `${input}`.slice(0, cursor - 1) + `${input}`.slice(cursor);
+    this.moveCursor(-1);
+    this.render();
+  }
+
+  deleteForward() {
+    let { cursor, input } = this.state;
+    if (input[cursor] === void 0) return this.alert();
+    this.input = `${input}`.slice(0, cursor) + `${input}`.slice(cursor + 1);
+    this.render();
+  }
+
+  cutForward() {
+    let pos = this.cursor;
+    if (this.input.length <= pos) return this.alert();
+    this.state.clipboard.push(this.input.slice(pos));
+    this.input = this.input.slice(0, pos);
+    this.render();
+  }
+
+  cutLeft() {
+    let pos = this.cursor;
+    if (pos === 0) return this.alert();
+    let before = this.input.slice(0, pos);
+    let after = this.input.slice(pos);
+    let words = before.split(' ');
+    this.state.clipboard.push(words.pop());
+    this.input = words.join(' ');
+    this.cursor = this.input.length;
+    this.input += after;
+    this.render();
+  }
+
+  paste() {
+    if (!this.state.clipboard.length) return this.alert();
+    this.insert(this.state.clipboard.pop());
+    this.render();
+  }
+
+  toggleCursor() {
+    if (this.state.prevCursor) {
+      this.cursor = this.state.prevCursor;
+      this.state.prevCursor = 0;
+    } else {
+      this.state.prevCursor = this.cursor;
+      this.cursor = 0;
+    }
+    this.render();
+  }
+
+  first() {
+    this.cursor = 0;
+    this.render();
+  }
+
+  last() {
+    this.cursor = this.input.length - 1;
+    this.render();
+  }
+
+  next() {
+    let init = this.initial != null ? String(this.initial) : '';
+    if (!init || !init.startsWith(this.input)) return this.alert();
+    this.input = this.initial;
+    this.cursor = this.initial.length;
+    this.render();
+  }
+
+  prev() {
+    if (!this.input) return this.alert();
+    this.reset();
+  }
+
+  backward() {
+    return this.left();
+  }
+
+  forward() {
+    return this.right();
+  }
+
+  right() {
+    if (this.cursor >= this.input.length) return this.alert();
+    this.moveCursor(1);
+    return this.render();
+  }
+
+  left() {
+    if (this.cursor <= 0) return this.alert();
+    this.moveCursor(-1);
+    return this.render();
+  }
+
+  isValue(value) {
+    return !!value;
+  }
+
+  async format(input = this.value) {
+    let initial = await this.resolve(this.initial, this.state);
+    if (!this.state.submitted) {
+      return placeholder(this, { input, initial, pos: this.cursor });
+    }
+    return this.styles.submitted(input || initial);
+  }
+
+  async render() {
+    let size = this.state.size;
+
+    let prefix = await this.prefix();
+    let separator = await this.separator();
+    let message = await this.message();
+
+    let prompt = [prefix, message, separator].filter(Boolean).join(' ');
+    this.state.prompt = prompt;
+
+    let header = await this.header();
+    let output = await this.format();
+    let help = (await this.error()) || (await this.hint());
+    let footer = await this.footer();
+
+    if (help && !output.includes(help)) output += ' ' + help;
+    prompt += ' ' + output;
+
+    this.clear(size);
+    this.write([header, prompt, footer].filter(Boolean).join('\n'));
+    this.restore();
+  }
+}
+
+module.exports = StringPrompt;

package/node_modules/enquirer/lib/utils.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const toString = Object.prototype.toString;
+const colors = require('ansi-colors');
+let onExitCalled = false;
+let onExitCallbacks = new Set();
+
+const complements = {
+  'yellow': 'blue',
+  'cyan': 'red',
+  'green': 'magenta',
+  'black': 'white',
+  'blue': 'yellow',
+  'red': 'cyan',
+  'magenta': 'green',
+  'white': 'black'
+};
+
+exports.longest = (arr, prop) => {
+  return arr.reduce((a, v) => Math.max(a, prop ? v[prop].length : v.length), 0);
+};
+
+exports.hasColor = str => !!str && colors.hasColor(str);
+
+const isObject = exports.isObject = val => {
+  return val !== null && typeof val === 'object' && !Array.isArray(val);
+};
+
+exports.nativeType = val => {
+  return toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, '');
+};
+
+exports.isAsyncFn = val => {
+  return exports.nativeType(val) === 'asyncfunction';
+};
+
+exports.isPrimitive = val => {
+  return val != null && typeof val !== 'object' && typeof val !== 'function';
+};
+
+exports.resolve = (context, value, ...rest) => {
+  if (typeof value === 'function') {
+    return value.call(context, ...rest);
+  }
+  return value;
+};
+
+exports.scrollDown = (choices = []) => [...choices.slice(1), choices[0]];
+exports.scrollUp = (choices = []) => [choices.pop(), ...choices];
+
+exports.reorder = (arr = []) => {
+  let res = arr.slice();
+  res.sort((a, b) => {
+    if (a.index > b.index) return 1;
+    if (a.index < b.index) return -1;
+    return 0;
+  });
+  return res;
+};
+
+exports.swap = (arr, index, pos) => {
+  let len = arr.length;
+  let idx = pos === len ? 0 : pos < 0 ? len - 1 : pos;
+  let choice = arr[index];
+  arr[index] = arr[idx];
+  arr[idx] = choice;
+};
+
+exports.width = (stream, fallback = 80) => {
+  let columns = (stream && stream.columns) ? stream.columns : fallback;
+  if (stream && typeof stream.getWindowSize === 'function') {
+    columns = stream.getWindowSize()[0];
+  }
+  if (process.platform === 'win32') {
+    return columns - 1;
+  }
+  return columns;
+};
+
+exports.height = (stream, fallback = 20) => {
+  let rows = (stream && stream.rows) ? stream.rows : fallback;
+  if (stream && typeof stream.getWindowSize === 'function') {
+    rows = stream.getWindowSize()[1];
+  }
+  return rows;
+};
+
+exports.wordWrap = (str, options = {}) => {
+  if (!str) return str;
+
+  if (typeof options === 'number') {
+    options = { width: options };
+  }
+
+  let { indent = '', newline = ('\n' + indent), width = 80 } = options;
+  let spaces = (newline + indent).match(/[^\S\n]/g) || [];
+  width -= spaces.length;
+  let source = `.{1,${width}}([\\s\\u200B]+|$)|[^\\s\\u200B]+?([\\s\\u200B]+|$)`;
+  let output = str.trim();
+  let regex = new RegExp(source, 'g');
+  let lines = output.match(regex) || [];
+  lines = lines.map(line => line.replace(/\n$/, ''));
+  if (options.padEnd) lines = lines.map(line => line.padEnd(width, ' '));
+  if (options.padStart) lines = lines.map(line => line.padStart(width, ' '));
+  return indent + lines.join(newline);
+};
+
+exports.unmute = color => {
+  let name = color.stack.find(n => colors.keys.color.includes(n));
+  if (name) {
+    return colors[name];
+  }
+  let bg = color.stack.find(n => n.slice(2) === 'bg');
+  if (bg) {
+    return colors[name.slice(2)];
+  }
+  return str => str;
+};
+
+exports.pascal = str => str ? str[0].toUpperCase() + str.slice(1) : '';
+
+exports.inverse = color => {
+  if (!color || !color.stack) return color;
+  let name = color.stack.find(n => colors.keys.color.includes(n));
+  if (name) {
+    let col = colors['bg' + exports.pascal(name)];
+    return col ? col.black : color;
+  }
+  let bg = color.stack.find(n => n.slice(0, 2) === 'bg');
+  if (bg) {
+    return colors[bg.slice(2).toLowerCase()] || color;
+  }
+  return colors.none;
+};
+
+exports.complement = color => {
+  if (!color || !color.stack) return color;
+  let name = color.stack.find(n => colors.keys.color.includes(n));
+  let bg = color.stack.find(n => n.slice(0, 2) === 'bg');
+  if (name && !bg) {
+    return colors[complements[name] || name];
+  }
+  if (bg) {
+    let lower = bg.slice(2).toLowerCase();
+    let comp = complements[lower];
+    if (!comp) return color;
+    return colors['bg' + exports.pascal(comp)] || color;
+  }
+  return colors.none;
+};
+
+exports.meridiem = date => {
+  let hours = date.getHours();
+  let minutes = date.getMinutes();
+  let ampm = hours >= 12 ? 'pm' : 'am';
+  hours = hours % 12;
+  let hrs = hours === 0 ? 12 : hours;
+  let min = minutes < 10 ? '0' + minutes : minutes;
+  return hrs + ':' + min + ' ' + ampm;
+};
+
+/**
+ * Set a value on the given object.
+ * @param {Object} obj
+ * @param {String} prop
+ * @param {any} value
+ */
+
+exports.set = (obj = {}, prop = '', val) => {
+  return prop.split('.').reduce((acc, k, i, arr) => {
+    let value = arr.length - 1 > i ? (acc[k] || {}) : val;
+    if (!exports.isObject(value) && i < arr.length - 1) value = {};
+    return (acc[k] = value);
+  }, obj);
+};
+
+/**
+ * Get a value from the given object.
+ * @param {Object} obj
+ * @param {String} prop
+ */
+
+exports.get = (obj = {}, prop = '', fallback) => {
+  let value = obj[prop] == null
+    ? prop.split('.').reduce((acc, k) => acc && acc[k], obj)
+    : obj[prop];
+  return value == null ? fallback : value;
+};
+
+exports.mixin = (target, b) => {
+  if (!isObject(target)) return b;
+  if (!isObject(b)) return target;
+  for (let key of Object.keys(b)) {
+    let desc = Object.getOwnPropertyDescriptor(b, key);
+    if (hasOwnProperty.call(desc, 'value')) {
+      if (hasOwnProperty.call(target, key) && isObject(desc.value)) {
+        let existing = Object.getOwnPropertyDescriptor(target, key);
+        if (isObject(existing.value) && existing.value !== desc.value) {
+          target[key] = exports.merge({}, target[key], b[key]);
+        } else {
+          Reflect.defineProperty(target, key, desc);
+        }
+      } else {
+        Reflect.defineProperty(target, key, desc);
+      }
+    } else {
+      Reflect.defineProperty(target, key, desc);
+    }
+  }
+  return target;
+};
+
+exports.merge = (...args) => {
+  let target = {};
+  for (let ele of args) exports.mixin(target, ele);
+  return target;
+};
+
+exports.mixinEmitter = (obj, emitter) => {
+  let proto = emitter.constructor.prototype;
+  for (let key of Object.keys(proto)) {
+    let val = proto[key];
+    if (typeof val === 'function') {
+      exports.define(obj, key, val.bind(emitter));
+    } else {
+      exports.define(obj, key, val);
+    }
+  }
+};
+
+const onExit = (quit, code) => {
+  if (onExitCalled) return;
+
+  onExitCalled = true;
+  onExitCallbacks.forEach(fn => fn());
+
+  if (quit === true) {
+    process.exit(128 + code);
+  }
+};
+const onSigTerm = onExit.bind(null, true, 15);
+const onSigInt = onExit.bind(null, true, 2);
+
+exports.onExit = callback => {
+  if (onExitCallbacks.size === 0) {
+    process.once('SIGTERM', onSigTerm);
+    process.once('SIGINT', onSigInt);
+    process.once('exit', onExit);
+  }
+
+  onExitCallbacks.add(callback);
+
+  return () => {
+    onExitCallbacks.delete(callback);
+    if (onExitCallbacks.size === 0) {
+      process.off('SIGTERM', onSigTerm);
+      process.off('SIGINT', onSigInt);
+      process.off('exit', onExit);
+    }
+  }
+};
+
+exports.define = (obj, key, value) => {
+  Reflect.defineProperty(obj, key, { value });
+};
+
+exports.defineExport = (obj, key, fn) => {
+  let custom;
+  Reflect.defineProperty(obj, key, {
+    enumerable: true,
+    configurable: true,
+    set(val) {
+      custom = val;
+    },
+    get() {
+      return custom ? custom() : fn();
+    }
+  });
+};