clean up prelude (#4416)

* clear away prelude on dioxus

* clippy

* wip - drop prelude from dioxus-html

* docs clippy

* wip

* more fixe

* delete all preludes

* doc...

* better export

* merge some imports

* fewer global imports

* global incremental renderer

* fix cargo doc

Author: jkelleyrtp

examples/fullstack-auth/src/auth.rs

@@ -9,7 +9,7 @@ use axum_session::{SessionConfig, SessionLayer, SessionStore};
 use axum_session_auth::*;
 use axum_session_sqlx::SessionSqlitePool;
 use core::pin::Pin;
-use dioxus_fullstack::prelude::*;
+use dioxus::prelude::*;
 use serde::{Deserialize, Serialize};
 use sqlx::sqlite::{SqliteConnectOptions, SqlitePool, SqlitePoolOptions};
 use std::error::Error;

examples/fullstack-auth/src/main.rs

@@ -4,7 +4,6 @@
 mod auth;
 
 use dioxus::prelude::*;
-use dioxus_fullstack::prelude::*;
 use serde::{Deserialize, Serialize};
 
 fn main() {

examples/fullstack-desktop/src/main.rs

@@ -4,7 +4,7 @@ use dioxus::prelude::*;
 fn main() {
     // Set the url of the server where server functions are hosted.
     #[cfg(not(feature = "server"))]
-    dioxus::fullstack::prelude::server_fn::client::set_server_url("http://127.0.0.1:8080");
+    dioxus::fullstack::set_server_url("http://127.0.0.1:8080");
     dioxus::launch(app);
 }
 

examples/fullstack-router/src/main.rs

@@ -9,7 +9,7 @@ use dioxus::prelude::*;
 fn main() {
     dioxus::LaunchBuilder::new()
         .with_cfg(server_only!(ServeConfig::builder().incremental(
-            IncrementalRendererConfig::default()
+            dioxus::fullstack::IncrementalRendererConfig::default()
                 .invalidate_after(std::time::Duration::from_secs(120)),
         )))
         .launch(app);

examples/query_segment_search.rs

@@ -2,7 +2,7 @@
 //!
 //! The enum router makes it easy to use your route as state in your app. This example shows how to use the router to encode search text into the url and decode it back into a string.
 //!
-//! Run this example on desktop with  
+//! Run this example on desktop with
 //! ```sh
 //! dx serve --example query_segment_search
 //! ```
@@ -29,7 +29,7 @@ enum Route {
 
     // The each query segment must implement <https://docs.rs/dioxus-router/latest/dioxus_router/routable/trait.FromQueryArgument.html> and Display.
     // You can use multiple query segments separated by `&`s.
-    #[route("/search?:query&:word_count")] 
+    #[route("/search?:query&:word_count")]
     Search {
         query: String,
         word_count: usize,

packages/core-macro/src/props/mod.rs

@@ -544,7 +544,7 @@ fn extract_inner_type_from_segment(segment: &PathSegment) -> Option<&Type> {
 mod struct_info {
     use convert_case::{Case, Casing};
     use proc_macro2::TokenStream;
-    use quote::quote;
+    use quote::{quote, ToTokens};
     use syn::parse::Error;
     use syn::punctuated::Punctuated;
     use syn::spanned::Spanned;
@@ -884,7 +884,7 @@ Finally, call `.build()` to create the instance of `{name}`.
                     _phantom: (#( #phantom_generics ),*),
                 }
 
-                impl #impl_generics dioxus_core::prelude::Properties for #name #ty_generics
+                impl #impl_generics dioxus_core::Properties for #name #ty_generics
                 #b_generics_where
                 {
                     type Builder = #builder_name #generics_with_empty;
@@ -1024,22 +1024,19 @@ Finally, call `.build()` to create the instance of `{name}`.
 
             Ok(quote! {
                 #[allow(dead_code, non_camel_case_types, missing_docs)]
-                impl #impl_generics dioxus_core::prelude::HasAttributes for #builder_name < #( #ty_generics ),* > #where_clause {
+                impl #impl_generics dioxus_core::HasAttributes for #builder_name < #( #ty_generics ),* > #where_clause {
                     fn push_attribute<L>(
                         mut self,
                         ____name: &'static str,
                         ____ns: Option<&'static str>,
-                        ____attr: impl dioxus_core::prelude::IntoAttributeValue<L>,
+                        ____attr: impl dioxus_core::IntoAttributeValue<L>,
                         ____volatile: bool
                     ) -> Self {
                         let ( #(#descructuring,)* ) = self.fields;
                         self.#field_name.push(
                             dioxus_core::Attribute::new(
                                 ____name,
-                                {
-                                    use dioxus_core::prelude::IntoAttributeValue;
-                                    ____attr.into_value()
-                                },
+                                dioxus_core::IntoAttributeValue::<L>::into_value(____attr),
                                 ____ns,
                                 ____volatile,
                             )
@@ -1150,16 +1147,16 @@ Finally, call `.build()` to create the instance of `{name}`.
                 let marker_ident = syn::Ident::new("__Marker", proc_macro2::Span::call_site());
                 marker = Some(marker_ident.clone());
                 (
-                    quote!(impl dioxus_core::prelude::SuperInto<#arg_type, #marker_ident>),
+                    quote!(impl dioxus_core::SuperInto<#arg_type, #marker_ident>),
                     // If this looks like a signal type, we automatically convert it with SuperInto and use the props struct as the owner
-                    quote!(with_owner(self.owner.clone(), move || dioxus_core::prelude::SuperInto::super_into(#field_name))),
+                    quote!(dioxus_core::with_owner(self.owner.clone(), move || dioxus_core::SuperInto::super_into(#field_name))),
                 )
             } else if field.builder_attr.auto_into || field.builder_attr.strip_option {
                 let marker_ident = syn::Ident::new("__Marker", proc_macro2::Span::call_site());
                 marker = Some(marker_ident.clone());
                 (
-                    quote!(impl dioxus_core::prelude::SuperInto<#arg_type, #marker_ident>),
-                    quote!(dioxus_core::prelude::SuperInto::super_into(#field_name)),
+                    quote!(impl dioxus_core::SuperInto<#arg_type, #marker_ident>),
+                    quote!(dioxus_core::SuperInto::super_into(#field_name)),
                 )
             } else if field.builder_attr.from_displayable {
                 (
@@ -1419,24 +1416,27 @@ Finally, call `.build()` to create the instance of `{name}`.
                     // If this is a signal type, we use super_into and the props struct as the owner
                     let is_child_owned_type = child_owned_type(field.ty);
 
-                    let mut into = quote!{};
 
-                    if !is_default {
+                    let body = if !is_default {
                         if is_child_owned_type {
-                            into = quote!{ .super_into() }
+                            quote!{ dioxus_core::SuperInto::super_into(#default) }
                         } else if field.builder_attr.auto_into {
-                            into = quote!{ .into() }
+                            quote!{ (#default).into() }
                         } else if field.builder_attr.auto_to_string {
-                            into = quote!{ .to_string() }
+                            quote!{ (#default).to_string() }
+                        } else {
+                            default.to_token_stream()
                         }
-                    }
+                    } else {
+                        default.to_token_stream()
+                    };
 
                     if field.builder_attr.skip {
-                        quote!(let #name = #default #into;)
+                        quote!(let #name = #body;)
                     } else if is_child_owned_type {
-                        quote!(let #name = #helper_trait_name::into_value(#name, || with_owner(self.owner.clone(), move || (#default) #into));)
+                        quote!(let #name = #helper_trait_name::into_value(#name, || dioxus_core::with_owner(self.owner.clone(), move || #body));)
                     } else {
-                        quote!(let #name = #helper_trait_name::into_value(#name, || #default #into);)
+                        quote!(let #name = #helper_trait_name::into_value(#name, || #body);)
                     }
                 } else {
                     quote!(let #name = #name.0;)
@@ -1484,15 +1484,15 @@ Finally, call `.build()` to create the instance of `{name}`.
                         /// Create a component from the props.
                         pub fn into_vcomponent<M: 'static>(
                             self,
-                            render_fn: impl dioxus_core::prelude::ComponentFunction<#original_name #ty_generics, M>,
+                            render_fn: impl dioxus_core::ComponentFunction<#original_name #ty_generics, M>,
                         ) -> dioxus_core::VComponent {
-                            use dioxus_core::prelude::ComponentFunction;
+                            use dioxus_core::ComponentFunction;
                             let component_name = ::std::any::type_name_of_val(&render_fn);
                             dioxus_core::VComponent::new(move |wrapper: Self| render_fn.rebuild(wrapper.inner), self, component_name)
                         }
                     }
 
-                    impl #original_impl_generics dioxus_core::prelude::Properties for #name #ty_generics #where_clause {
+                    impl #original_impl_generics dioxus_core::Properties for #name #ty_generics #where_clause {
                         type Builder = ();
                         fn builder() -> Self::Builder {
                             unreachable!()
@@ -1742,7 +1742,7 @@ fn child_owned_type(ty: &Type) -> bool {
 fn looks_like_signal_type(ty: &Type) -> bool {
     match extract_base_type_without_generics(ty) {
         Some(path_without_generics) => {
-            path_without_generics == parse_quote!(dioxus_core::prelude::ReadOnlySignal)
+            path_without_generics == parse_quote!(dioxus_core::ReadOnlySignal)
                 || path_without_generics == parse_quote!(prelude::ReadOnlySignal)
                 || path_without_generics == parse_quote!(ReadOnlySignal)
         }
@@ -1754,10 +1754,10 @@ fn looks_like_callback_type(ty: &Type) -> bool {
     let type_without_option = remove_option_wrapper(ty.clone());
     match extract_base_type_without_generics(&type_without_option) {
         Some(path_without_generics) => {
-            path_without_generics == parse_quote!(dioxus_core::prelude::EventHandler)
+            path_without_generics == parse_quote!(dioxus_core::EventHandler)
                 || path_without_generics == parse_quote!(prelude::EventHandler)
                 || path_without_generics == parse_quote!(EventHandler)
-                || path_without_generics == parse_quote!(dioxus_core::prelude::Callback)
+                || path_without_generics == parse_quote!(dioxus_core::Callback)
                 || path_without_generics == parse_quote!(prelude::Callback)
                 || path_without_generics == parse_quote!(Callback)
         }

packages/core-macro/tests/values_memoize_in_place.rs

@@ -1,4 +1,7 @@
-use dioxus::prelude::*;
+use dioxus::{
+    core::{generation, needs_update},
+    prelude::*,
+};
 use dioxus_core::ElementId;
 use std::{any::Any, rc::Rc};
 
@@ -136,6 +139,8 @@ fn TakesSignal(sig: ReadOnlySignal<usize>, number: usize) -> Element {
 // Regression test for https://github.com/DioxusLabs/dioxus/issues/2582
 #[test]
 fn spreads_memorize_in_place() {
+    use dioxus_core::Properties;
+
     #[derive(Props, Clone, PartialEq)]
     struct CompProps {
         #[props(extends = GlobalAttributes)]

packages/core/README.md

@@ -4,8 +4,7 @@
 
 ```rust, no_run
 # tokio::runtime::Runtime::new().unwrap().block_on(async {
-use dioxus_core::prelude::*;
-use dioxus_core::*;
+use dioxus_core::{VirtualDom, Event, Element, Mutations};
 
 let mut vdom = VirtualDom::new(app);
 let real_dom = SomeRenderer::new();

packages/core/src/diff/component.rs

@@ -10,10 +10,9 @@ use crate::{
         VComponent, WriteMutations,
     },
     nodes::{AsVNode, VNode},
-    prelude::SuspenseContext,
     scopes::ScopeId,
     virtual_dom::VirtualDom,
-    Element,
+    Element, SuspenseContext,
 };
 
 impl VirtualDom {

packages/core/src/events.rs

@@ -1,6 +1,4 @@
-use crate::{
-    prelude::current_scope_id, properties::SuperFrom, runtime::RuntimeGuard, Runtime, ScopeId,
-};
+use crate::{current_scope_id, properties::SuperFrom, runtime::RuntimeGuard, Runtime, ScopeId};
 use generational_box::GenerationalBox;
 use std::{any::Any, cell::RefCell, marker::PhantomData, panic::Location, rc::Rc};
 
@@ -337,7 +335,7 @@ impl<Ret> SpawnIfAsync<(), Ret> for Ret {
 pub struct AsyncMarker;
 impl<F: std::future::Future<Output = ()> + 'static> SpawnIfAsync<AsyncMarker> for F {
     fn spawn(self) {
-        crate::prelude::spawn(async move {
+        crate::spawn(async move {
             self.await;
         });
     }
@@ -353,9 +351,9 @@ where
 {
     #[inline]
     fn spawn(self) {
-        crate::prelude::spawn(async move {
+        crate::spawn(async move {
             if let Err(err) = self.await {
-                crate::prelude::throw_error(err)
+                crate::throw_error(err)
             }
         });
     }
@@ -366,7 +364,7 @@ impl SpawnIfAsync<()> for crate::Result<()> {
     #[inline]
     fn spawn(self) {
         if let Err(err) = self {
-            crate::prelude::throw_error(err)
+            crate::throw_error(err)
         }
     }
 }