Core Prompting API

/**
 * Prompt function that takes a question object or array of questions
 * @param questions - Single question object or array of question objects
 * @param options - Optional global options for all prompts
 * @returns Promise resolving to answers object
 */
function prompt(questions, ...options);

const { prompt } = require('enquirer');

// Single prompt
const response = await prompt({
  type: 'input',
  name: 'username',
  message: 'What is your username?'
});
console.log(response.username);

// Multiple prompts
const responses = await prompt([
  {
    type: 'input', 
    name: 'name',
    message: 'What is your name?'
  },
  {
    type: 'confirm',
    name: 'proceed', 
    message: 'Continue?'
  }
]);

// With global options
const responses = await prompt(questions, { prefix: '?' });

/**
 * Create an instance of Enquirer
 * @param options - Default options to use with all prompts
 * @param answers - Initial answers object
 */
class Enquirer extends EventEmitter {
  constructor(options, answers);
}

const Enquirer = require('enquirer');

// Create instance with default options
const enquirer = new Enquirer({
  prefix: '❯',
  stdin: process.stdin,
  stdout: process.stdout
});

// Create with initial answers
const enquirer = new Enquirer({}, { username: 'admin' });

/**
 * Prompt function that takes a question object or array of questions
 * @param questions - Single question object or array of question objects
 * @returns Promise resolving to answers object
 */
async prompt(questions);

const enquirer = new Enquirer();

const response = await enquirer.prompt({
  type: 'select',
  name: 'framework',
  message: 'Choose a framework',
  choices: ['React', 'Vue', 'Angular']
});

// Answers are accumulated across calls
const moreAnswers = await enquirer.prompt({
  type: 'input',
  name: 'projectName', 
  message: 'Project name?'
});

console.log(enquirer.answers); // Contains all answers

/**
 * Ask a single question and return the answer
 * @param question - Single question object
 * @returns Promise resolving to the answer value
 */
async ask(question);

const enquirer = new Enquirer();

// Ask a single question
const username = await enquirer.ask({
  type: 'input',
  name: 'username',
  message: 'Enter username:'
});

// Dynamic question type
const answer = await enquirer.ask({
  type: (question, answers) => answers.mode === 'advanced' ? 'input' : 'select',
  name: 'config',
  message: 'Configuration:',
  choices: ['basic', 'advanced']
});

// Function-based question
const result = await enquirer.ask(() => ({
  type: 'confirm',
  name: 'proceed',
  message: 'Continue with installation?'
}));

/**
 * Register a custom prompt type
 * @param type - Prompt type name or object mapping types to constructors
 * @param fn - Prompt class or factory function
 * @returns Enquirer instance for chaining
 */
register(type, fn);

const CustomPrompt = require('./custom-prompt');

// Register single type
enquirer.register('custom', CustomPrompt);

// Register multiple types
enquirer.register({
  'type1': Type1Prompt,
  'type2': Type2Prompt
});

// Use registered type
const response = await enquirer.prompt({
  type: 'custom',
  name: 'result',
  message: 'Custom prompt'
});

/**  
 * Use an enquirer plugin
 * @param plugin - Plugin function that receives the Enquirer instance
 * @returns Enquirer instance for chaining
 */
use(plugin);

function themePlugin(enquirer) {
  // Customize enquirer instance
  enquirer.options.prefix = '🎯';
  
  // Add custom methods
  enquirer.quickConfirm = async (message) => {
    return enquirer.prompt({
      type: 'confirm',
      name: 'confirmed',
      message
    });
  };
}

enquirer.use(themePlugin);
const result = await enquirer.quickConfirm('Are you sure?');

// Available as static methods (complete list)
Enquirer.autocomplete(options);
Enquirer.basicauth(options);
Enquirer.confirm(options);
Enquirer.editable(options);
Enquirer.form(options);
Enquirer.input(options);
Enquirer.invisible(options);
Enquirer.list(options);
Enquirer.multiselect(options);
Enquirer.numeral(options);
Enquirer.password(options);
Enquirer.quiz(options);
Enquirer.scale(options);
Enquirer.select(options);
Enquirer.snippet(options);
Enquirer.sort(options);
Enquirer.survey(options);
Enquirer.text(options);
Enquirer.toggle(options);

// Available as instance methods (complete list)
enquirer.autocomplete(options);
enquirer.basicauth(options);
enquirer.confirm(options);
enquirer.editable(options);
enquirer.form(options);
enquirer.input(options);
enquirer.invisible(options);
enquirer.list(options);
enquirer.multiselect(options);
enquirer.numeral(options);
enquirer.password(options);
enquirer.quiz(options);
enquirer.scale(options);
enquirer.select(options);
enquirer.snippet(options);
enquirer.sort(options);
enquirer.survey(options);
enquirer.text(options);
enquirer.toggle(options);

// Static usage
const name = await Enquirer.input({
  message: 'Your name?',
  initial: 'Anonymous'
});

// Instance usage
const enquirer = new Enquirer();
const color = await enquirer.select({
  message: 'Pick a color',
  choices: ['red', 'green', 'blue']
});

// Available on the static prompt function
const { prompt } = require('enquirer');

prompt.autocomplete(options);
prompt.basicauth(options);
prompt.confirm(options);
prompt.editable(options);
prompt.form(options);
prompt.input(options);
prompt.invisible(options);
prompt.list(options);
prompt.multiselect(options);
prompt.numeral(options);
prompt.password(options);
prompt.quiz(options);
prompt.scale(options);
prompt.select(options);
prompt.snippet(options);
prompt.sort(options);
prompt.survey(options);
prompt.text(options);
prompt.toggle(options);

const { prompt } = require('enquirer');

// Use specific prompt types directly
const username = await prompt.input({
  message: 'Enter username:',
  initial: 'admin'
});

const framework = await prompt.select({
  message: 'Choose framework:',
  choices: ['React', 'Vue', 'Angular']
});

const confirmed = await prompt.confirm({
  message: 'Are you sure?'
});

// Instance property
answers: object;

// Static and instance property
static prompts: object;
prompts: object;

// Static and instance property
static Prompt: class;
Prompt: class;

// Main Enquirer events
enquirer.on('prompt', (prompt, enquirer) => {});
enquirer.on('answer', (name, value, prompt) => {});

// Base prompt events (available on all prompt types)
prompt.on('keypress', (input, key) => {});
prompt.on('state', (state) => {});
prompt.on('alert', () => {});
prompt.on('submit', (value) => {});
prompt.on('cancel', (error) => {});
prompt.on('close', () => {});
prompt.on('start', (prompt) => {});
prompt.on('run', () => {});

// Array prompt events (select, multiselect, autocomplete, etc.)
prompt.on('choice', (choice, index, prompt) => {});
prompt.on('toggle', (choice, prompt) => {});

const { prompt } = require('enquirer');

// Events on the static prompt function
prompt.on('prompt', (promptInstance, enquirer) => {});
prompt.on('answer', (name, value, promptInstance) => {});
prompt.on('keypress', (input, key) => {});
prompt.on('submit', (value) => {});
prompt.on('cancel', (error) => {});

const enquirer = new Enquirer();

// Track all prompts and answers
enquirer.on('prompt', (prompt) => {
  console.log(`Starting prompt: ${prompt.options.name}`);
});

enquirer.on('answer', (name, value) => {
  console.log(`Answered ${name}: ${value}`);
});

// Listen for individual prompt events
enquirer.on('keypress', (input, key) => {
  if (key.name === 'escape') {
    console.log('User pressed escape');
  }
});

await enquirer.prompt({
  type: 'input',
  name: 'username',
  message: 'Username?'
});

// Using static prompt with events
const { prompt } = require('enquirer');

prompt.on('answer', (name, value) => {
  console.log(`Global answer listener: ${name} = ${value}`);
});

const response = await prompt({
  type: 'select',
  name: 'framework',
  message: 'Choose framework',
  choices: ['React', 'Vue', 'Angular']
});

// Individual prompt instance events
const promptInstance = enquirer.prompt({
  type: 'multiselect',
  name: 'features',
  message: 'Select features',
  choices: ['auth', 'routing', 'testing']
});

// Listen to choice events on array prompts
promptInstance.on('choice', (choice, index) => {
  console.log(`Focused on choice: ${choice.name} at index ${index}`);
});

promptInstance.on('toggle', (choice) => {
  console.log(`Toggled choice: ${choice.name} (${choice.enabled ? 'enabled' : 'disabled'})`);
});

const result = await promptInstance;

// Keypress event data
interface KeypressData {
  sequence: string;
  name: string;
  ctrl: boolean;
  meta: boolean;
  shift: boolean;
}

// State event data
interface StateData {
  name: string;
  message: string;
  value: any;
  submitted: boolean;
  cancelled: boolean;
  // ... other state properties
}

// Choice event data  
interface ChoiceData {
  name: string;
  value: any;
  enabled: boolean;
  disabled: boolean | string;
  message?: string;
  hint?: string;
  // ... other choice properties
}