TypeScript inquirer.prompt函数代码示例

async function promptKey (conf:KeypairConfDTO, program:any) {

  const changeKeypair = !conf.pair || !conf.pair.pub || !conf.pair.sec;

  const answersWantToChange = await inquirer.prompt([{
    type: "confirm",
    name: "change",
    message: "Modify your keypair?",
    default: changeKeypair
  }]);

  if (answersWantToChange.change) {
    const obfuscatedSalt = (program.salt || "").replace(/./g, '*');
    const answersSalt = await inquirer.prompt([{
      type: "password",
      name: "salt",
      message: "Key's salt",
      default: obfuscatedSalt || undefined
    }]);
    const obfuscatedPasswd = (program.passwd || "").replace(/./g, '*');
    const answersPasswd = await inquirer.prompt([{
      type: "password",
      name: "passwd",
      message: "Key\'s password",
      default: obfuscatedPasswd || undefined
    }]);

    const keepOldSalt = obfuscatedSalt.length > 0 && obfuscatedSalt == answersSalt.salt;
    const keepOldPasswd = obfuscatedPasswd.length > 0 && obfuscatedPasswd == answersPasswd.passwd;
    const salt   = keepOldSalt ? program.salt : answersSalt.salt;
    const passwd = keepOldPasswd ? program.passwd : answersPasswd.passwd;
    conf.pair = await Scrypt(salt, passwd)
  }
}

 .then((respuestas) => {
     if (respuestas.opciones === 'Crear'){
         const preguntasFormulario = [
             { type: 'input', name: 'nombreDelJuego', message: 'Ingrese nombre del Juego:' },
             { type: 'input', name: 'precioDelJuego', message: 'Ingrese el precio del Juego:' },
             { type: 'list', name: 'tipoDelJuego', message: 'Escoga el tipo de Juego:', choices: tiposDeJuegos },
             { type: 'input', name: 'nombreDeLaEmpresaDelJuego', message: 'Ingrese nombre de la Empresa:'},
             { type: 'list', name: 'clasificacion', message: 'Escoga la clasficación del Juego:', choices: tipoDeClasificacion},
         ];
         inquirer
             .prompt(preguntasFormulario)
             .then((respuestasFormulario) => {
                     console.log(respuestasFormulario)
                     funcionEscritura(respuestasFormulario.nombreDelJuego,JSON.stringify(respuestasFormulario));
                 }
             );
     }if(respuestas.opciones == 'Borrar'){
         const preguntaParaBorrar = [
             { type: 'input', name: 'nombreDelJuego', message: '¿Qué Juego quiere borrar?' }];
         inquirer
             .prompt(preguntaParaBorrar)
             .then((respuestaParaBorrar) => {
                     funcionBorrar(respuestaParaBorrar.nombreDelJuego);
                 }
             )
     }
 });

            (respuesta: RespuestaUsuario)=>{
                if (respuesta.respuestaUsuario1.queEsUsted==='Vendedor'){
                    switch (respuesta.respuestaVenta.menuVendedor) {
                        case 'Ingresar Usuarios':
                            return rxjs.from(inquirer.prompt(ingresarUser)).pipe(
                                map(
                                    (usuario)=>{
                                        respuesta.usuario=usuario;
                                        return respuesta;
                                    }
                                )
                            );
                        case 'Ingresar más productos':
                            return rxjs.from(inquirer.prompt(ingresarProductos)).pipe(
                                map(
                                    (productos)=>{
                                        respuesta.producto=productos;
                                        return respuesta;
                                    }
                                )
                            );
                    }
                }
                else if(respuesta.respuestaUsuario1.queEsUsted === 'Comprador'){
                    switch (respuesta.respuestaCompra.menuComprador) {
                        case 'Escojer producto a comprar':
                            //leer base
                            const productos=[];

                            respuesta.respuestaBDD.bdd.productos.forEach(
                                (elemento)=>{
                                    productos.push(elemento.nombre)
                                }
                            );
                            const listaProductos={
                                name: 'productos',
                                type: 'list',
                                message: 'Escoja una opción:\nProducto: ',
                                choices: productos,
                                default: 0,
                            };
                            return rxjs.from(inquirer.prompt(listaProductos)).pipe(
                                map(
                                    (respuestaProductos)=>{
                                        return{
                                            respuestaUsuario1:respuesta.respuestaUsuario1,
                                            respuestaCompra: respuesta.respuestaCompra,
                                            respuestaBDD: respuesta.respuestaBDD,
                                            respuestaProducto:respuestaProductos
                                        }
                                    }
                                )
                            );
                            //enlistar los productos
                            //escojemos la opcion
                        case 'Productos a comprar':
                    }
               }
            }

  async function start() {
    events = [];
    const { url } = await inquirer.prompt<{ url: string }>([
      {
        type: 'input',
        name: 'url',
        message:
          'Enter the url you want to record, e.g https://react-redux.realworld.io: ',
      },
    ]);

    console.log(`Going to open ${url}...`);
    await record(url);
    console.log('Ready to record. You can do any interaction on the page.');

    const { shouldReplay } = await inquirer.prompt<{ shouldReplay: boolean }>([
      {
        type: 'confirm',
        name: 'shouldReplay',
        message: `Once you want to finish the recording, enter 'y' to start replay: `,
      },
    ]);

    emitter.emit('done', shouldReplay);

    const { shouldStore } = await inquirer.prompt<{ shouldStore: boolean }>([
      {
        type: 'confirm',
        name: 'shouldStore',
        message: `Persistently store these recorded events?`,
      },
    ]);

    if (shouldStore) {
      saveEvents();
    }

    const { shouldRecordAnother } = await inquirer.prompt<{
      shouldRecordAnother: boolean;
    }>([
      {
        type: 'confirm',
        name: 'shouldRecordAnother',
        message: 'Record another one?',
      },
    ]);

    if (shouldRecordAnother) {
      start();
    } else {
      process.exit();
    }
  }

 .then(opcionMenu => {
     //console.log(opcionMenu.Menu);
     switch (opcionMenu.Menu) {
         case 'Agregar libro':
             console.log('1');
             inquirer.prompt([
                 {
                     type: 'input', name: 'Titulo', message: 'Ingrese el tituo del Libro'},
                 {
                     type: 'input', name: 'Autor', message: 'Ingrese el autor del Libro'},
                 {
                     type: 'input', name: 'Genero', message: 'Ingrese el genero del Libro'}
             ])
                 .then(respuestasNuevoLibro => {
                     const libroNuevo: libroInterface = {
                         titulo: respuestasNuevoLibro.Titulo,
                         autor: respuestasNuevoLibro.Autor,
                         genero: respuestasNuevoLibro.Genero
                     };
                     agregarLibro(libros, libroNuevo);
                     console.log('Libro ingresado con exito.!');
                     start();
                 });
             break;
         case 'Listar libros':
             listarLibros();
             start();
             break;
         case 'Prestamo libro':
             listarLibros();
             //console.log('Escoja un libro de la lista');
             inquirer.prompt([
                 {
                     type: 'input', name: 'Titulo', message: 'Ingrese el tituo del Libro'}
             ])
                 .then(respuestasNuevoPrestamo=> {
                     const nuevoPrestamo: prestamosInterface = {
                         fecha: fechaActual.getDate()+'/'+(fechaActual.getMonth()+1)+'/'+fechaActual.getFullYear(),
                         nombreLibro: respuestasNuevoPrestamo.Titulo,
                         fechaEntrega: fechaActual.getDate()+'/'+(fechaActual.getMonth()+2)+'/'+fechaActual.getFullYear()
                     };
                     crearPrestamo(prestamosLibros, nuevoPrestamo);
                     console.log('Prestamo registrado con exito.!');
                     start();
                 });
             break;
         case 'Salir':
             break;
     }
 });

        .consoleHandler = async function () {

            console.log(`Getting payment methods ...`);

            let store = await session.getStore();
            let choices = [];

            if (store.information.has_cash_on_delivery)
                choices.push('Cash');

            if (store.information.has_credit)
                choices.push('Credit card');

            let input = await inquirer.prompt([{
                name: 'method',
                message: 'Select a payment method',
                type: 'list',
                choices
            }]);

            if(input.method == 'Cash') {
                session.setPayment({
                    paymentMethod: 'cash',
                    paymentToken: null,
                    paymentHashcode: null
                });
            }

            if (input.method == 'Credit card') {
                let cards = await session.getCreditCards();

                let input = await inquirer.prompt([{
                    name: 'card',
                    message: 'Select a card',
                    type: 'list',
                    choices: cards.map(c => `[${c.card_type}] ${c.card_number}`)
                }]);

                let selectedCard = cards.filter(c => `[${c.card_type}] ${c.card_number}` == input.card)[0];

                session.setPayment({
                    paymentMethod: 'piraeus.creditcard',
                    paymentToken: selectedCard.id,
                    paymentHashcode: selectedCard.hashcode
                });
            }

            console.log(c.green(`Done.`));

        };

/**
 * Start the sign in process by opening CodeSandbox CLI login url, this page
 * will show a token that the user will have to fill in in the CLI
 *
 * @returns
 */
async function handleSignIn() {
  // Open specific url
  info(`Opening ${CLI_LOGIN_URL}`);
  opn(CLI_LOGIN_URL, { wait: false });

  const { authToken } = await inquirer.prompt([
    {
      message: 'Token:',
      name: 'authToken',
      type: 'input',
    },
  ]);

  // We got the token! Ask the server on authorization
  const spinner = ora('Fetching user...').start();
  try {
    const { token, user } = await api.verifyUser(authToken);

    // Save definite token and user to config
    spinner.text = 'Saving user...';
    await cfg.saveUser(token, user);
    spinner.stop();

    return user;
  } catch (e) {
    spinner.stop();
    throw e;
  }
}

export async function promptChangelogReleaseName(): Promise<string> {
  return (await prompt<{releaseName: string}>({
    type: 'text',
    name: 'releaseName',
    message: 'What should be the name of the release?'
  })).releaseName;
}

 /** Prompts the user with a confirmation question and a specified message. */
 protected async promptConfirm(message: string): Promise<boolean> {
   return (await prompt<{result: boolean}>({
     type: 'confirm',
     name: 'result',
     message: message,
   })).result;
 }

gulp.task('default', cb => {
	inquirer.prompt([
		Util.promptFn.nameIt('project', (gulp.args.length > 0) ? gulp.args : 'slushy'), 
		Util.promptFn.confirmIt('project')
	], answers => {
		if (!answers.good) { return cb(); }
		answers.camel = Util.camelize(answers.project);
		answers.slug = Util.slugify(answers.project);
		path.resolve(process.cwd(), answers.slug);
		let img = filter(['**/**', '!**/**.{ico,png}'], {restore: true});
		gulp.src(path.join(__dirname, 'templates/app/**'))
			.pipe(img)
			.pipe(template(answers))
			.pipe(img.restore)
			.pipe(rename(file => {
				if (file.basename[0] === '_' && file.extname !== '.scss') {
					file.basename = '.' + file.basename.slice(1);
				}
			}))
			.pipe(conflict(path.join(process.cwd(), answers.slug)))
			.pipe(gulp.dest(path.join(process.cwd(), answers.slug)))
			.pipe(install())
			.on('finish', () => { cb(); }).resume();
	});
});