Add prompt function to the dialogue service.

yew/src/services/dialog.rs

@@ -1,5 +1,8 @@
 //! This module contains the implementation of a service
 //! to show alerts and confirm dialogs in a browser.
+//!
+//! If you call these methods repeatably browsers tend to disable these options to give users
+//! a better experience.
 
 use cfg_if::cfg_if;
 use cfg_match::cfg_match;
@@ -41,4 +44,45 @@ impl DialogService {
             feature = "web_sys" => utils::window().confirm_with_message(message).unwrap(),
         }
     }
+
+    /// Prompts the user to input a message. In most browsers this will open an alert box with
+    /// an input field where the user can input a message.
+    ///
+    /// It is possible to supply a default value which will be used if the user does not provide
+    /// a value.
+    ///
+    /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)
+    ///
+    /// This method will `panic!` if there is an error in the process of trying to carry out this
+    /// operation.
+    ///
+    /// Note that this function is blocking; no other code can be run on the thread while
+    /// the user inputs their message which means that the page will appear to have 'frozen'
+    /// while the user types in their message.
+    pub fn prompt(
+        message: &str,
+        #[cfg(feature = "web_sys")] default: Option<&str>,
+        #[cfg(feature = "std_web")] _: Option<&str>,
+    ) -> Option<String> {
+        cfg_if! {
+            if #[cfg(feature="web_sys")] {
+                if let Some(default) = default {
+                    utils::window()
+                           .prompt_with_message_and_default(message, default)
+                           .expect("Couldn't read input.")
+                }
+                else {
+                    utils::window()
+                           .prompt_with_message(message)
+                           .expect("Couldn't read input.")
+                }
+            } else if #[cfg(feature="std_web")] {
+                let value: Value = js! { return prompt(@{message}); };
+                match value {
+                    Value::String(result) => Some(result),
+                    _ => None,
+                }
+            }
+        }
+    }
 }

yew/src/services/fetch/web_sys.rs

@@ -164,7 +164,7 @@ pub struct FetchService {}
 
 impl FetchService {
     /// Sends a request to a remote server given a Request object and a callback
-    /// fuction to convert a Response object into a loop's message.
+    /// function to convert a Response object into a loop's message.
     ///
     /// You may use a Request builder to build your request declaratively as on the
     /// following examples:
@@ -183,7 +183,7 @@ impl FetchService {
     ///     .expect("Failed to build request.");
     /// ```
     ///
-    /// The callback function can build a loop message by passing or analizing the
+    /// The callback function can build a loop message by passing or analyzing the
     /// response body and metadata.
     ///
     /// ```
@@ -220,8 +220,8 @@ impl FetchService {
     /// ```
     ///
     /// For a full example, you can specify that the response must be in the JSON format,
-    /// and be a specific serialized data type. If the mesage isn't Json, or isn't the specified
-    /// data type, then you will get a message indicating failure.
+    /// and be a specific serialized data type. If the message isn't JSON, or isn't the specified
+    /// data type, then you will get an error message.
     ///
     /// ```
     ///# use yew::format::{Json, Nothing, Format};
@@ -555,7 +555,9 @@ impl WindowOrWorker {
         } else if !global.worker().is_undefined() {
             Self::Worker(global.unchecked_into())
         } else {
-            panic!("Only supported in a browser or web worker");
+            panic!(
+                "Yew's `FetchService` only works when a `window` or `worker` object is available."
+            );
         }
     }
 }

yew/src/services/mod.rs

@@ -37,8 +37,10 @@ pub use self::websocket::WebSocketService;
 
 use std::time::Duration;
 
-/// An universal task of a service.
-/// The task must be handled when it is cancelled.
+/// A task is an ongoing process which is part of a Yew application.
+///
+/// All tasks must be handled when they are cancelled, which is why the `Drop` trait is required.
+/// Tasks should cancel themselves in their implementation of the `Drop` trait.
 pub trait Task: Drop {
     /// Returns `true` if task is active.
     fn is_active(&self) -> bool;

yew/src/services/reader/web_sys.rs

@@ -19,7 +19,7 @@ impl ReaderService {
 
     /// Reads all bytes from a file and returns them with a callback.
     pub fn read_file(&mut self, file: File, callback: Callback<FileData>) -> Result<ReaderTask> {
-        let file_reader = FileReader::new().map_err(|_| anyhow!("couldn't aquire file reader"))?;
+        let file_reader = FileReader::new().map_err(|_| anyhow!("couldn't acquire file reader"))?;
         let reader = file_reader.clone();
         let name = file.name();
         let callback = move |_event: &Event| {