Add support for Ctrl-C handling

Cargo.toml

@@ -19,3 +19,6 @@ indicatif = "0.17.5"
 once_cell = "1.18.0"
 textwrap = "0.16.0"
 zeroize = {version = "1.6.0", features = ["derive"]}
+
+[dev-dependencies]
+ctrlc = "3.4.2"

examples/basic.rs

@@ -3,6 +3,14 @@ use std::{thread, time::Duration};
 use console::style;
 
 fn main() -> std::io::Result<()> {
+    // Set a no-op Ctrl-C handler so that Ctrl-C results in a
+    // `term.read_key()` error instead of terminating the process. You can skip
+    // this step if you have your own Ctrl-C handler already set up.
+    //
+    // We cannot (easily) handle this at the library level due to
+    // https://github.com/Detegr/rust-ctrlc/issues/106#issuecomment-1887793468.
+    ctrlc::set_handler(move || {}).expect("Error setting Ctrl-C handler");
+
     cliclack::clear_screen()?;
 
     cliclack::intro(style(" create-app ").on_cyan().black())?;

examples/basic_dynamic_items.rs

@@ -1,6 +1,14 @@
 use console::style;
 
 fn main() -> std::io::Result<()> {
+    // Set a no-op Ctrl-C handler so that Ctrl-C results in a
+    // `term.read_key()` error instead of terminating the process. You can skip
+    // this step if you have your own Ctrl-C handler already set up.
+    //
+    // We cannot (easily) handle this at the library level due to
+    // https://github.com/Detegr/rust-ctrlc/issues/106#issuecomment-1887793468.
+    ctrlc::set_handler(move || {}).expect("Error setting Ctrl-C handler");
+
     cliclack::clear_screen()?;
 
     cliclack::intro(style(" create-app ").on_cyan().black())?;

examples/theme.rs

@@ -22,6 +22,14 @@ impl Theme for MagentaTheme {
 }
 
 fn main() -> std::io::Result<()> {
+    // Set a no-op Ctrl-C handler so that Ctrl-C results in a
+    // `term.read_key()` error instead of terminating the process. You can skip
+    // this step if you have your own Ctrl-C handler already set up.
+    //
+    // We cannot (easily) handle this at the library level due to
+    // https://github.com/Detegr/rust-ctrlc/issues/106#issuecomment-1887793468.
+    ctrlc::set_handler(move || {}).expect("Error setting Ctrl-C handler");
+
     set_theme(MagentaTheme);
 
     intro(style(" theme ").on_magenta().black())?;

src/lib.rs

@@ -35,8 +35,8 @@
 //! ## Cancellation
 //!
 //! `Esc` cancels the prompt sequence with a nice message.
-//! `Ctrl+C` interrupts the session abruptly, it's handled inside of the
-//! `Term` crate and cannot be easily caught and rendered fancy.
+//! `Ctrl+C` will be handled gracefully (same as `Esc`) if you set up a Ctrl+C
+//! handler, eg. with the `ctrlc` crate.
 //!
 //! # Components
 //!
@@ -226,8 +226,8 @@ pub use select::Select;
 pub use spinner::Spinner;
 pub use validate::Validate;
 
-fn term_write(line: String) -> io::Result<()> {
-    Term::stderr().write_str(&line)
+fn term_write(line: impl Display) -> io::Result<()> {
+    Term::stderr().write_str(line.to_string().as_str())
 }
 
 /// Clears the terminal.

src/prompt/interaction.rs

@@ -86,50 +86,38 @@ pub trait PromptInteraction<T> {
                 prev_frame = frame;
             }
 
-            if let State::Submit(result) = state {
-                return Ok(result);
+            match state {
+                State::Submit(result) => return Ok(result),
+                State::Cancel => return Err(io::ErrorKind::Interrupted.into()),
+                _ => {}
             }
 
-            if let State::Cancel = state {
-                return Err(io::ErrorKind::Interrupted.into());
-            }
-
-            let key = term.read_key()?;
-
-            if let Some(cursor) = self.input() {
-                match key {
-                    Key::Char(chr) if !chr.is_ascii_control() => {
-                        cursor.insert(chr);
-                    }
-                    Key::Backspace => {
-                        cursor.delete_left();
-                    }
-                    Key::Del => {
-                        cursor.delete_right();
-                    }
-                    Key::ArrowLeft => {
-                        cursor.move_left();
-                    }
-                    Key::ArrowRight => {
-                        cursor.move_right();
+            match term.read_key() {
+                Ok(Key::Escape) => state = State::Cancel,
+
+                Ok(key) => {
+                    if let Some(cursor) = self.input() {
+                        match key {
+                            Key::Char(chr) if !chr.is_ascii_control() => cursor.insert(chr),
+                            Key::Backspace => cursor.delete_left(),
+                            Key::Del => cursor.delete_right(),
+                            Key::ArrowLeft => cursor.move_left(),
+                            Key::ArrowRight => cursor.move_right(),
+                            Key::Home => cursor.move_home(),
+                            Key::End => cursor.move_end(),
+                            _ => {}
+                        }
                     }
-                    Key::Home => {
-                        cursor.move_home();
-                    }
-                    Key::End => {
-                        cursor.move_end();
-                    }
-                    _ => {}
-                }
-            }
 
-            match key {
-                Key::Escape => {
-                    state = State::Cancel;
-                }
-                other => {
-                    state = self.on(&Event::Key(other));
+                    state = self.on(&Event::Key(key));
                 }
+
+                // Handle Ctrl-C as a cancel event.
+                Err(e) if e.kind() == io::ErrorKind::Interrupted => state = State::Cancel,
+
+                // Don't handle other errors, just break the loop and propagate
+                // them.
+                Err(e) => return Err(e),
             }
         }
     }