Improve inline docs (#2460)

Improve inline docs

* improve incorrect event handler return error message

* Improve event handler docs

* document the eval functions

* document spawn and common spawn errors

* fix event handler docs

* add notes about how you use attributes and elements in rsx

* add doc aliases for attributes and events we rename

* add some more aliases for common search terms

* don't doc ignore any public examples in core

* don't ignore public doc examples in ssr

* don't ignore examples in the dioxus package readme

* add a warning when you launch without a renderer enabled

* fix some outdated element docs

* add a bunch of examples to resource

* add notes about desktop events

* add more docs for use_resource

* add on_unimplemented hint to Dependency

* fix some unresolved links

* add examples to each of the router traits

* add not implemented errors for router traits

* add an example to the routable trait

* expand rsx macro docs

* improve memo docs

* update the dioxus readme

* mention dioxus crate features in the docs

* fix a bunch of doc tests

* fix html doc tests

* fix router doc tests

* fix dioxus signals doc tests

* fix dioxus ssr doc tests

* fix use_future example in the hooks cheat sheet

* add a javascript alias for eval

* fix hook explanation values

* remove unused embed-doc-image dependency

packages/html/src/events/mounted.rs

@@ -53,6 +53,7 @@ impl RenderedElementBacking for () {
 
 /// The way that scrolling should be performed
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[doc(alias = "ScrollIntoViewOptions")]
 pub enum ScrollBehavior {
     /// Scroll to the element immediately
     #[cfg_attr(feature = "serialize", serde(rename = "instant"))]
@@ -84,21 +85,27 @@ impl MountedData {
     }
 
     /// Get the number of pixels that an element's content is scrolled
+    #[doc(alias = "scrollTop")]
+    #[doc(alias = "scrollLeft")]
     pub async fn get_scroll_offset(&self) -> MountedResult<PixelsVector2D> {
         self.inner.get_scroll_offset().await
     }
 
     /// Get the size of an element's content, including content not visible on the screen due to overflow
+    #[doc(alias = "scrollWidth")]
+    #[doc(alias = "scrollHeight")]
     pub async fn get_scroll_size(&self) -> MountedResult<PixelsSize> {
         self.inner.get_scroll_size().await
     }
 
     /// Get the bounding rectangle of the element relative to the viewport (this does not include the scroll position)
+    #[doc(alias = "getBoundingClientRect")]
     pub async fn get_client_rect(&self) -> MountedResult<PixelsRect> {
         self.inner.get_client_rect().await
     }
 
     /// Scroll to make the element visible
+    #[doc(alias = "scrollIntoView")]
     pub fn scroll_to(
         &self,
         behavior: ScrollBehavior,
@@ -107,6 +114,8 @@ impl MountedData {
     }
 
     /// Set the focus on the element
+    #[doc(alias = "focus")]
+    #[doc(alias = "blur")]
     pub fn set_focus(&self, focus: bool) -> Pin<Box<dyn Future<Output = MountedResult<()>>>> {
         self.inner.set_focus(focus)
     }
@@ -126,7 +135,64 @@ pub type MountedEvent = Event<MountedData>;
 impl_event! [
     MountedData;
 
-    /// mounted
+    #[doc(alias = "ref")]
+    #[doc(alias = "createRef")]
+    #[doc(alias = "useRef")]
+    /// The onmounted event is fired when the element is first added to the DOM. This event gives you a [`MountedData`] object and lets you interact with the raw DOM element.
+    ///
+    /// This event is fired once per element. If you need to access the element multiple times, you can store the [`MountedData`] object in a [`use_signal`] hook and use it as needed.
+    ///
+    /// # Examples
+    ///
+    /// ```rust, no_run
+    /// # use dioxus::prelude::*;
+    /// fn App() -> Element {
+    ///     let mut header_element = use_signal(|| None);
+    ///
+    ///     rsx! {
+    ///         div {
+    ///             h1 {
+    ///                 // The onmounted event will run the first time the h1 element is mounted
+    ///                 onmounted: move |element| header_element.set(Some(element.data())),
+    ///                 "Scroll to top example"
+    ///             }
+    ///
+    ///             for i in 0..100 {
+    ///                 div { "Item {i}" }
+    ///             }
+    ///
+    ///             button {
+    ///                 // When you click the button, if the header element has been mounted, we scroll to that element
+    ///                 onclick: move |_| async move {
+    ///                     if let Some(header) = header_element.cloned() {
+    ///                         let _ = header.scroll_to(ScrollBehavior::Smooth).await;
+    ///                     }
+    ///                 },
+    ///                 "Scroll to top"
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The `MountedData` struct contains cross platform APIs that work on the desktop, mobile, liveview and web platforms. For the web platform, you can also downcast the `MountedData` event to the `web-sys::Element` type for more web specific APIs:
+    ///
+    /// ```rust, no_run
+    /// # use dioxus::prelude::*;
+    /// # use dioxus_web::WebEventExt;
+    /// fn App() -> Element {
+    ///     rsx! {
+    ///         div {
+    ///             id: "some-id",
+    ///             onmounted: move |element| {
+    ///                 // You can use the web_event trait to downcast the element to a web specific event. For the mounted event, this will be a web_sys::Element
+    ///                 let web_sys_element = element.web_event();
+    ///                 assert_eq!(web_sys_element.id(), "some-id");
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// ```
     onmounted
 ];