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/hooks/src/use_coroutine.rs

@@ -6,11 +6,11 @@ use std::future::Future;
 
 /// Maintain a handle over a future that can be paused, resumed, and canceled.
 ///
-/// This is an upgraded form of [`use_future`] with an integrated channel system.
-/// Specifically, the coroutine generated here comes with an [`UnboundedChannel`]
+/// This is an upgraded form of [`crate::use_future()`] with an integrated channel system.
+/// Specifically, the coroutine generated here comes with an [`futures_channel::mpsc::UnboundedSender`]
 /// built into it - saving you the hassle of building your own.
 ///
-/// Addititionally, coroutines are automatically injected as shared contexts, so
+/// Additionally, coroutines are automatically injected as shared contexts, so
 /// downstream components can tap into a coroutine's channel and send messages
 /// into a singular async event loop.
 ///
@@ -33,7 +33,7 @@ use std::future::Future;
 /// ## UseCallback instead
 ///
 /// However, you must plan out your own concurrency and synchronization. If you
-/// don't care about actions in your app being synchronized, you can use [`use_callback`]
+/// don't care about actions in your app being synchronized, you can use [`crate::use_callback()`]
 /// hook to spawn multiple tasks and run them concurrently.
 ///
 /// ### Notice
@@ -42,7 +42,9 @@ use std::future::Future;
 ///
 /// ## Example
 ///
-/// ```rust, ignore
+/// ```rust, no_run
+/// # use dioxus::prelude::*;
+/// use futures_util::StreamExt;
 /// enum Action {
 ///     Start,
 ///     Stop,
@@ -63,8 +65,9 @@ use std::future::Future;
 ///         onclick: move |_| chat_client.send(Action::Start),
 ///         "Start Chat Service"
 ///     }
-/// })
+/// };
 /// ```
+#[doc = include_str!("../docs/rules_of_hooks.md")]
 pub fn use_coroutine<M, G, F>(init: G) -> Coroutine<M>
 where
     M: 'static,
@@ -96,6 +99,7 @@ where
 /// Analagous to use_context_provider and use_context,
 /// but used for coroutines specifically
 /// See the docs for [`use_coroutine`] for more details.
+#[doc = include_str!("../docs/rules_of_hooks.md")]
 #[must_use]
 pub fn use_coroutine_handle<M: 'static>() -> Coroutine<M> {
     use_hook(consume_context::<Coroutine<M>>)