Specialized Prompts

/**
 * Boolean confirmation prompt
 * @param options - Confirm prompt options
 * @returns Promise resolving to boolean value
 */
function confirm(options);

interface ConfirmOptions extends BasePromptOptions {
  type: 'confirm';
  initial?: boolean;
}

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

// Basic confirmation
const response = await prompt({
  type: 'confirm',
  name: 'continue',
  message: 'Do you want to continue?'
});

// With default value
const response = await prompt({
  type: 'confirm',
  name: 'agree',
  message: 'Do you agree to the terms?',
  initial: false
});

// Destructive action confirmation
const response = await prompt({
  type: 'confirm',
  name: 'delete',
  message: 'Are you sure you want to delete all files? This cannot be undone.',
  initial: false
});

/**
 * Toggle/switch prompt with custom labels
 * @param options - Toggle prompt options
 * @returns Promise resolving to boolean value
 */
function toggle(options);

interface ToggleOptions extends BasePromptOptions {
  type: 'toggle';
  initial?: boolean;
  enabled?: string;
  disabled?: string;
}

// Basic toggle
const response = await prompt({
  type: 'toggle',
  name: 'notifications',
  message: 'Enable notifications?',
  enabled: 'Yes',
  disabled: 'No'
});

// Custom toggle labels
const response = await prompt({
  type: 'toggle',
  name: 'mode',
  message: 'Development mode',
  enabled: 'Development',
  disabled: 'Production',
  initial: true
});

// Feature toggle
const response = await prompt({
  type: 'toggle',
  name: 'feature',
  message: 'Enable experimental features?',
  enabled: 'ON',
  disabled: 'OFF',
  initial: false
});

/**
 * Basic authentication prompt
 * @param options - BasicAuth prompt options
 * @returns Promise resolving to object with username and password
 */
function basicauth(options);

interface BasicAuthOptions extends BasePromptOptions {
  type: 'basicauth';
  username?: string;
  password?: string;
  showPassword?: boolean;
}

// Basic authentication
const response = await prompt({
  type: 'basicauth',
  name: 'credentials',
  message: 'Enter your credentials'
});
// Returns: { username: 'user', password: 'pass' }

// With default username
const response = await prompt({
  type: 'basicauth',
  name: 'login',
  message: 'Login to server',
  username: 'admin'
});

// Show password for debugging
const response = await prompt({
  type: 'basicauth',
  name: 'auth',
  message: 'Database credentials',
  showPassword: true
});

/**
 * Code snippet template prompt
 * @param options - Snippet prompt options
 * @returns Promise resolving to completed snippet string
 */
function snippet(options);

interface SnippetOptions extends BasePromptOptions {
  type: 'snippet';
  newline?: string;
  template?: string;
}

// Function template
const response = await prompt({
  type: 'snippet',
  name: 'function',
  message: 'Fill out the function',
  template: `function \${name}(\${params}) {
  \${body}
  return \${return_value};
}`
});

// React component template
const response = await prompt({
  type: 'snippet',
  name: 'component',
  message: 'Create React component',
  template: `import React from 'react';

interface \${name}Props {
  \${props}
}

export const \${name}: React.FC<\${name}Props> = ({ \${destructured_props} }) => {
  return (
    <div>
      \${jsx_content}
    </div>
  );
};`
});

// Configuration template
const response = await prompt({
  type: 'snippet',
  name: 'config',
  message: 'Database configuration',
  template: `{
  "host": "\${host}",
  "port": \${port},
  "database": "\${database}",
  "username": "\${username}",
  "ssl": \${ssl_enabled}
}`
});

/**
 * Quiz/trivia prompt with scoring
 * @param options - Quiz prompt options
 * @returns Promise resolving to quiz results object
 */
function quiz(options);

interface QuizOptions extends BasePromptOptions {
  type: 'quiz';
  choices: QuizChoice[];
  correctChoice?: number | string;
}

interface QuizChoice extends Choice {
  correct?: boolean;
}

// Simple quiz question
const response = await prompt({
  type: 'quiz',
  name: 'question1',
  message: 'What is the capital of France?',
  choices: [
    'London',
    'Berlin', 
    'Paris',
    'Madrid'
  ],
  correctChoice: 2 // Index of correct answer
});

// Quiz with choice objects
const response = await prompt({
  type: 'quiz',
  name: 'jsQuestion',
  message: 'Which method adds elements to the end of an array?',
  choices: [
    { name: 'push()', value: 'push', correct: true },
    { name: 'pop()', value: 'pop' },
    { name: 'shift()', value: 'shift' },
    { name: 'unshift()', value: 'unshift' }
  ]
});

// Multiple quiz questions
const questions = [
  {
    type: 'quiz',
    name: 'q1',
    message: 'What does HTML stand for?',
    choices: [
      'Hyper Text Markup Language',
      'Home Tool Markup Language', 
      'Hyperlinks and Text Markup Language'
    ],
    correctChoice: 0
  },
  {
    type: 'quiz', 
    name: 'q2',
    message: 'Which company developed JavaScript?',
    choices: ['Microsoft', 'Netscape', 'Oracle', 'Apple'],
    correctChoice: 1
  }
];

const results = await prompt(questions);

const template = `
// Template with placeholders
class \${className} extends \${baseClass} {
  constructor(\${constructorParams}) {
    super(\${superParams});
    \${constructorBody:this.initializeProperties();}
  }
  
  \${method:getName}(\${methodParams}) {
    \${methodBody:return this.name;}
  }
}
`;

// Placeholders with default values use colon syntax:
// \${placeholder:default_value}

const quizConfig = {
  type: 'quiz',
  name: 'assessment',
  message: 'JavaScript Knowledge Check',
  choices: [
    { name: 'var', hint: 'Function-scoped' },
    { name: 'let', hint: 'Block-scoped', correct: true },
    { name: 'const', hint: 'Block-scoped, immutable binding' }
  ],
  onSubmit: (name, value, prompt) => {
    if (prompt.isCorrect) {
      console.log('✅ Correct!');
    } else {
      console.log('❌ Incorrect. The answer is "let"');
    }
  }
};

const responses = await prompt([
  {
    type: 'confirm',
    name: 'hasAccount',
    message: 'Do you have an existing account?'
  },
  {
    type: 'basicauth',
    name: 'login',
    message: 'Enter your credentials',
    skip: (state) => !state.answers.hasAccount
  },
  {
    type: 'form',
    name: 'registration',
    message: 'Create new account',
    choices: [
      { name: 'username', message: 'Username' },
      { name: 'email', message: 'Email' },
      { name: 'password', message: 'Password' }
    ],
    skip: (state) => state.answers.hasAccount
  }
]);

// Confirm with validation
const response = await prompt({
  type: 'confirm',
  name: 'proceed',
  message: 'This will delete all data. Are you absolutely sure?',
  validate: (value) => {
    if (!value) {
      return 'You must confirm to proceed with deletion';
    }
    return true;
  }
});

// BasicAuth with credential validation
const response = await prompt({
  type: 'basicauth',
  name: 'auth',
  message: 'Login',
  validate: async (value) => {
    // Simulate credential check
    if (value.username === 'admin' && value.password === 'secret') {
      return true;
    }
    return 'Invalid credentials';
  }
});