chore: fix broken links, etc. in docs

hydration_context/src/lib.rs

@@ -83,15 +83,14 @@ pub trait SharedContext: Debug {
 
     /// Reads the current value of some data from the shared context, if it has been
     /// sent from the server. This returns the serialized data as a `String` that should
-    /// be deserialized using [`Serializable::de`].
+    /// be deserialized.
     ///
     /// On the server and in client-side rendered implementations, this should
     /// always return [`None`].
     fn read_data(&self, id: &SerializedDataId) -> Option<String>;
 
     /// Returns a [`Future`] that resolves with a `String` that should
-    /// be deserialized using [`Serializable::de`] once the given piece of server
-    /// data has resolved.
+    /// be deserialized once the given piece of server data has resolved.
     ///
     /// On the server and in client-side rendered implementations, this should
     /// return a [`Future`] that is immediately ready with [`None`].
@@ -148,8 +147,8 @@ pub trait SharedContext: Debug {
 
     /// Adds a `Future` to the set of “blocking resources” that should prevent the server’s
     /// response stream from beginning until all are resolved. The `Future` returned by
-    /// [`blocking_resources`](Self::blocking_resources) will not resolve until every `Future`
-    /// added by this method has resolved.
+    /// blocking resources will not resolve until every `Future` added by this method
+    /// has resolved.
     ///
     /// In browser implementations, this should be a no-op.
     fn defer_stream(&self, wait_for: PinnedFuture<()>);

integrations/actix/src/lib.rs

@@ -82,7 +82,7 @@ impl ResponseParts {
     }
 }
 
-/// A wrapper for an Actix [`HttpRequest`](actix_web::HttpRequest) that allows it to be used in an
+/// A wrapper for an Actix [`HttpRequest`] that allows it to be used in an
 /// `Send`/`Sync` setting like Leptos's Context API.
 #[derive(Debug, Clone)]
 pub struct Request(SendWrapper<HttpRequest>);
@@ -419,12 +419,6 @@ pub fn handle_server_fns_with_context(
 /// will include fallback content for any `<Suspense/>` nodes, and be immediately interactive,
 /// but requires some client-side JavaScript.
 ///
-/// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
-/// rendering it, and includes any meta tags injected using [leptos_meta].
-///
-/// The HTML stream is rendered using [render_to_stream](leptos::ssr::render_to_stream), and
-/// includes everything described in the documentation for that function.
-///
 /// This can then be set up at an appropriate route in your application:
 /// ```
 /// use actix_web::{App, HttpServer};
@@ -465,7 +459,6 @@ pub fn handle_server_fns_with_context(
 /// - [ResponseOptions]
 /// - [Request]
 /// - [MetaContext](leptos_meta::MetaContext)
-/// - [RouterIntegrationContext](leptos_router::RouterIntegrationContext)
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -485,13 +478,6 @@ where
 /// This stream will pause at each `<Suspense/>` node and wait for it to resolve before
 /// sending down its HTML. The app will become interactive once it has fully loaded.
 ///
-/// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
-/// rendering it, and includes any meta tags injected using [leptos_meta].
-///
-/// The HTML stream is rendered using
-/// [render_to_stream_in_order](leptos::ssr::render_to_stream_in_order),
-/// and includes everything described in the documentation for that function.
-///
 /// This can then be set up at an appropriate route in your application:
 /// ```
 /// use actix_web::{App, HttpServer};
@@ -534,7 +520,6 @@ where
 /// This function always provides context values including the following types:
 /// - [ResponseOptions]
 /// - [Request]
-/// - [RouterIntegrationContext](leptos_router::RouterIntegrationContext)
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -551,13 +536,7 @@ where
 
 /// Returns an Actix [struct@Route](actix_web::Route) that listens for a `GET` request and tries
 /// to route it using [leptos_router], asynchronously rendering an HTML page after all
-/// `async` [Resource](leptos::Resource)s have loaded.
-///
-/// The provides a [MetaContext] and a [RouterIntegrationContext] to the app’s context before
-/// rendering it, and includes any meta tags injected using [leptos_meta].
-///
-/// The HTML stream is rendered using [render_to_string_async](leptos::ssr::render_to_string_async), and
-/// includes everything described in the documentation for that function.
+/// `async` resources have loaded.
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```
@@ -690,7 +669,6 @@ where
 /// - [ResponseOptions]
 /// - [Request]
 /// - [MetaContext](leptos_meta::MetaContext)
-/// - [RouterIntegrationContext](leptos_router::RouterIntegrationContext)
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -713,7 +691,7 @@ where
 
 /// Returns an Actix [struct@Route](actix_web::Route) that listens for a `GET` request and tries
 /// to route it using [leptos_router], asynchronously serving the page once all `async`
-/// [Resource](leptos::Resource)s have loaded.
+/// resources have loaded.
 ///
 /// This function allows you to provide additional information to Leptos for your route.
 /// It could be used to pass in Path Info, Connection Info, or anything your heart desires.

integrations/axum/src/lib.rs

@@ -197,9 +197,9 @@
 /// 2. A server function that is called from WASM running in the client (e.g., a dispatched action
 ///    or a spawned `Future`).
 /// 3. A `<form>` submitted to the server function endpoint using default browser APIs (often due
-///    to using [`ActionForm`](leptos::form::ActionForm) without JS/WASM present.)
+///    to using [`ActionForm`] without JS/WASM present.)
 ///
-/// Using it with a non-blocking [`Resource`](leptos::server::Resource) will not work if you are using streaming rendering,
+/// Using it with a non-blocking [`Resource`] will not work if you are using streaming rendering,
 /// as the response's headers will already have been sent by the time the server function calls `redirect()`.
 ///
 /// ### Implementation
@@ -442,12 +442,6 @@
 /// Returns an Axum [Handler](axum::handler::Handler) that listens for a `GET` request and tries
 /// to route it using [leptos_router], serving an HTML stream of your application.
 ///
-/// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
-/// rendering it, and includes any meta tags injected using [leptos_meta].
-///
-/// The HTML stream is rendered using [render_to_stream](leptos::ssr::render_to_stream), and
-/// includes everything described in the documentation for that function.
-///
 /// This can then be set up at an appropriate route in your application:
 /// ```
 /// use axum::{handler::Handler, Router};
@@ -485,8 +479,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -517,7 +510,7 @@
 pub fn render_route<S, IV>(
     paths: Vec<AxumRouteListing>,
     app_fn: impl Fn() -> IV + Clone + Send + 'static,
 ) -> impl Fn(
     State<S>,
     Request<Body>,
 ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'static>>
@@ -537,12 +530,6 @@
 /// This stream will pause at each `<Suspense/>` node and wait for it to resolve before
 /// sending down its HTML. The app will become interactive once it has fully loaded.
 ///
-/// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
-/// rendering it, and includes any meta tags injected using [leptos_meta].
-///
-/// The HTML stream is rendered using [render_to_stream_in_order], and includes everything described in
-/// the documentation for that function.
-///
 /// This can then be set up at an appropriate route in your application:
 /// ```
 /// use axum::{handler::Handler, Router};
@@ -580,8 +567,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -634,8 +620,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -672,7 +657,7 @@
     paths: Vec<AxumRouteListing>,
     additional_context: impl Fn() + 'static + Clone + Send,
     app_fn: impl Fn() -> IV + Clone + Send + 'static,
 ) -> impl Fn(
     State<S>,
     Request<Body>,
 ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'static>>
@@ -766,8 +751,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -834,8 +818,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -952,13 +935,7 @@
 
 /// Returns an Axum [Handler](axum::handler::Handler) that listens for a `GET` request and tries
 /// to route it using [leptos_router], asynchronously rendering an HTML page after all
-/// `async` [Resource](leptos::Resource)s have loaded.
-///
-/// The provides a [MetaContext] and a [RouterIntegrationContext] to app’s context before
-/// rendering it, and includes any meta tags injected using [leptos_meta].
-///
-/// The HTML stream is rendered using [render_to_string_async], and includes everything described in
-/// the documentation for that function.
+/// `async` resources have loaded.
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```
@@ -998,8 +975,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -1020,7 +996,7 @@
 
 /// Returns an Axum [Handler](axum::handler::Handler) that listens for a `GET` request and tries
 /// to route it using [leptos_router], asynchronously rendering an HTML page after all
-/// `async` [Resource](leptos::Resource)s have loaded.
+/// `async` resources have loaded.
 ///
 /// This version allows us to pass Axum State/Extension/Extractor or other infro from Axum or network
 /// layers above Leptos itself. To use it, you'll need to write your own handler function that provides
@@ -1053,8 +1029,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
@@ -1088,7 +1063,7 @@
 
 /// Returns an Axum [Handler](axum::handler::Handler) that listens for a `GET` request and tries
 /// to route it using [leptos_router], asynchronously rendering an HTML page after all
-/// `async` [Resource](leptos::Resource)s have loaded.
+/// `async` resources have loaded.
 ///
 /// This version allows us to pass Axum State/Extension/Extractor or other infro from Axum or network
 /// layers above Leptos itself. To use it, you'll need to write your own handler function that provides
@@ -1121,8 +1096,7 @@
 /// This function always provides context values including the following types:
 /// - [`Parts`]
 /// - [`ResponseOptions`]
-/// - [`ServerMetaContext`](leptos_meta::ServerMetaContext)
-/// - [`RouterIntegrationContext`](leptos_router::RouterIntegrationContext)
+/// - [`ServerMetaContext`]
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)

leptos/src/callback.rs

@@ -31,13 +31,13 @@
 //! *Notes*:
 //! - The `render_number` prop can receive any type that implements `Fn(i32) -> String`.
 //! - Callbacks are most useful when you want optional generic props.
-//! - All callbacks implement the [`Callable`] trait, and can be invoked with `my_callback.run(input)`.
+//! - All callbacks implement the [`Callable`](leptos::callback::Callable) trait, and can be invoked with `my_callback.run(input)`.
 //! - The callback types implement [`Copy`], so they can easily be moved into and out of other closures, just like signals.
 //!
 //! # Types
 //! This modules implements 2 callback types:
-//! - [`Callback`]
-//! - [`UnsyncCallback`]
+//! - [`Callback`](leptos::callback::Callback)
+//! - [`UnsyncCallback`](leptos::callback::UnsyncCallback)
 //!
 //! Use `SyncCallback` if the function is not `Sync` and `Send`.
 

leptos/src/children.rs

@@ -246,7 +246,7 @@ where
     }
 }
 
-/// A typed equivalent to [`ChildrenMut`], which takes a generic but preserves type information to
+/// A typed equivalent to [`ChildrenFnMut`], which takes a generic but preserves type information to
 /// allow the compiler to optimize the view more effectively.
 pub struct TypedChildrenMut<T>(Box<dyn FnMut() -> View<T> + Send>);
 

leptos/src/form.rs

@@ -72,9 +72,7 @@ use web_sys::{
 #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip_all))]
 #[component]
 pub fn ActionForm<ServFn>(
-    /// The action from which to build the form. This should include a URL, which can be generated
-    /// by default using [`create_server_action`](leptos_server::create_server_action) or added
-    /// manually using [`using_server_fn`](leptos_server::Action::using_server_fn).
+    /// The action from which to build the form.
     action: ServerAction<ServFn>,
     /// A [`NodeRef`] in which the `<form>` element should be stored.
     #[prop(optional)]
@@ -149,9 +147,7 @@ where
 /// progressively enhanced to use client-side routing.
 #[component]
 pub fn MultiActionForm<ServFn>(
-    /// The action from which to build the form. This should include a URL, which can be generated
-    /// by default using [create_server_action](leptos_server::create_server_action) or added
-    /// manually using [leptos_server::Action::using_server_fn].
+    /// The action from which to build the form.
     action: ServerMultiAction<ServFn>,
     /// A [`NodeRef`] in which the `<form>` element should be stored.
     #[prop(optional)]

leptos/src/lib.rs

@@ -39,7 +39,7 @@
 //!   server actions, forms, and server-sent events (SSE).
 //! - **[`todomvc`]** shows the basics of building an isomorphic web app. Both the server and the client import the same app code.
 //!   The server renders the app directly to an HTML string, and the client hydrates that HTML to make it interactive.
-//!   You might also want to see how we use [`Effect::new`](leptos::prelude::Effect::new) to
+//!   You might also want to see how we use [`Effect::new`](leptos::prelude::Effect) to
 //!   [serialize JSON to `localStorage`](https://github.com/leptos-rs/leptos/blob/20af4928b2fffe017408d3f4e7330db22cf68277/examples/todomvc/src/lib.rs#L191-L209)
 //!   and [reactively call DOM methods](https://github.com/leptos-rs/leptos/blob/16f084a71268ac325fbc4a5e50c260df185eadb6/examples/todomvc/src/lib.rs#L292-L296)
 //!   on [references to elements](https://github.com/leptos-rs/leptos/blob/20af4928b2fffe017408d3f4e7330db22cf68277/examples/todomvc/src/lib.rs#L228).
@@ -78,7 +78,7 @@
 //!   + `async` interop: [`Resource`](leptos::prelude::Resource) for loading data using `async` functions
 //!     and [`Action`](leptos::prelude::Action) to mutate data or imperatively call `async` functions.
 //!   + reactions: [`Effect`](leptos::prelude::Effect) and [`RenderEffect`](leptos::prelude::RenderEffect).
-//! - **Templating/Views**: the [`view`] macro and [`IntoView`](leptos::IntoView) trait.
+//! - **Templating/Views**: the [`view`] macro and [`IntoView`] trait.
 //! - **Routing**: the [`leptos_router`](https://docs.rs/leptos_router/latest/leptos_router/) crate
 //! - **Server Functions**: the [`server`](macro@leptos::prelude::server) macro and [`ServerAction`](leptos::prelude::ServerAction).
 //!

leptos_macro/src/lib.rs

@@ -1,4 +1,4 @@
-//! Macros for use with the [`leptos`] framework.
+//! Macros for use with the Leptos framework.
 
 #![cfg_attr(feature = "nightly", feature(proc_macro_span))]
 #![forbid(unsafe_code)]
@@ -272,8 +272,8 @@ pub fn view(tokens: TokenStream) -> TokenStream {
     view_macro_impl(tokens, false)
 }
 
-/// The `template` macro behaves like [`view`], except that it wraps the entire tree in a
-/// [`ViewTemplate`](leptos::prelude::ViewTemplate). This optimizes creation speed by rendering
+/// The `template` macro behaves like [`view`](view!), except that it wraps the entire tree in a
+/// [`ViewTemplate`](https://docs.rs/leptos/0.7.0-gamma3/leptos/prelude/struct.ViewTemplate.html). This optimizes creation speed by rendering
 /// most of the view into a `<template>` tag with HTML rendered at compile time, then hydrating it.
 /// In exchange, there is a small binary size overhead.
 #[proc_macro_error2::proc_macro_error]
@@ -366,7 +366,7 @@ fn normalized_call_site(site: proc_macro::Span) -> Option<String> {
     }
 }
 
-/// This behaves like the [`view`] macro, but loads the view from an external file instead of
+/// This behaves like the [`view`](view!) macro, but loads the view from an external file instead of
 /// parsing it inline.
 ///
 /// This is designed to allow editing views in a separate file, if this improves a user's workflow.

leptos_server/src/lib.rs

@@ -1,4 +1,4 @@
-//! Utilities for communicating between the server and the client with [`leptos`].
+//! Utilities for communicating between the server and the client with Leptos.
 
 #![deny(missing_docs)]
 #![forbid(unsafe_code)]

leptos_server/src/once_resource.rs

@@ -253,7 +253,8 @@ where
     }
 }
 
-/// A [`Future`] that is ready when an [`ArcAsyncDerived`] is finished loading or reloading,
+/// A [`Future`] that is ready when an
+/// [`ArcAsyncDerived`](reactive_graph::computed::ArcAsyncDerived) is finished loading or reloading,
 /// and contains its value. `.await`ing this clones the value `T`.
 pub struct OnceResourceFuture<T> {
     source: AnySource,

meta/src/lib.rs

@@ -7,8 +7,7 @@
 //! using the [`Leptos`](https://github.com/leptos-rs/leptos) web framework.
 //!
 //! Document metadata is updated automatically when running in the browser. For server-side
-//! rendering, after the component tree is rendered to HTML, [`MetaContext::dehydrate`] can generate
-//! HTML that should be injected into the `<head>` of the HTML document being rendered.
+//! rendering, after the component tree is rendered to HTML, [`ServerMetaContextOutput::inject_meta_context`] will inject meta tags into a stream of HTML inside the `<head>`.
 //!
 //! ```
 //! use leptos::prelude::*;

reactive_graph/src/computed.rs

@@ -19,7 +19,7 @@ pub(crate) use inner::MemoInner;
 pub use memo::*;
 pub use selector::*;
 
-/// Derives a reactive slice of an [`RwSignal`](crate::signal::RwSignal).
+/// Derives a reactive slice of an [`RwSignal`].
 ///
 /// Slices have the same guarantees as [`Memo`s](crate::computed::Memo):
 /// they only emit their value when it has actually been changed.