Full change to #4528

[metatoaster]

See #4528 for the discussion, but the intent here is to split out the final two commits which include the breaking changes.

The new method will benefit from at least a test or two to verify that the route providing the assets remains working in the future, I'll get this in at some point.

Making this a draft request until the other non-breaking changes are merged, unless it was decided to do a full breaking change.

[metatoaster]

This change now provides the following shortcut methods for doing the site_pkg_dir and the error fallback:

Router::new()
    .leptos_routes(&leptos_options, routes, {
        let leptos_options = leptos_options.clone();
        move || shell(leptos_options.clone())
    })
    // this:
    .leptos_route_site_pkg_dir(&leptos_options, shell)
    .leptos_route_fallback(&leptos_options, shell)
    // instead of this:
    // .fallback(leptos_axum::file_and_error_handler(shell))
    .with_state(leptos_options),

Naturally, leptos_route_fallback isn't a strictly necessary addition as it's a shortcut for

    .fallback_service(ErrorHandler::new(shell, leptos_options))

Naturally we could go one step further to offer another method that combine the two to effectively replicate file_and_error_handler in one step, but maybe that's at the point where adopting the service builder pattern to customize each and every aspect of all the .leptos_routes* methods while also avoid repeating leptos_options and shell everywhere. I am open to doing this if that's desirable.

[metatoaster]

I've been thinking about the axum integration (and actix to a much smaller extent), I think given how patterns have started to emerge I think I have a better idea to formalize everything into a configuration builder to get the axum::Router all set up in much less boilerplate for the default case with a configuration builder.

Moreover, now that I've stepped back out to take a grander view of this integration, I found that the typical shell (from the leptos-rs/start-axum template) and the file_and_error_handler are actually somewhat coupled when they really shouldn't be, as the shell that the template provides expects a LeptosOptions which feeds into file_and_error_handler as that also expects this, while the entire time the LeptosRoutes::leptos_routes and friends allow all kinds of S as long as it satisfies the bound LeptosOptions: FromRef<S>. Hence I pushed a change that cleaned up ErrorHandler so that it also doesn't require LeptosOptions at all.

Backtracking to the configuration builder, perhaps it may be beneficial to formalize that and provide documentation to show that by using the existing state can serve as an AppState that tracks additional common configuration values (e.g. analytics/firebase tokens), how to make that AppState usable (ensuring LeptosOptions: FromRef<S>) and that avoids having to use leptos_routes_with_context.

To expand a bit with an example:

In app.rs:

#[derive(Clone)]
#[cfg_attr(feature = "ssr", derive(axum::extract::FromRef))]
pub struct MyState { 
    pub leptos_options: LeptosOptions,
    // doesn't matter what this is, these are additional States for the router
    pub token: Token,
} 
        
pub fn shell(state: MyState) -> impl IntoView {
    todo!()
}

In main.rs:

async fn main() {
    let my_state = MyState { leptos_options, .. };
    let routes = generate_route_list(App);

    let app = Router::new()
        .leptos_routes(&my_state, routes, {
            let my_state = my_state.clone();
            move || shell(my_state.clone())
        })
        .fallback_service(ErrorHandler::new(shell, my_state));
        .with_state(my_state);
    todo!()
}

The configuration helper I am thinking of could simply configure the App, S (default to LeptosOptions), the shell, and then an optional extra context, and it might end up looking like (name pending):

let config = LeptosAxumConfig::default()  // or `LeptosAxumConfig::new()` to disable defaults
    .app(App)
    .shell(shell);
    // this could even be optional as `get_configuration` could be called automatically
    // .state(leptos_options);
let app = Router::new()
    .leptos_config(config);

With that we don't need to worry about calling generate_route_list(App) and setting up the default file handler and error handler, though naturally that should be possible to be toggled. The idea of this helper is to have less typing going forward, it will also basically use the existing configuration methods as they are working fine still.