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

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);

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,
-                                {
+                                dioxus_core::IntoAttributeValue::<L>::into_value(____attr),
-                                    use dioxus_core::prelude::IntoAttributeValue;
-                                    ____attr.into_value()
-                                },
                                 ____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!(impl dioxus_core::SuperInto<#arg_type, #marker_ident>),
-                    quote!(dioxus_core::prelude::SuperInto::super_into(#field_name)),
+                    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::{VirtualDom, Event, Element, Mutations};
-use dioxus_core::*;
 
 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::{
+use crate::{current_scope_id, properties::SuperFrom, runtime::RuntimeGuard, Runtime, ScopeId};
-    prelude::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)
         }
     }
 }

packages/core/src/global_context.rs

@@ -1,6 +1,8 @@
-use crate::prelude::SuspenseContext;
 use crate::runtime::RuntimeError;
-use crate::{innerlude::SuspendedFuture, runtime::Runtime, CapturedError, Element, ScopeId, Task};
+use crate::{
+    innerlude::SuspendedFuture, runtime::Runtime, CapturedError, Element, ScopeId, SuspenseContext,
+    Task,
+};
 use std::future::Future;
 use std::sync::Arc;
 
@@ -18,7 +20,7 @@ pub fn vdom_is_rendering() -> bool {
     Runtime::with(|rt| rt.rendering.get()).unwrap_or_default()
 }
 
-/// Throw a [`CapturedError`] into the current scope. The error will bubble up to the nearest [`crate::prelude::ErrorBoundary()`] or the root of the app.
+/// Throw a [`CapturedError`] into the current scope. The error will bubble up to the nearest [`crate::ErrorBoundary()`] or the root of the app.
 ///
 /// # Examples
 /// ```rust, no_run

packages/core/src/lib.rs

@@ -77,32 +77,20 @@ pub(crate) mod innerlude {
 }
 
 pub use crate::innerlude::{
-    fc_to_builder, generation, schedule_update, schedule_update_any, use_hook, vdom_is_rendering,
+    consume_context, consume_context_from_scope, current_owner, current_scope_id, fc_to_builder,
-    AnyValue, Attribute, AttributeValue, CapturedError, Component, ComponentFunction, DynamicNode,
+    force_all_dirty, generation, has_context, needs_update, needs_update_any, parent_scope,
-    Element, ElementId, Event, Fragment, HasAttributes, IntoDynNode, LaunchConfig,
+    provide_context, provide_error_boundary, provide_root_context, queue_effect, remove_future,
-    ListenerCallback, MarkerWrapper, Mutation, Mutations, NoOpMutations, Ok, Properties, Result,
+    schedule_update, schedule_update_any, spawn, spawn_forever, spawn_isomorphic, suspend,
-    Runtime, ScopeId, ScopeState, SpawnIfAsync, Task, Template, TemplateAttribute, TemplateNode,
+    suspense_context, throw_error, try_consume_context, use_after_render, use_before_render,
-    VComponent, VNode, VNodeInner, VPlaceholder, VText, VirtualDom, WriteMutations,
+    use_drop, use_hook, use_hook_with_cleanup, vdom_is_rendering, with_owner, AnyValue, Attribute,
+    AttributeValue, Callback, CapturedError, Component, ComponentFunction, Context, DynamicNode,
+    Element, ElementId, ErrorBoundary, ErrorContext, Event, EventHandler, Fragment, HasAttributes,
+    IntoAttributeValue, IntoDynNode, LaunchConfig, ListenerCallback, MarkerWrapper, Mutation,
+    Mutations, NoOpMutations, Ok, OptionStringFromMarker, Properties, ReactiveContext, RenderError,
+    Result, Runtime, RuntimeGuard, ScopeId, ScopeState, SpawnIfAsync, SuperFrom, SuperInto,
+    SuspendedFuture, SuspenseBoundary, SuspenseBoundaryProps, SuspenseContext, SuspenseExtension,
+    Task, Template, TemplateAttribute, TemplateNode, VComponent, VNode, VNodeInner, VPlaceholder,
+    VText, VirtualDom, WriteMutations,
 };
 
-/// The purpose of this module is to alleviate imports of many common types
-///
-/// This includes types like [`Element`], and [`Component`].
-pub mod prelude {
-    pub use crate::innerlude::{
-        consume_context, consume_context_from_scope, current_owner, current_scope_id,
-        fc_to_builder, force_all_dirty, generation, has_context, needs_update, needs_update_any,
-        parent_scope, provide_context, provide_error_boundary, provide_root_context, queue_effect,
-        remove_future, spawn, spawn_forever, spawn_isomorphic, suspend, suspense_context,
-        throw_error, try_consume_context, use_after_render, use_before_render, use_drop, use_hook,
-        use_hook_with_cleanup, with_owner, AnyValue, Attribute, Callback, Component,
-        ComponentFunction, Context, Element, ErrorBoundary, ErrorContext, Event, EventHandler,
-        Fragment, HasAttributes, IntoAttributeValue, IntoDynNode, OptionStringFromMarker,
-        Properties, ReactiveContext, RenderError, Runtime, RuntimeGuard, ScopeId, ScopeState,
-        SuperFrom, SuperInto, SuspendedFuture, SuspenseBoundary, SuspenseBoundaryProps,
-        SuspenseContext, SuspenseExtension, Task, Template, TemplateAttribute, TemplateNode, VNode,
-        VNodeInner, VirtualDom,
-    };
-}
-
 pub use const_format;

packages/core/src/nodes.rs

@@ -1,15 +1,12 @@
-use dioxus_core_types::DioxusFormattable;
-
-use crate::events::ListenerCallback;
-use crate::innerlude::VProps;
-use crate::prelude::RenderError;
-use crate::{any_props::BoxedAnyProps, innerlude::ScopeState};
-use crate::{arena::ElementId, Element, Event};
 use crate::{
-    innerlude::{ElementRef, MountId},
+    any_props::BoxedAnyProps,
+    arena::ElementId,
+    events::ListenerCallback,
+    innerlude::{ElementRef, MountId, ScopeState, VProps},
     properties::ComponentFunction,
+    Element, Event, Properties, RenderError, ScopeId, VirtualDom,
 };
-use crate::{Properties, ScopeId, VirtualDom};
+use dioxus_core_types::DioxusFormattable;
 use std::ops::Deref;
 use std::rc::Rc;
 use std::vec;

packages/core/src/reactive_context.rs

@@ -1,9 +1,4 @@
-use crate::{
+use crate::{current_scope_id, scope_context::Scope, tasks::SchedulerMsg, Runtime, ScopeId};
-    prelude::{current_scope_id, ScopeId},
-    scope_context::Scope,
-    tasks::SchedulerMsg,
-    Runtime,
-};
 use futures_channel::mpsc::UnboundedReceiver;
 use generational_box::{BorrowMutError, GenerationalBox, SyncStorage};
 use std::{

packages/core/src/root_wrapper.rs

@@ -1,4 +1,7 @@
-use crate::{prelude::*, properties::RootProps, DynamicNode, VComponent};
+use crate::{
+    fc_to_builder, properties::RootProps, DynamicNode, Element, ErrorBoundary, Properties,
+    SuspenseBoundary, Template, TemplateNode, VComponent, VNode,
+};
 
 // We wrap the root scope in a component that renders it inside a default ErrorBoundary and SuspenseBoundary
 #[allow(non_snake_case)]

packages/core/src/scope_arena.rs

@@ -1,13 +1,11 @@
-use crate::innerlude::{throw_error, RenderError, ScopeOrder};
-use crate::nodes::AsVNode;
-use crate::prelude::ReactiveContext;
-use crate::scope_context::SuspenseLocation;
 use crate::{
     any_props::{AnyProps, BoxedAnyProps},
-    innerlude::ScopeState,
+    innerlude::{throw_error, RenderError, ScopeOrder, ScopeState},
-    scope_context::Scope,
+    nodes::AsVNode,
+    scope_context::{Scope, SuspenseLocation},
     scopes::ScopeId,
     virtual_dom::VirtualDom,
+    ReactiveContext,
 };
 use crate::{Element, VNode};
 

packages/core/src/scope_context.rs

@@ -1,8 +1,7 @@
-use crate::runtime::RuntimeError;
-use crate::{innerlude::SchedulerMsg, Runtime, ScopeId, Task};
 use crate::{
-    innerlude::{throw_into, CapturedError},
+    innerlude::{throw_into, CapturedError, SchedulerMsg, SuspenseContext},
-    prelude::SuspenseContext,
+    runtime::RuntimeError,
+    Runtime, ScopeId, Task,
 };
 use generational_box::{AnyStorage, Owner};
 use rustc_hash::FxHashSet;
@@ -159,7 +158,7 @@ impl Scope {
 
     /// Schedule an update for any component given its [`ScopeId`].
     ///
-    /// A component's [`ScopeId`] can be obtained from `use_hook` or the [`current_scope_id`](crate::prelude::current_scope_id) method.
+    /// A component's [`ScopeId`] can be obtained from `use_hook` or the [`current_scope_id`](crate::current_scope_id) method.
     ///
     /// This method should be used when you want to schedule an update for a component.
     ///
@@ -612,7 +611,7 @@ impl ScopeId {
             .on_scope(self, f)
     }
 
-    /// Throw a [`CapturedError`] into a scope. The error will bubble up to the nearest [`ErrorBoundary`](crate::prelude::ErrorBoundary) or the root of the app.
+    /// Throw a [`CapturedError`] into a scope. The error will bubble up to the nearest [`ErrorBoundary`](crate::ErrorBoundary) or the root of the app.
     ///
     /// # Examples
     /// ```rust, no_run

packages/core/src/scopes.rs

@@ -33,7 +33,7 @@ impl std::fmt::Debug for ScopeId {
 }
 
 impl ScopeId {
-    /// The ScopeId of the main scope passed into [`crate::prelude::VirtualDom::new`].
+    /// The ScopeId of the main scope passed into [`crate::VirtualDom::new`].
     ///
     /// This scope will last for the entire duration of your app, making it convenient for long-lived state
     /// that is created dynamically somewhere down the component tree.
@@ -51,7 +51,7 @@ impl ScopeId {
     pub const APP: ScopeId = ScopeId(3);
 
     /// The ScopeId of the topmost scope in the tree.
-    /// This will be higher up in the tree than [`ScopeId::APP`] because dioxus inserts a default [`crate::prelude::SuspenseBoundary`] and [`crate::prelude::ErrorBoundary`] at the root of the tree.
+    /// This will be higher up in the tree than [`ScopeId::APP`] because dioxus inserts a default [`crate::SuspenseBoundary`] and [`crate::ErrorBoundary`] at the root of the tree.
     // ScopeId(0) is the root scope wrapper
     pub const ROOT: ScopeId = ScopeId(0);
 

packages/core/tests/attr_cleanup.rs

@@ -2,8 +2,8 @@
 //!
 //! This tests to ensure we clean it up
 
-use dioxus::dioxus_core::{ElementId, Mutation::*};
 use dioxus::prelude::*;
+use dioxus_core::{generation, ElementId, IntoAttributeValue, Mutation::*};
 
 #[test]
 fn attrs_cycle() {

packages/core/tests/attributes_pass.rs

@@ -1,4 +1,5 @@
 use dioxus::prelude::*;
+use dioxus_core::TemplateNode;
 
 /// Make sure that rsx! is parsing templates and their attributes properly
 #[test]

packages/core/tests/bubble_error.rs

@@ -1,6 +1,7 @@
 //! we should properly bubble up errors from components
 
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 fn app() -> Element {
     let raw = match generation() % 2 {

packages/core/tests/children_drop_futures.rs

@@ -3,6 +3,7 @@
 use std::{sync::atomic::AtomicUsize, time::Duration};
 
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 #[tokio::test]
 async fn child_futures_drop_first() {

packages/core/tests/context_api.rs

@@ -1,5 +1,6 @@
 use dioxus::dioxus_core::{ElementId, Mutation::*};
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 #[test]
 fn state_shares() {

packages/core/tests/cycle.rs

@@ -1,5 +1,6 @@
 use dioxus::dioxus_core::{ElementId, Mutation::*};
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 /// As we clean up old templates, the ID for the node should cycle
 #[test]

packages/core/tests/diff_dynamic_node.rs

@@ -1,5 +1,6 @@
 use dioxus::dioxus_core::{ElementId, Mutation::*};
 use dioxus::prelude::*;
+use dioxus_core::generation;
 use pretty_assertions::assert_eq;
 
 #[test]

packages/core/tests/diff_element.rs

@@ -1,6 +1,7 @@
 use dioxus::dioxus_core::Mutation::*;
 use dioxus::dioxus_core::{AttributeValue, ElementId, NoOpMutations};
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 #[test]
 fn text_diff() {

packages/core/tests/diff_keyed_list.rs

@@ -6,6 +6,7 @@
 
 use dioxus::dioxus_core::{ElementId, Mutation::*};
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 /// Should result in moves, but not removals or additions
 #[test]

packages/core/tests/diff_unkeyed_list.rs

@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use dioxus::dioxus_core::{ElementId, Mutation::*};
 use dioxus::prelude::*;
-use dioxus_core::Mutation;
+use dioxus_core::{generation, Mutation};
 use pretty_assertions::assert_eq;
 
 #[test]

packages/core/tests/kitchen_sink.rs

@@ -1,5 +1,6 @@
 use dioxus::dioxus_core::{ElementId, Mutation};
 use dioxus::prelude::*;
+use dioxus_core::IntoAttributeValue;
 use pretty_assertions::assert_eq;
 
 fn basic_syntax_is_a_template() -> Element {

packages/core/tests/miri_simple.rs

@@ -1,4 +1,5 @@
 use dioxus::prelude::*;
+use dioxus_core::generation;
 
 #[test]
 fn app_drops() {

packages/core/tests/miri_stress.rs

@@ -3,7 +3,7 @@
 use std::rc::Rc;
 
 use dioxus::prelude::*;
-use dioxus_core::NoOpMutations;
+use dioxus_core::{generation, NoOpMutations};
 
 /// This test checks that we should release all memory used by the virtualdom when it exits.
 ///

packages/core/tests/suspense.rs

@@ -1,5 +1,5 @@
 use dioxus::prelude::*;
-use dioxus_core::{AttributeValue, ElementId, Mutation};
+use dioxus_core::{generation, AttributeValue, ElementId, Mutation};
 use pretty_assertions::assert_eq;
 use std::future::poll_fn;
 use std::task::Poll;

packages/core/tests/task.rs

@@ -3,6 +3,7 @@
 use std::{sync::atomic::AtomicUsize, time::Duration};
 
 use dioxus::prelude::*;
+use dioxus_core::{generation, needs_update, spawn_forever};
 
 async fn run_vdom(app: fn() -> Element) {
     let mut dom = VirtualDom::new(app);

packages/core/tests/tracing.rs

@@ -1,6 +1,6 @@
 use dioxus::html::SerializedHtmlEventConverter;
 use dioxus::prelude::*;
-use dioxus_core::ElementId;
+use dioxus_core::{ElementId, Event};
 use std::{any::Any, rc::Rc};
 use tracing_fluent_assertions::{AssertionRegistry, AssertionsLayer};
 use tracing_subscriber::{layer::SubscriberExt, Registry};

packages/desktop/src/assets.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::Callback;
+use dioxus_core::Callback;
 use rustc_hash::FxHashMap;
 use std::{cell::RefCell, rc::Rc};
 use wry::{http::Request, RequestAsyncResponder};

packages/desktop/src/desktop_context.rs

@@ -8,7 +8,7 @@ use crate::{
     webview::PendingWebview,
     AssetRequest, Config, WindowCloseBehaviour, WryEventHandler,
 };
-use dioxus_core::{prelude::Callback, VirtualDom};
+use dioxus_core::{Callback, VirtualDom};
 use std::{
     cell::Cell,
     future::{Future, IntoFuture},
@@ -31,7 +31,7 @@ use tao::platform::ios::WindowExtIOS;
 ///
 /// This function will panic if it is called outside of the context of a Dioxus App.
 pub fn window() -> DesktopContext {
-    dioxus_core::prelude::consume_context()
+    dioxus_core::consume_context()
 }
 
 /// A handle to the [`DesktopService`] that can be passed around.

packages/desktop/src/document.rs

@@ -1,5 +1,5 @@
 use crate::{query::Query, DesktopContext, WeakDesktopContext};
-use dioxus_core::prelude::queue_effect;
+use dioxus_core::queue_effect;
 use dioxus_document::{
     create_element_in_head, Document, Eval, EvalError, Evaluator, LinkProps, MetaProps,
     ScriptProps, StyleProps,

packages/desktop/src/file_upload.rs

@@ -11,8 +11,8 @@ use dioxus_html::{
     point_interaction::{
         InteractionElementOffset, InteractionLocation, ModifiersInteraction, PointerInteraction,
     },
-    prelude::{SerializedMouseData, SerializedPointInteraction},
+    FileEngine, HasDragData, HasFileData, HasFormData, HasMouseData, SerializedMouseData,
-    FileEngine, HasDragData, HasFileData, HasFormData, HasMouseData,
+    SerializedPointInteraction,
 };
 
 use serde::Deserialize;
@@ -233,7 +233,7 @@ impl InteractionElementOffset for DesktopFileDragEvent {
 }
 
 impl ModifiersInteraction for DesktopFileDragEvent {
-    fn modifiers(&self) -> dioxus_html::prelude::Modifiers {
+    fn modifiers(&self) -> dioxus_html::Modifiers {
         self.mouse.modifiers()
     }
 }

packages/desktop/src/hooks.rs

@@ -4,10 +4,7 @@ use crate::{
     assets::*, ipc::UserWindowEvent, shortcut::IntoAccelerator, window, DesktopContext,
     HotKeyState, ShortcutHandle, ShortcutRegistryError, WryEventHandler,
 };
-use dioxus_core::{
+use dioxus_core::{consume_context, use_hook, use_hook_with_cleanup, Runtime};
-    prelude::{consume_context, use_hook_with_cleanup},
-    use_hook, Runtime,
-};
 
 use dioxus_hooks::use_callback;
 use tao::{event::Event, event_loop::EventLoopWindowTarget};
@@ -22,7 +19,7 @@ pub fn use_window() -> DesktopContext {
 pub fn use_wry_event_handler(
     mut handler: impl FnMut(&Event<UserWindowEvent>, &EventLoopWindowTarget<UserWindowEvent>) + 'static,
 ) -> WryEventHandler {
-    use dioxus_core::prelude::current_scope_id;
+    use dioxus_core::current_scope_id;
 
     // Capture the current runtime and scope ID.
     let runtime = Runtime::current().unwrap();

packages/desktop/src/trayicon.rs

@@ -1,9 +1,6 @@
 //! tray icon
 
-use dioxus_core::{
+use dioxus_core::{provide_context, try_consume_context, use_hook};
-    prelude::{provide_context, try_consume_context},
-    use_hook,
-};
 
 #[cfg(not(any(target_os = "ios", target_os = "android")))]
 pub use tray_icon::*;

packages/devtools/src/lib.rs

@@ -44,7 +44,7 @@ pub fn try_apply_changes(dom: &VirtualDom, msg: &HotReloadMsg) -> Result<(), Pat
 
                 if msg.for_pid == our_pid {
                     unsafe { subsecond::apply_patch(jump_table) }?;
-                    dioxus_core::prelude::force_all_dirty();
+                    dioxus_core::force_all_dirty();
                     ctx.clear::<Signal<Option<HotReloadedTemplate>>>();
                 }
             }

packages/dioxus-lib/src/lib.rs

@@ -3,6 +3,8 @@
 #![doc(html_logo_url = "https://avatars.githubusercontent.com/u/79236386")]
 #![doc(html_favicon_url = "https://avatars.githubusercontent.com/u/79236386")]
 
+pub use dioxus_core as core;
+
 #[cfg(feature = "hooks")]
 pub use dioxus_hooks as hooks;
 
@@ -10,8 +12,8 @@ pub use dioxus_hooks as hooks;
 pub use dioxus_signals as signals;
 
 pub mod events {
-    #[cfg(feature = "html")]
+    // #[cfg(feature = "html")]
-    pub use dioxus_html::prelude::*;
+    // pub use dioxus_html::prelude::*;
 }
 
 #[cfg(feature = "html")]
@@ -43,8 +45,6 @@ pub mod prelude {
     #[cfg(feature = "signals")]
     pub use dioxus_signals::*;
 
-    pub use dioxus_core::prelude::*;
-
     #[cfg(feature = "macro")]
     #[allow(deprecated)]
     pub use dioxus_core_macro::{component, rsx, Props};
@@ -56,7 +56,14 @@ pub mod prelude {
     pub use dioxus_html as dioxus_elements;
 
     #[cfg(feature = "html")]
-    pub use dioxus_elements::{global_attributes, prelude::*, svg_attributes};
+    pub use dioxus_elements::{events::*, global_attributes, svg_attributes, traits::*};
 
     pub use dioxus_core;
+
+    pub use dioxus_core::{
+        consume_context, provide_context, spawn, suspend, try_consume_context, use_hook, Attribute,
+        Callback, Component, Context, Element, ErrorBoundary, ErrorContext, Event, EventHandler,
+        Fragment, HasAttributes, IntoDynNode, RenderError, ScopeId, SuspenseBoundary,
+        SuspenseContext, SuspenseExtension, VNode, VirtualDom,
+    };
 }

packages/dioxus/src/launch.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::new_without_default)]
 #![allow(unused)]
 use dioxus_config_macro::*;
-use dioxus_core::LaunchConfig;
+use dioxus_core::{Element, LaunchConfig};
 use std::any::Any;
 
 use crate::prelude::*;
@@ -299,7 +299,7 @@ impl LaunchBuilder {
         // Set any flags if we're running under fullstack
         #[cfg(feature = "fullstack")]
         {
-            use dioxus_fullstack::prelude::server_fn::client::{get_server_url, set_server_url};
+            use dioxus_fullstack::server_fn::client::{get_server_url, set_server_url};
 
             // Make sure to set the server_fn endpoint if the user specified the fullstack feature
             // We only set this on native targets

packages/dioxus/src/lib.rs

@@ -32,6 +32,8 @@ pub use dioxus_core::{CapturedError, Ok, Result};
 #[cfg_attr(docsrs, doc(cfg(feature = "launch")))]
 mod launch;
 
+pub use dioxus_core as core;
+
 #[cfg(feature = "launch")]
 #[cfg_attr(docsrs, doc(cfg(feature = "launch")))]
 pub use crate::launch::*;
@@ -47,7 +49,7 @@ pub use dioxus_signals as signals;
 pub mod events {
     #[cfg(feature = "html")]
     #[cfg_attr(docsrs, doc(cfg(feature = "html")))]
-    pub use dioxus_html::prelude::*;
+    pub use dioxus_html::events::*;
 }
 
 #[cfg(feature = "document")]
@@ -143,8 +145,6 @@ pub mod prelude {
     #[cfg_attr(docsrs, doc(cfg(feature = "signals")))]
     pub use dioxus_signals::*;
 
-    pub use dioxus_core::prelude::*;
-
     #[cfg(feature = "macro")]
     #[cfg_attr(docsrs, doc(cfg(feature = "macro")))]
     #[allow(deprecated)]
@@ -160,7 +160,10 @@ pub mod prelude {
 
     #[cfg(feature = "html")]
     #[cfg_attr(docsrs, doc(cfg(feature = "html")))]
-    pub use dioxus_elements::{global_attributes, prelude::*, svg_attributes};
+    pub use dioxus_elements::{
+        events::*, extensions::*, global_attributes, keyboard_types, svg_attributes, traits::*,
+        Code, GlobalAttributesExtension, Key, Location, Modifiers, SvgAttributesExtension,
+    };
 
     #[cfg(feature = "devtools")]
     #[cfg_attr(docsrs, doc(cfg(feature = "devtools")))]
@@ -170,7 +173,15 @@ pub mod prelude {
 
     #[cfg(feature = "fullstack")]
     #[cfg_attr(docsrs, doc(cfg(feature = "fullstack")))]
-    pub use dioxus_fullstack::prelude::*;
+    pub use dioxus_fullstack::{
+        server, server_fn, use_server_cached, use_server_future, ServerFnError, ServerFnResult,
+    };
+
+    #[cfg(feature = "server")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "server")))]
+    pub use dioxus_server::{
+        extract, DioxusRouterExt, DioxusRouterFnExt, FromContext, ServeConfig,
+    };
 
     #[cfg(feature = "router")]
     #[cfg_attr(docsrs, doc(cfg(feature = "router")))]
@@ -178,7 +189,10 @@ pub mod prelude {
 
     #[cfg(feature = "router")]
     #[cfg_attr(docsrs, doc(cfg(feature = "router")))]
-    pub use dioxus_router::prelude::*;
+    pub use dioxus_router::{
+        hooks::*, navigator, use_navigator, GoBackButton, GoForwardButton, Link, NavigationTarget,
+        Outlet, Routable, Router,
+    };
 
     #[cfg(feature = "asset")]
     #[cfg_attr(docsrs, doc(cfg(feature = "asset")))]
@@ -187,4 +201,11 @@ pub mod prelude {
     #[cfg(feature = "wasm-split")]
     #[cfg_attr(docsrs, doc(cfg(feature = "wasm-split")))]
     pub use wasm_splitter as wasm_split;
+
+    pub use dioxus_core::{
+        consume_context, provide_context, spawn, suspend, try_consume_context, use_hook, Attribute,
+        Callback, Component, Context, Element, ErrorBoundary, ErrorContext, Event, EventHandler,
+        Fragment, HasAttributes, IntoDynNode, RenderError, ScopeId, SuspenseBoundary,
+        SuspenseContext, SuspenseExtension, VNode, VirtualDom,
+    };
 }

packages/document/src/elements/link.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::document;
+use dioxus_core::{use_hook, VNode};
 use dioxus_html as dioxus_elements;
 
 #[non_exhaustive]

packages/document/src/elements/meta.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::document;
+use dioxus_core::{use_hook, VNode};
 use dioxus_html as dioxus_elements;
 
 #[non_exhaustive]

packages/document/src/elements/mod.rs

@@ -2,7 +2,7 @@
 
 use std::{cell::RefCell, collections::HashSet, rc::Rc};
 
-use dioxus_core::{prelude::*, DynamicNode};
+use dioxus_core::{Attribute, DynamicNode, Element, RenderError, ScopeId, Template, TemplateNode};
 use dioxus_core_macro::*;
 
 mod link;
@@ -23,6 +23,8 @@ pub use title::*;
 fn use_update_warning<T: PartialEq + Clone + 'static>(value: &T, name: &'static str) {
     #[cfg(debug_assertions)]
     {
+        use dioxus_core::use_hook;
+
         let cloned_value = value.clone();
         let initial = use_hook(move || value.clone());
 

packages/document/src/elements/script.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::document;
+use dioxus_core::{use_hook, VNode};
 use dioxus_html as dioxus_elements;
 
 #[non_exhaustive]

packages/document/src/elements/style.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::document;
+use dioxus_core::{use_hook, VNode};
 use dioxus_html as dioxus_elements;
 
 #[non_exhaustive]

packages/document/src/elements/title.rs

@@ -1,3 +1,5 @@
+use dioxus_core::{use_hook, VNode};
+
 use crate::document;
 
 use super::*;

packages/document/src/lib.rs

@@ -12,7 +12,7 @@ pub use eval::*;
 
 /// Get the document provider for the current platform or a no-op provider if the platform doesn't document functionality.
 pub fn document() -> Rc<dyn Document> {
-    match dioxus_core::prelude::try_consume_context::<Rc<dyn Document>>() {
+    match dioxus_core::try_consume_context::<Rc<dyn Document>>() {
         Some(document) => document,
         None => {
             tracing::error!(

packages/fullstack-hooks/src/history.rs

@@ -2,7 +2,7 @@
 
 use std::cell::OnceCell;
 
-use dioxus_core::{prelude::queue_effect, schedule_update};
+use dioxus_core::{queue_effect, schedule_update};
 use dioxus_fullstack_protocol::is_hydrating;
 use dioxus_history::History;
 

packages/fullstack-hooks/src/hooks/server_cached.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::use_hook;
+use dioxus_core::use_hook;
 use dioxus_fullstack_protocol::SerializeContextEntry;
 use serde::{de::DeserializeOwned, Serialize};
 

packages/fullstack-hooks/src/hooks/server_future.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::{suspend, use_hook, RenderError};
+use dioxus_core::{suspend, use_hook, RenderError};
 use dioxus_hooks::*;
 use dioxus_signals::Readable;
 use serde::{de::DeserializeOwned, Serialize};

packages/fullstack-hooks/src/lib.rs

@@ -5,9 +5,5 @@ pub mod history;
 mod hooks;
 mod streaming;
 
-pub mod prelude {
-    //! A prelude of commonly used items in dioxus-fullstack-hooks.
-
 pub use crate::hooks::*;
 pub use crate::streaming::*;
-}

packages/fullstack-hooks/src/streaming.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::try_consume_context;
+use dioxus_core::try_consume_context;
 use dioxus_signals::{Readable, Signal, Writable};
 
 /// The status of the streaming response

packages/fullstack-protocol/src/lib.rs

@@ -174,8 +174,8 @@ pub fn serialize_context() -> HydrationContext {
     #[cfg(not(feature = "web"))]
     {
         // On the server each scope creates the context lazily
-        dioxus_core::prelude::has_context()
+        dioxus_core::has_context()
-            .unwrap_or_else(|| dioxus_core::prelude::provide_context(HydrationContext::default()))
+            .unwrap_or_else(|| dioxus_core::provide_context(HydrationContext::default()))
     }
 }
 

packages/fullstack/src/error.rs

@@ -4,7 +4,7 @@ use std::{
     str::FromStr,
 };
 
-use dioxus_lib::prelude::{dioxus_core::CapturedError, RenderError};
+use dioxus_lib::core::{CapturedError, RenderError};
 use serde::{de::DeserializeOwned, Serialize};
 use server_fn::{
     codec::JsonEncoding,

packages/fullstack/src/lib.rs

@@ -12,19 +12,16 @@ mod error;
 #[cfg(all(feature = "web", feature = "document"))]
 pub use web::FullstackWebDocument;
 
-#[cfg(feature = "server")]
-pub use dioxus_server::*;
-
 pub use dioxus_fullstack_hooks::history::FullstackHistory;
 
-/// A prelude of commonly used items in dioxus-fullstack.
-pub mod prelude {
-    pub use dioxus_fullstack_hooks::prelude::*;
-
 pub use crate::error::{ServerFnError, ServerFnResult};
-    pub use dioxus_server_macro::*;
+pub use dioxus_fullstack_hooks::*;
-    pub use server_fn::{self, ServerFn as _};
-
 #[cfg(feature = "server")]
-    pub use dioxus_server::prelude::*;
+pub use dioxus_server::*;
-}
+pub use dioxus_server_macro::*;
+pub use server_fn::{
+    self, client,
+    client::{get_server_url, set_server_url},
+    codec, server, BoxedStream, ContentType, Decodes, Encodes, Format, FormatType, ServerFn as _,
+    ServerFn, Websocket,
+};

packages/history/src/lib.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::{provide_context, provide_root_context};
+use dioxus_core::{provide_context, provide_root_context};
 use std::{rc::Rc, sync::Arc};
 
 mod memory;
@@ -6,7 +6,7 @@ pub use memory::*;
 
 /// Get the history provider for the current platform if the platform doesn't implement a history functionality.
 pub fn history() -> Rc<dyn History> {
-    match dioxus_core::prelude::try_consume_context::<Rc<dyn History>>() {
+    match dioxus_core::try_consume_context::<Rc<dyn History>>() {
         Some(history) => history,
         None => {
             tracing::error!("Unable to find a history provider in the renderer. Make sure your renderer supports the Router. Falling back to the in-memory history provider.");

packages/hooks/src/use_after_suspense_resolved.rs

@@ -1,4 +1,4 @@
-use dioxus_core::{prelude::suspense_context, use_hook};
+use dioxus_core::{suspense_context, use_hook};
 
 /// Run a closure after the suspense boundary this is under is resolved. The
 /// closure will be run immediately if the suspense boundary is already resolved

packages/hooks/src/use_callback.rs

@@ -1,5 +1,4 @@
-use dioxus_core::prelude::use_hook;
+use dioxus_core::{use_hook, Callback};
-use dioxus_core::prelude::Callback;
 
 /// Create a callback that's always up to date. Whenever this hook is called the inner callback will be replaced with the new callback but the handle will remain.
 ///

packages/hooks/src/use_context.rs

@@ -1,7 +1,4 @@
-use dioxus_core::{
+use dioxus_core::{consume_context, provide_context, try_consume_context, use_hook};
-    prelude::{consume_context, provide_context, try_consume_context},
-    use_hook,
-};
 
 /// Consume some context in the tree, providing a sharable handle to the value
 ///

packages/hooks/src/use_coroutine.rs

@@ -1,6 +1,6 @@
 use crate::{use_context_provider, use_future, UseFuture};
-use dioxus_core::prelude::{consume_context, use_hook};
 use dioxus_core::Task;
+use dioxus_core::{consume_context, use_hook};
 use dioxus_signals::*;
 pub use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
 use std::future::Future;

packages/hooks/src/use_effect.rs

@@ -1,6 +1,6 @@
 use std::{cell::Cell, rc::Rc};
 
-use dioxus_core::prelude::*;
+use dioxus_core::*;
 use futures_util::StreamExt;
 
 use crate::use_callback;

packages/hooks/src/use_future.rs

@@ -1,6 +1,6 @@
 #![allow(missing_docs)]
 use crate::{use_callback, use_hook_did_run, use_signal};
-use dioxus_core::prelude::*;
+use dioxus_core::{use_hook, Callback, Task};
 use dioxus_signals::*;
 use std::future::Future;
 use std::ops::Deref;
@@ -8,7 +8,7 @@ use std::ops::Deref;
 /// A hook that allows you to spawn a future the first time you render a component.
 ///
 ///
-/// This future will **not** run on the server. To run a future on the server, you should use [`spawn_isomorphic`] directly.
+/// This future will **not** run on the server. To run a future on the server, you should use [`dioxus_core::spawn_isomorphic`] directly.
 ///
 ///
 /// `use_future` **won't return a value**. If you want to return a value from a future, use [`crate::use_resource()`] instead.
@@ -50,7 +50,7 @@ where
 
     let callback = use_callback(move |_| {
         let fut = future();
-        spawn(async move {
+        dioxus_core::spawn(async move {
             state.set(UseFutureState::Pending);
             fut.await;
             state.set(UseFutureState::Ready);

packages/hooks/src/use_hook_did_run.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::*;
+use dioxus_core::{use_after_render, use_before_render, use_hook};
 use dioxus_signals::{CopyValue, Writable};
 
 /// A hook that uses before/after lifecycle hooks to determine if the hook was run

packages/hooks/src/use_memo.rs

@@ -1,5 +1,5 @@
 use crate::use_callback;
-use dioxus_core::prelude::*;
+use dioxus_core::use_hook;
 use dioxus_signals::Memo;
 
 #[doc = include_str!("../docs/derived_state.md")]

packages/hooks/src/use_on_destroy.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::use_drop;
+use dioxus_core::use_drop;
 
 #[deprecated(note = "Use `use_drop` instead, which has the same functionality.")]
 pub fn use_on_unmount<D: FnOnce() + 'static>(destroy: D) {

packages/hooks/src/use_resource.rs

@@ -1,7 +1,11 @@
 #![allow(missing_docs)]
 
 use crate::{use_callback, use_signal};
-use dioxus_core::prelude::*;
+
+use dioxus_core::{
+    spawn, use_hook, Callback, IntoAttributeValue, IntoDynNode, ReactiveContext, RenderError,
+    SuspendedFuture, Task,
+};
 use dioxus_signals::*;
 use futures_util::{future, pin_mut, FutureExt, StreamExt};
 use std::ops::Deref;

packages/hooks/src/use_root_context.rs

@@ -1,4 +1,4 @@
-use dioxus_core::{prelude::provide_root_context, prelude::try_consume_context, use_hook};
+use dioxus_core::{provide_root_context, try_consume_context, use_hook};
 
 /// Try to get a value from the root of the virtual dom, if it doesn't exist, create a new one with the closure provided.
 ///

packages/hooks/src/use_set_compare.rs

@@ -1,7 +1,6 @@
-use std::hash::Hash;
+use dioxus_core::use_hook;
-
-use dioxus_core::prelude::*;
 use dioxus_signals::{ReadOnlySignal, SetCompare};
+use std::hash::Hash;
 
 /// Creates a new SetCompare which efficiently tracks when a value changes to check if it is equal to a set of values.
 ///

packages/hooks/src/use_signal.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::*;
+use dioxus_core::use_hook;
 use dioxus_signals::{Signal, SignalData, Storage, SyncStorage, UnsyncStorage};
 
 /// Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.

packages/hooks/tests/effect.rs

@@ -30,7 +30,7 @@ async fn effects_rerun() {
                     println!("Signal: {:?}", signal);
 
                     // Stop the wait for work manually
-                    needs_update();
+                    dioxus_core::needs_update();
                 }
             });
             signal += 1;

packages/hooks/tests/memo.rs

@@ -1,3 +1,5 @@
+use dioxus_core::generation;
+
 #[tokio::test]
 async fn memo_updates() {
     use std::cell::RefCell;

packages/html/src/attribute_groups.rs

@@ -1,8 +1,8 @@
 #![allow(non_upper_case_globals)]
 #![allow(deprecated)]
 
-use dioxus_core::prelude::IntoAttributeValue;
 use dioxus_core::HasAttributes;
+use dioxus_core::IntoAttributeValue;
 use dioxus_html_internal_macro::impl_extension_attributes;
 
 use crate::AttributeDescription;

packages/html/src/elements.rs

@@ -1,7 +1,7 @@
 #![allow(non_upper_case_globals)]
 
-use dioxus_core::prelude::IntoAttributeValue;
 use dioxus_core::HasAttributes;
+use dioxus_core::IntoAttributeValue;
 #[cfg(feature = "hot-reload-context")]
 use dioxus_core_types::HotReloadingContext;
 use dioxus_html_internal_macro::impl_extension_attributes;

packages/html/src/events/drag.rs

@@ -1,6 +1,6 @@
 use crate::geometry::{ClientPoint, Coordinates, ElementPoint, PagePoint, ScreenPoint};
 use crate::input_data::{MouseButton, MouseButtonSet};
-use crate::prelude::*;
+use crate::*;
 
 use dioxus_core::Event;
 use keyboard_types::Modifiers;

packages/html/src/events/keyboard.rs

@@ -2,7 +2,7 @@ use dioxus_core::Event;
 use keyboard_types::{Code, Key, Location, Modifiers};
 use std::fmt::Debug;
 
-use crate::prelude::ModifiersInteraction;
+use crate::ModifiersInteraction;
 
 #[cfg(feature = "serialize")]
 fn resilient_deserialize_code<'de, D>(deserializer: D) -> Result<Code, D::Error>

packages/html/src/events/mod.rs

@@ -25,7 +25,7 @@ macro_rules! impl_event {
                 #[doc(alias = $js_name)]
             )?
             #[inline]
-            pub fn $name<__Marker>(mut _f: impl ::dioxus_core::prelude::SuperInto<::dioxus_core::ListenerCallback<$data>, __Marker>) -> ::dioxus_core::Attribute {
+            pub fn $name<__Marker>(mut _f: impl ::dioxus_core::SuperInto<::dioxus_core::ListenerCallback<$data>, __Marker>) -> ::dioxus_core::Attribute {
                 let event_handler = _f.super_into();
                 ::dioxus_core::Attribute::new(
                     impl_event!(@name $name $($js_name)?),

packages/html/src/events/mouse.rs

@@ -1,6 +1,6 @@
 use crate::geometry::{ClientPoint, Coordinates, ElementPoint, PagePoint, ScreenPoint};
 use crate::input_data::{MouseButton, MouseButtonSet};
-use crate::prelude::*;
+use crate::*;
 use dioxus_core::Event;
 use keyboard_types::Modifiers;
 

packages/html/src/events/pointer.rs

@@ -1,7 +1,7 @@
 use dioxus_core::Event;
 use keyboard_types::Modifiers;
 
-use crate::{geometry::*, input_data::*, prelude::*};
+use crate::{geometry::*, input_data::*, *};
 
 /// A synthetic event that wraps a web-style [`PointerEvent`](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent)
 pub type PointerEvent = Event<PointerData>;

packages/html/src/events/touch.rs

@@ -2,7 +2,7 @@ use dioxus_core::Event;
 use keyboard_types::Modifiers;
 
 use crate::geometry::*;
-use crate::prelude::{InteractionLocation, ModifiersInteraction};
+use crate::{InteractionLocation, ModifiersInteraction};
 
 pub type TouchEvent = Event<TouchData>;
 pub struct TouchData {

packages/html/src/events/wheel.rs

@@ -1,9 +1,12 @@
 use dioxus_core::Event;
+use keyboard_types::Modifiers;
 use std::fmt::Formatter;
 
-use crate::geometry::*;
+use crate::{geometry::*, InteractionLocation, ModifiersInteraction, PointerInteraction};
-use crate::input_data::{MouseButton, MouseButtonSet};
+use crate::{
-use crate::prelude::*;
+    input_data::{MouseButton, MouseButtonSet},
+    InteractionElementOffset,
+};
 
 use super::HasMouseData;
 

packages/html/src/lib.rs

@@ -41,15 +41,17 @@ pub use elements::*;
 pub use events::*;
 pub use render_template::*;
 
+pub use crate::attribute_groups::{GlobalAttributesExtension, SvgAttributesExtension};
+pub use crate::elements::extensions::*;
+pub use crate::point_interaction::*;
+pub use keyboard_types::{self, Code, Key, Location, Modifiers};
+
+pub mod traits {
+    pub use crate::events::*;
+    pub use crate::point_interaction::*;
+}
+
 pub mod extensions {
     pub use crate::attribute_groups::{GlobalAttributesExtension, SvgAttributesExtension};
     pub use crate::elements::extensions::*;
 }
-
-pub mod prelude {
-    pub use crate::attribute_groups::{GlobalAttributesExtension, SvgAttributesExtension};
-    pub use crate::elements::extensions::*;
-    pub use crate::events::*;
-    pub use crate::point_interaction::*;
-    pub use keyboard_types::{self, Code, Key, Location, Modifiers};
-}

packages/liveview/src/adapters/axum_adapter.rs

@@ -41,7 +41,7 @@ impl LiveviewRouter for Router {
     fn with_virtual_dom(
         self,
         route: &str,
-        app: impl Fn() -> dioxus_core::prelude::VirtualDom + Send + Sync + 'static,
+        app: impl Fn() -> dioxus_core::VirtualDom + Send + Sync + 'static,
     ) -> Self {
         let view = crate::LiveViewPool::new();
 

packages/liveview/src/config.rs

@@ -33,7 +33,7 @@ impl<R: LiveviewRouter> Config<R> {
     }
 
     /// Create a new configuration for the LiveView server.
-    pub fn with_app(mut self, app: fn() -> dioxus_core::prelude::Element) -> Self {
+    pub fn with_app(mut self, app: fn() -> dioxus_core::Element) -> Self {
         self.router = self.router.with_app(&self.route, app);
         self
     }

packages/liveview/src/document.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::queue_effect;
+use dioxus_core::queue_effect;
 use dioxus_core::ScopeId;
 use dioxus_document::{
     create_element_in_head, Document, Eval, EvalError, Evaluator, LinkProps, MetaProps,

packages/liveview/src/history.rs

@@ -1,4 +1,4 @@
-use dioxus_core::prelude::spawn;
+use dioxus_core::spawn;
 use dioxus_document::Eval;
 use dioxus_history::History;
 use serde::{Deserialize, Serialize};

packages/liveview/src/pool.rs

@@ -5,7 +5,8 @@ use crate::{
     query::{QueryEngine, QueryResult},
     LiveViewError,
 };
-use dioxus_core::prelude::*;
+
+use dioxus_core::{provide_context, Element, Event, ScopeId, VirtualDom};
 use dioxus_html::{EventData, HtmlEvent, PlatformEventData};
 use dioxus_interpreter_js::MutationState;
 use futures_util::{pin_mut, SinkExt, StreamExt};

packages/native/src/dioxus_renderer.rs

@@ -10,7 +10,7 @@ pub use anyrender_vello::{
 };
 
 pub fn use_wgpu<T: CustomPaintSource>(create_source: impl FnOnce() -> T) -> u64 {
-    use dioxus_core::prelude::{consume_context, use_hook_with_cleanup};
+    use dioxus_core::{consume_context, use_hook_with_cleanup};
 
     let (_renderer, id) = use_hook_with_cleanup(
         || {

packages/playwright-tests/fullstack/src/main.rs

@@ -5,10 +5,8 @@
 // - Hydration
 
 #![allow(non_snake_case)]
-use dioxus::prelude::{
+use dioxus::fullstack::{codec::JsonEncoding, commit_initial_chunk, BoxedStream, Websocket};
-    server_fn::{codec::JsonEncoding, BoxedStream, Websocket},
+use dioxus::prelude::*;
-    *,
-};
 use futures::{channel::mpsc, SinkExt, StreamExt};
 
 fn main() {
@@ -77,6 +75,7 @@ fn DefaultServerFnCodec() -> Element {
 
 #[cfg(feature = "server")]
 async fn assert_server_context_provided() {
+    use dioxus::server::{extract, FromContext};
     let FromContext(i): FromContext<u32> = extract().await.unwrap();
     assert_eq!(i, 1234u32);
 }

packages/playwright-tests/nested-suspense/src/lib.rs

@@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize};
 
 pub fn app() -> Element {
     // Start streaming immediately
-    use_hook(commit_initial_chunk);
+    use_hook(dioxus::fullstack::commit_initial_chunk);
 
     rsx! {
         SuspenseBoundary {

packages/playwright-tests/nested-suspense/src/ssg.rs

@@ -9,7 +9,7 @@ fn main() {
         .with_cfg(server_only! {
             ServeConfig::builder()
                 .incremental(
-                    IncrementalRendererConfig::new()
+                    dioxus::server::IncrementalRendererConfig::new()
                         .static_dir(
                             std::env::current_exe()
                                 .unwrap()

packages/playwright-tests/suspense-carousel/src/main.rs

@@ -5,7 +5,7 @@
 // - Server futures
 
 #![allow(non_snake_case, unused)]
-use dioxus::prelude::*;
+use dioxus::{fullstack::commit_initial_chunk, prelude::*};
 use serde::{Deserialize, Serialize};
 
 fn app() -> Element {

packages/playwright-tests/wasm-split-harness/src/main.rs

@@ -134,7 +134,7 @@ async fn add_body_element() {
     let output_box = document.get_element_by_id("output-box").unwrap_throw();
     output_box.append_child(&output).unwrap_throw();
 
-    dioxus::prelude::queue_effect(move || {
+    dioxus::core::queue_effect(move || {
         web_sys::console::log_1(&"add body async internal!".into());
         *GLOBAL_COUNTER.write() += 2;
     });
@@ -146,7 +146,7 @@ async fn gzip_it() {
     let reader = Box::pin(futures::io::BufReader::new(DATA));
     let reader: Pin<Box<dyn futures::io::AsyncBufRead>> = reader;
 
-    dioxus::prelude::spawn(async move {
+    dioxus::core::spawn(async move {
         let mut fut = Box::pin(async_compression::futures::bufread::GzipDecoder::new(
             reader,
         ));
@@ -177,7 +177,7 @@ async fn brotli_it(data: &'static [u8]) {
     let reader = Box::pin(futures::io::BufReader::new(data));
     let reader: Pin<Box<dyn futures::io::AsyncBufRead>> = reader;
 
-    dioxus::prelude::spawn(async move {
+    dioxus::core::spawn(async move {
         let mut fut = Box::pin(async_compression::futures::bufread::BrotliDecoder::new(
             reader,
         ));
@@ -274,7 +274,7 @@ fn ChildSplit() -> Element {
             button {
                 onclick: move |_| {
                     set_stars("stars".to_string(), num + 1);
-                    dioxus::prelude::needs_update();
+                    dioxus::core::needs_update();
                 },
                 "Add Star"
             }

packages/router-macro/src/segment.rs

@@ -30,7 +30,9 @@ impl RouteSegment {
                     write!(f, "/{}", dioxus_router::exports::percent_encoding::utf8_percent_encode(&as_string, dioxus_router::exports::PATH_ASCII_SET))?;
                 }
             },
-            Self::CatchAll(ident, _) => quote! { #ident.display_route_segments(f)?; },
+            Self::CatchAll(ident, _) => quote! {
+                dioxus_router::ToRouteSegments::display_route_segments(#ident,f)?;
+            },
         }
     }
 

packages/router/src/components/child_router.rs

@@ -2,7 +2,7 @@
 /// to the child router that maps child routes to root routes and vice versa.
 use dioxus_lib::prelude::*;
 
-use crate::prelude::Routable;
+use crate::Routable;
 
 /// Maps a child route into the root router and vice versa
 // NOTE: Currently child routers only support simple static prefixes, but this

packages/router/src/components/outlet.rs

@@ -1,4 +1,4 @@
-use crate::prelude::{outlet::OutletContext, *};
+use crate::{outlet::OutletContext, *};
 use dioxus_lib::prelude::*;
 
 /// An outlet for the current content.

packages/router/src/components/router.rs

@@ -1,10 +1,6 @@
 use dioxus_lib::prelude::*;
 
-use crate::{
+use crate::{provide_router_context, routable::Routable, router_cfg::RouterConfig, Outlet};
-    prelude::{provide_router_context, Outlet},
-    routable::Routable,
-    router_cfg::RouterConfig,
-};
 
 /// The props for [`Router`].
 #[derive(Props)]
@@ -38,7 +34,7 @@ impl<R: Clone> PartialEq for RouterProps<R> {
 
 /// A component that renders the current route.
 pub fn Router<R: Routable + Clone>(props: RouterProps<R>) -> Element {
-    use crate::prelude::{outlet::OutletContext, RouterContext};
+    use crate::{outlet::OutletContext, RouterContext};
 
     use_hook(|| {
         provide_router_context(RouterContext::new(props.config.call(())));
@@ -46,7 +42,7 @@ pub fn Router<R: Routable + Clone>(props: RouterProps<R>) -> Element {
 
     #[cfg(feature = "streaming")]
     use_after_suspense_resolved(|| {
-        dioxus_fullstack_hooks::prelude::commit_initial_chunk();
+        dioxus_fullstack_hooks::commit_initial_chunk();
     });
 
     use_hook(|| {

packages/router/src/contexts/navigator.rs

@@ -1,4 +1,4 @@
-use crate::prelude::{ExternalNavigationFailure, NavigationTarget, RouterContext};
+use crate::{ExternalNavigationFailure, NavigationTarget, RouterContext};
 
 /// Acquire the navigator without subscribing to updates.
 ///
@@ -9,7 +9,7 @@ use crate::prelude::{ExternalNavigationFailure, NavigationTarget, RouterContext}
 /// Panics if there is no router present.
 pub fn navigator() -> Navigator {
     Navigator(
-        dioxus_lib::prelude::try_consume_context::<RouterContext>()
+        dioxus_lib::core::try_consume_context::<RouterContext>()
             .expect("A router must be present to use navigator"),
     )
 }