work to port to leptos 0.7

Cargo.toml

@@ -20,16 +20,16 @@ cfg-if = "1"
 cookie = { version = "0.18", features = ["percent-encode"] }
 default-struct-builder = "0.5"
 futures-util = "0.3"
-gloo-timers = { version = "0.3.0", features = ["futures"] }
-gloo-utils = { version = "0.2.0" }
+gloo-timers = { version = "0.3", features = ["futures"] }
+gloo-utils = { version = "0.2" }
 http1 = { version = "1", optional = true, package = "http" }
 http0_2 = { version = "0.2", optional = true, package = "http" }
 js-sys = "0.3"
 lazy_static = "1"
-leptos = "0.6"
-leptos_axum = { version = "0.6", optional = true }
+leptos = "0.7.0-preview2"
+leptos_axum = { version = "0.7.0-preview2", optional = true }
 leptos_actix = { version = "0.6", optional = true }
-leptos-spin = { version = "0.1", optional = true }
+leptos-spin = { version = "0.2", optional = true }
 num = { version = "0.4", optional = true }
 paste = "1"
 prost = { version = "0.12", optional = true }
@@ -133,7 +133,7 @@ features = [
 
 [dev-dependencies]
 getrandom = { version = "0.2", features = ["js"] }
-leptos_meta = "0.6"
+leptos_meta = "0.7.0-preview2"
 rand = "0.8"
 
 [features]

README.md

@@ -20,7 +20,6 @@
 <br/>
 <br/>
 
-
 ## Usage
 
 [![Docs](https://docs.rs/leptos-use/badge.svg)](https://docs.rs/leptos-use/)
@@ -29,7 +28,7 @@
 [![Discord](https://img.shields.io/discord/1031524867910148188?color=%237289DA&label=discord)](https://discord.com/channels/1031524867910148188/1121154537709895783)
 
 ```rust
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::{use_mouse, UseMouseReturn};
 
 #[component]
@@ -82,7 +81,8 @@ python3 post_build.py use_storage
 
 ### New Function Template
 
-To scaffold a new function quickly you can run `template/createfn.sh`. It requires that [`ffizer`](https://ffizer.github.io/) and Python 3 is installed.
+To scaffold a new function quickly you can run `template/createfn.sh`. It requires
+that [`ffizer`](https://ffizer.github.io/) and Python 3 is installed.
 This will create the function file in the src directory, scaffold an example directory and an entry in the book.
 
 ## Leptos compatibility

docs/book/src/element_parameters.md

@@ -35,14 +35,16 @@ pub fn some_directive(el: HtmlElement<AnyElement>) {
 Signal of Strings: `Signal<String>`, `ReadSignal<String>`, `RwSignal<String>`, `Memo<String>`; also works with `&str`:
 
 ```rust
-let (str_signal, set_str_signal) = create_signal("div > p.some-class".to_string());
+let (str_signal, set_str_signal) = signal("div > p.some-class".to_string());
 use_element_size(str_signal);
 ```
 
-Signals of Elements: `Signal<web_sys::Element>`, `ReadSignal<web_sys::Element>`, `RwSignal<web_sys::Element>`, `Memo<web_sys::Element>`; also works with `Option<web_sys::Element>`:
+Signals of
+Elements: `Signal<web_sys::Element>`, `ReadSignal<web_sys::Element>`, `RwSignal<web_sys::Element>`, `Memo<web_sys::Element>`;
+also works with `Option<web_sys::Element>`:
 
 ```rust
-let (el_signal, set_el_signal) = create_signal(document().query_selector("div > p.some-class").unwrap());
+let (el_signal, set_el_signal) = signal(document().query_selector("div > p.some-class").unwrap());
 use_element_size(el_signal); 
 ```
 

docs/book/src/get_started.md

@@ -15,7 +15,7 @@ cargo add leptos-use
 Simply import the functions you need from `leptos-use`
 
 ```rust,noplayground
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::{use_mouse, UseMouseReturn};
 
 #[component]

docs/book/src/server_side_rendering.md

@@ -66,7 +66,7 @@ a new-type-wrapped `Option<web_sys::Window>` or `Option<web_sys::Document>` resp
 used safely on the server. The following code works on both the client and the server:
 
 ```rust
-use leptos::*;
+use leptos::prelude::*;
 use leptos::ev::keyup;
 use leptos_use::{use_event_listener, use_window};
 

examples/on_click_outside/src/main.rs

@@ -1,11 +1,11 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::on_click_outside;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (show_modal, set_show_modal) = create_signal(false);
+    let (show_modal, set_show_modal) = signal(false);
     let modal_ref = create_node_ref::<Div>();
 
     let _ = on_click_outside(modal_ref, move |_| set_show_modal.set(false));

examples/signal_debounced/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::signal_debounced;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (input, set_input) = create_signal("".to_string());
+    let (input, set_input) = signal("".to_string());
     let debounced: Signal<String> = signal_debounced(input, 1000.0);
 
     view! {

examples/signal_throttled/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::signal_throttled;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (input, set_input) = create_signal("".to_string());
+    let (input, set_input) = signal("".to_string());
     let throttled: Signal<String> = signal_throttled(input, 1000.0);
 
     view! {

examples/ssr/src/app.rs

@@ -1,6 +1,6 @@
 use crate::error_template::{AppError, ErrorTemplate};
 use leptos::ev::{keypress, KeyboardEvent};
-use leptos::*;
+use leptos::prelude::*;
 use leptos_meta::*;
 use leptos_router::*;
 use leptos_use::storage::use_local_storage;
@@ -49,14 +49,14 @@ fn HomePage() -> impl IntoView {
 
     let zh_count = nf.format::<i32>(count);
 
-    let (key, set_key) = create_signal("".to_string());
+    let (key, set_key) = signal("".to_string());
 
     // window() doesn't work on the server so we provide use_window()
     let _ = use_event_listener(use_window(), keypress, move |evt: KeyboardEvent| {
         set_key(evt.key())
     });
 
-    let (debounce_value, set_debounce_value) = create_signal("not called");
+    let (debounce_value, set_debounce_value) = signal("not called");
 
     let debounced_fn = use_debounce_fn(
         move || {

examples/ssr/src/error_template.rs

@@ -1,6 +1,6 @@
 use cfg_if::cfg_if;
 use http::status::StatusCode;
-use leptos::*;
+use leptos::prelude::*;
 use thiserror::Error;
 
 #[cfg(feature = "ssr")]

examples/ssr/src/fileserv.rs

@@ -10,7 +10,7 @@ cfg_if! { if #[cfg(feature = "ssr")] {
     use axum::response::Response as AxumResponse;
     use tower::ServiceExt;
     use tower_http::services::ServeDir;
-    use leptos::*;
+    use leptos::prelude::*;
     use crate::app::App;
 
     pub async fn file_and_error_handler(uri: Uri, State(options): State<LeptosOptions>, req: Request<Body>) -> AxumResponse {

examples/ssr/src/lib.rs

@@ -4,7 +4,7 @@ pub mod error_template;
 pub mod fileserv;
 
 cfg_if! { if #[cfg(feature = "hydrate")] {
-    use leptos::*;
+    use leptos::prelude::*;
     use wasm_bindgen::prelude::wasm_bindgen;
     use crate::app::*;
 

examples/ssr/src/main.rs

@@ -3,7 +3,7 @@
 async fn main() {
     use axum::{routing::post, Router};
     use leptos::logging::log;
-    use leptos::*;
+    use leptos::prelude::*;
     use leptos_axum::{generate_route_list, LeptosRoutes};
     use leptos_use_ssr::app::*;
     use leptos_use_ssr::fileserv::file_and_error_handler;

examples/sync_signal/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::sync_signal;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (a, set_a) = create_signal(String::new());
-    let (b, set_b) = create_signal(String::new());
+    let (a, set_a) = signal(String::new());
+    let (b, set_b) = signal(String::new());
 
     let _ = sync_signal((a, set_a), (b, set_b));
 

examples/use_abs/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::math::use_abs;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (value, set_value) = create_signal(-32.25);
+    let (value, set_value) = signal(-32.25);
 
     let result: Signal<f64> = use_abs(value);
 

examples/use_active_element/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::use_active_element;
 

examples/use_and/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::math::use_and;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (a, set_a) = create_signal(false);
-    let (b, set_b) = create_signal(false);
+    let (a, set_a) = signal(false);
+    let (b, set_b) = signal(false);
 
     let a_and_b = use_and(a, b);
 

examples/use_breakpoints/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::{breakpoints_tailwind, use_breakpoints, BreakpointsTailwind};
 

examples/use_broadcast_channel/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::utils::FromToStringCodec;
 use leptos_use::{use_broadcast_channel, UseBroadcastChannelReturn};
@@ -13,7 +13,7 @@ fn Demo() -> impl IntoView {
         ..
     } = use_broadcast_channel::<String, FromToStringCodec>("leptos-use-demo-channel");
 
-    let (input_value, set_input_value) = create_signal(String::new());
+    let (input_value, set_input_value) = signal(String::new());
 
     view! {
         <p>Please open this page in at least two tabs</p>

examples/use_ceil/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::math::use_ceil;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (value, set_value) = create_signal(4.15);
+    let (value, set_value) = signal(4.15);
 
     let result: Signal<f64> = use_ceil(value);
 

examples/use_clipboard/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{use_clipboard, use_permission, UseClipboardReturn};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (input, set_input) = create_signal("".to_owned());
+    let (input, set_input) = signal("".to_owned());
 
     let UseClipboardReturn {
         is_supported,

examples/use_color_mode/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::html;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{
     use_color_mode_with_options, use_cycle_list_with_options, ColorMode, UseColorModeOptions,

examples/use_cookie/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_cookie;
 use leptos_use::utils::FromToStringCodec;

examples/use_css_var/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_css_var_with_options, UseCssVarOptions};
 
@@ -17,7 +17,7 @@ fn Demo() -> impl IntoView {
     };
 
     let elv = create_node_ref::<Div>();
-    let (key, set_key) = create_signal("--color".to_string());
+    let (key, set_key) = signal("--color".to_string());
     let (color_val, _) = use_css_var_with_options(key, UseCssVarOptions::default().target(elv));
     let change_var = move |_| {
         if key.get() == "--color" {

examples/use_cycle_list/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_cycle_list, UseCycleListReturn};
 

examples/use_debounce_fn/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{use_debounce_fn_with_options, DebounceOptions};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (click_count, set_click_count) = create_signal(0);
-    let (debounced_count, set_debounced_count) = create_signal(0);
+    let (click_count, set_click_count) = signal(0);
+    let (debounced_count, set_debounced_count) = signal(0);
 
     let debounced_fn = use_debounce_fn_with_options(
         move || set_debounced_count.set(debounced_count.get_untracked() + 1),

examples/use_device_orientation/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_device_orientation;
 

examples/use_device_pixel_ratio/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_device_pixel_ratio;
 

examples/use_display_media/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_display_media, UseDisplayMediaReturn};
 

examples/use_document_visibility/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_document_visibility;
 use std::time::Duration;
@@ -6,7 +6,7 @@ use std::time::Duration;
 #[component]
 fn Demo() -> impl IntoView {
     let start_message = "💡 Minimize the page or switch tab then return";
-    let (message, set_message) = create_signal(start_message);
+    let (message, set_message) = signal(start_message);
     let visibility = use_document_visibility();
 
     let _ = watch(

examples/use_draggable/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::Position;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_draggable_with_options, use_window, UseDraggableOptions, UseDraggableReturn};

examples/use_drop_zone/src/main.rs

@@ -1,11 +1,11 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::{use_drop_zone_with_options, UseDropZoneOptions, UseDropZoneReturn};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (dropped, set_dropped) = create_signal(false);
+    let (dropped, set_dropped) = signal(false);
 
     let drop_zone_el = create_node_ref::<Div>();
 

examples/use_element_bounding/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Textarea;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{use_element_bounding, UseElementBoundingReturn};
 

examples/use_element_hover/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Button;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_element_hover_with_options, UseElementHoverOptions};
 

examples/use_element_size/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Textarea;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{use_element_size, UseElementSizeReturn};
 

examples/use_element_visibility/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay, Note};
 use leptos_use::use_element_visibility;
 

examples/use_event_listener/src/main.rs

@@ -1,7 +1,7 @@
 use leptos::ev::{click, keydown};
 use leptos::html::A;
 use leptos::logging::log;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::{use_event_listener, use_window};
 
 #[component]
@@ -21,7 +21,7 @@ fn Demo() -> impl IntoView {
         evt.prevent_default();
     });
 
-    let (cond, set_cond) = create_signal(true);
+    let (cond, set_cond) = signal(true);
 
     view! {
         <p>"Check in the dev tools console"</p>

examples/use_favicon/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_favicon_with_options, UseFaviconOptions};
 

examples/use_floor/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::math::use_floor;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (value, set_value) = create_signal(5.95);
+    let (value, set_value) = signal(5.95);
 
     let result: Signal<f64> = use_floor(value);
 

examples/use_geolocation/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_geolocation, UseGeolocationReturn};
 

examples/use_idle/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay, Note};
 use leptos_use::{use_idle, use_timestamp_with_options, UseIdleReturn, UseTimestampOptions};
 

examples/use_infinite_scroll/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_infinite_scroll_with_options, UseInfiniteScrollOptions};
 
@@ -7,7 +7,7 @@ use leptos_use::{use_infinite_scroll_with_options, UseInfiniteScrollOptions};
 fn Demo() -> impl IntoView {
     let el = create_node_ref::<Div>();
 
-    let (data, set_data) = create_signal(vec![1, 2, 3, 4, 5, 6]);
+    let (data, set_data) = signal(vec![1, 2, 3, 4, 5, 6]);
 
     let _ = use_infinite_scroll_with_options(
         el,

examples/use_intersection_observer/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::{
     use_intersection_observer_with_options, UseIntersectionObserverOptions,
@@ -10,7 +10,7 @@ use leptos_use::{
 fn Demo() -> impl IntoView {
     let root = create_node_ref::<Div>();
     let target = create_node_ref::<Div>();
-    let (is_visible, set_visible) = create_signal(false);
+    let (is_visible, set_visible) = signal(false);
 
     let UseIntersectionObserverReturn {
         is_active,

examples/use_interval/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_interval, UseIntervalReturn};
 

examples/use_interval_fn/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_interval_fn;
 use leptos_use::utils::Pausable;
@@ -18,9 +18,9 @@ fn Demo() -> impl IntoView {
         "Привет",
     ];
 
-    let (word, set_word) = create_signal(greetings[0]);
-    let (interval, set_interval) = create_signal(500_u64);
-    let (index, set_index) = create_signal(0);
+    let (word, set_word) = signal(greetings[0]);
+    let (interval, set_interval) = signal(500_u64);
+    let (index, set_index) = signal(0);
 
     let Pausable {
         pause,

examples/use_intl_number_format/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_intl_number_format, NumberStyle, UseIntlNumberFormatOptions};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (number, set_number) = create_signal(123456.78);
+    let (number, set_number) = signal(123456.78);
 
     let de_nf = use_intl_number_format(
         UseIntlNumberFormatOptions::default()

examples/use_media_query/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::use_media_query;
 

examples/use_mouse/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{
     use_mouse, use_mouse_with_options, UseMouseCoordType, UseMouseEventExtractor, UseMouseOptions,

examples/use_mouse_in_element/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_mouse_in_element, UseMouseInElementReturn};
 

examples/use_mutation_observer/src/main.rs

@@ -1,5 +1,5 @@
 use leptos::html::Div;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_mutation_observer_with_options, UseMutationObserverOptions};
 use std::time::Duration;
@@ -7,9 +7,9 @@ use std::time::Duration;
 #[component]
 fn Demo() -> impl IntoView {
     let el = create_node_ref::<Div>();
-    let (messages, set_messages) = create_signal(vec![]);
-    let (class_name, set_class_name) = create_signal(String::new());
-    let (style, set_style) = create_signal(String::new());
+    let (messages, set_messages) = signal(vec![]);
+    let (class_name, set_class_name) = signal(String::new());
+    let (style, set_style) = signal(String::new());
 
     use_mutation_observer_with_options(
         el,

examples/use_not/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::math::use_not;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (a, set_a) = create_signal(false);
+    let (a, set_a) = signal(false);
     let not_a = use_not(a);
 
     view! {

examples/use_or/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::math::use_or;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (a, set_a) = create_signal(false);
-    let (b, set_b) = create_signal(false);
+    let (a, set_a) = signal(false);
+    let (b, set_b) = signal(false);
 
     let a_or_b = use_or(a, b);
 

examples/use_permission/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_permission;
 

examples/use_raf_fn/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_raf_fn, utils::Pausable};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (count, set_count) = create_signal(0);
+    let (count, set_count) = signal(0);
 
     let Pausable {
         pause,

examples/use_resize_observer/src/main.rs

@@ -1,12 +1,12 @@
 use leptos::html::Textarea;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::use_resize_observer;
 
 #[component]
 fn Demo() -> impl IntoView {
     let el = create_node_ref::<Textarea>();
-    let (text, set_text) = create_signal("".to_string());
+    let (text, set_text) = signal("".to_string());
 
     use_resize_observer(el, move |entries, _| {
         let rect = entries[0].content_rect();

examples/use_round/src/main.rs

@@ -1,10 +1,10 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::math::use_round;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (value, set_value) = create_signal(5.95);
+    let (value, set_value) = signal(5.95);
 
     let result: Signal<f64> = use_round(value);
 

examples/use_scroll/src/main.rs

@@ -1,6 +1,6 @@
 use leptos::html::Div;
 use leptos::logging::log;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::{use_scroll_with_options, ScrollBehavior, UseScrollOptions, UseScrollReturn};
 
@@ -9,7 +9,7 @@ use web_sys::Event;
 #[component]
 fn Demo() -> impl IntoView {
     let el = create_node_ref::<Div>();
-    let (smooth, set_smooth) = create_signal(false);
+    let (smooth, set_smooth) = signal(false);
     let behavior = Signal::derive(move || {
         if smooth.get() {
             ScrollBehavior::Smooth

examples/use_service_worker/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::{use_document, use_service_worker, UseServiceWorkerReturn};
 use web_sys::HtmlMetaElement;

examples/use_sorted/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_sorted;
 

examples/use_storage/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::storage::use_local_storage;
 use leptos_use::utils::JsonCodec;

examples/use_throttle_fn/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::use_throttle_fn;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (click_count, set_click_count) = create_signal(0);
-    let (throttled_count, set_throttled_count) = create_signal(0);
+    let (click_count, set_click_count) = signal(0);
+    let (throttled_count, set_throttled_count) = signal(0);
 
     let throttled_fn = use_throttle_fn(
         move || set_throttled_count.set(throttled_count.get_untracked() + 1),

examples/use_timeout_fn/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_timeout_fn, UseTimeoutFnReturn};
 
@@ -6,7 +6,7 @@ use leptos_use::{use_timeout_fn, UseTimeoutFnReturn};
 fn Demo() -> impl IntoView {
     const DEFAULT_TEXT: &str = "Please wait for 3 seconds";
 
-    let (text, set_text) = create_signal(DEFAULT_TEXT.to_string());
+    let (text, set_text) = signal(DEFAULT_TEXT.to_string());
     let UseTimeoutFnReturn {
         start, is_pending, ..
     } = use_timeout_fn(

examples/use_timestamp/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_timestamp;
 

examples/use_web_notification/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, BooleanDisplay};
 use leptos_use::{
     use_web_notification_with_options, NotificationDirection, ShowOptions,

examples/use_websocket/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{
     core::ConnectionReadyState, use_websocket, use_websocket_with_options, UseWebSocketOptions,
@@ -9,7 +9,7 @@ use web_sys::{CloseEvent, Event};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (history, set_history) = create_signal(vec![]);
+    let (history, set_history) = signal(vec![]);
 
     fn update_history(&history: &WriteSignal<Vec<String>>, message: String) {
         let _ = &history.update(|history: &mut Vec<_>| history.push(message));
@@ -68,7 +68,7 @@ fn Demo() -> impl IntoView {
     // use_websocket_with_options
     // ----------------------------
 
-    let (history2, set_history2) = create_signal(vec![]);
+    let (history2, set_history2) = signal(vec![]);
 
     let on_open_callback = move |e: Event| {
         set_history2.update(|history: &mut Vec<_>| {

examples/use_webtransport/src/log_display.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 
 #[component]
 pub fn LogDisplay(#[prop(into)] log: Signal<Vec<String>>) -> impl IntoView {

examples/use_webtransport/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::ConnectionReadyState;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_webtransport_with_options, UseWebTransportOptions};
@@ -13,7 +13,7 @@ use stream_send::*;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (datagrams_log, set_datagrams_log) = create_signal(vec![]);
+    let (datagrams_log, set_datagrams_log) = signal(vec![]);
 
     let id = store_value(0);
 
@@ -28,7 +28,7 @@ fn Demo() -> impl IntoView {
             }),
     );
 
-    let (text, set_text) = create_signal("".to_string());
+    let (text, set_text) = signal("".to_string());
 
     let on_send_datagrams = {
         let transport = transport.clone();
@@ -56,7 +56,7 @@ fn Demo() -> impl IntoView {
         false,
     );
 
-    let (bidir_streams, set_bidir_streams) = create_signal(vec![]);
+    let (bidir_streams, set_bidir_streams) = signal(vec![]);
 
     let on_open_bidir_stream = {
         let transport = transport.clone();

examples/use_webtransport/src/stream_bidir.rs

@@ -1,5 +1,5 @@
 use crate::{LogDisplay, StreamSend};
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::ConnectionReadyState;
 use leptos_use::BidirStream;
 
@@ -8,7 +8,7 @@ pub fn StreamBidir(
     #[prop(into)] ready_state: Signal<ConnectionReadyState>,
     stream: BidirStream,
 ) -> impl IntoView {
-    let (log, set_log) = create_signal(vec![]);
+    let (log, set_log) = signal(vec![]);
 
     let on_send = move |msg| {
         set_log.update(|log| log.push(format!("Sent: '{}'", msg)));

examples/use_webtransport/src/stream_send.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::ConnectionReadyState;
 use leptos_use::SendableStream;
 
@@ -12,7 +12,7 @@ where
     S: SendableStream + 'static,
     F: Fn(String) + 'static,
 {
-    let (text, set_text) = create_signal("".to_string());
+    let (text, set_text) = signal("".to_string());
 
     let on_send = {
         move |_| {

examples/use_webtransport_with_server/client/src/log_display.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 
 #[component]
 pub fn LogDisplay(#[prop(into)] log: Signal<Vec<String>>) -> impl IntoView {

examples/use_webtransport_with_server/client/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::ConnectionReadyState;
 use leptos_use::docs::demo_or_body;
 use leptos_use::{use_webtransport_with_options, UseWebTransportOptions};
@@ -13,8 +13,8 @@ use stream_send::*;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (datagrams_log, set_datagrams_log) = create_signal(vec![]);
-    let (bidir_streams, set_bidir_streams) = create_signal(vec![]);
+    let (datagrams_log, set_datagrams_log) = signal(vec![]);
+    let (bidir_streams, set_bidir_streams) = signal(vec![]);
 
     let id = store_value(0);
 
@@ -37,7 +37,7 @@ fn Demo() -> impl IntoView {
             }),
     );
 
-    let (text, set_text) = create_signal("".to_string());
+    let (text, set_text) = signal("".to_string());
 
     let on_send_datagrams = {
         let transport = transport.clone();

examples/use_webtransport_with_server/client/src/stream_bidir.rs

@@ -1,5 +1,5 @@
 use crate::{LogDisplay, StreamSend};
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::ConnectionReadyState;
 use leptos_use::{BidirStream, CloseableStream, StreamState};
 
@@ -9,7 +9,7 @@ pub fn StreamBidir(
     stream: BidirStream,
     opened_by: &'static str,
 ) -> impl IntoView {
-    let (log, set_log) = create_signal(vec![]);
+    let (log, set_log) = signal(vec![]);
 
     let on_send = move |msg| {
         set_log.update(|log| log.push(format!("Sent: '{}'", msg)));

examples/use_webtransport_with_server/client/src/stream_send.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::core::ConnectionReadyState;
 use leptos_use::{SendableStream, StreamState};
 
@@ -13,7 +13,7 @@ where
     S: SendableStream + 'static,
     F: Fn(String) + 'static,
 {
-    let (text, set_text) = create_signal("".to_string());
+    let (text, set_text) = signal("".to_string());
 
     let on_send = {
         move |_| {

examples/use_window_focus/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::demo_or_body;
 use leptos_use::use_window_focus;
 
@@ -6,7 +6,7 @@ use leptos_use::use_window_focus;
 fn Demo() -> impl IntoView {
     let start_message = "💡 Click somewhere outside of the document to unfocus.";
 
-    let (message, set_message) = create_signal(start_message);
+    let (message, set_message) = signal(start_message);
 
     let focused = use_window_focus();
 

examples/use_window_scroll/src/main.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::use_window_scroll;
 

examples/watch_debounced/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{watch_debounced_with_options, WatchDebouncedOptions};
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (input, set_input) = create_signal("".to_string());
-    let (updated, set_updated) = create_signal(0);
+    let (input, set_input) = signal("".to_string());
+    let (updated, set_updated) = signal(0);
 
     let _ = watch_debounced_with_options(
         move || input.get(),

examples/watch_pausable/src/main.rs

@@ -1,13 +1,13 @@
 use leptos::html::Input;
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::{watch_pausable, WatchPausableReturn};
 
 #[component]
 fn Demo() -> impl IntoView {
     let input = create_node_ref::<Input>();
-    let (log, set_log) = create_signal("".to_string());
-    let (source, set_source) = create_signal("".to_string());
+    let (log, set_log) = signal("".to_string());
+    let (source, set_source) = signal("".to_string());
 
     let WatchPausableReturn {
         pause,

examples/watch_throttled/src/main.rs

@@ -1,11 +1,11 @@
-use leptos::*;
+use leptos::prelude::*;
 use leptos_use::docs::{demo_or_body, Note};
 use leptos_use::watch_throttled;
 
 #[component]
 fn Demo() -> impl IntoView {
-    let (input, set_input) = create_signal("".to_string());
-    let (updated, set_updated) = create_signal(0);
+    let (input, set_input) = signal("".to_string());
+    let (updated, set_updated) = signal(0);
 
     let _ = watch_throttled(
         move || input.get(),

src/core/element_maybe_signal.rs

@@ -1,7 +1,8 @@
 use crate::{UseDocument, UseWindow};
 use cfg_if::cfg_if;
-use leptos::html::ElementDescriptor;
-use leptos::*;
+use leptos::html::HtmlElement;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use std::marker::PhantomData;
 use std::ops::Deref;
 

src/core/elements_maybe_signal.rs

@@ -2,7 +2,8 @@ use crate::core::ElementMaybeSignal;
 use crate::{UseDocument, UseWindow};
 use cfg_if::cfg_if;
 use leptos::html::ElementDescriptor;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use std::marker::PhantomData;
 use std::ops::Deref;
 

src/core/maybe_rw_signal.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 use std::fmt::Debug;
 
 pub enum MaybeRwSignal<T>
@@ -91,7 +91,7 @@ impl<T: Clone> MaybeRwSignal<T> {
     pub fn into_signal(self) -> (Signal<T>, WriteSignal<T>) {
         match self {
             Self::DynamicRead(s) => {
-                let (r, w) = create_signal(s.get_untracked());
+                let (r, w) = signal(s.get_untracked());
 
                 create_effect(move |_| {
                     w.update(move |w| {
@@ -103,7 +103,7 @@ impl<T: Clone> MaybeRwSignal<T> {
             }
             Self::DynamicRw(r, w) => (r, w),
             Self::Static(v) => {
-                let (r, w) = create_signal(v.clone());
+                let (r, w) = signal(v.clone());
                 (Signal::from(r), w)
             }
         }

src/core/storage.rs

@@ -1,4 +1,4 @@
-use leptos::window;
+use leptos::prelude::*;
 use wasm_bindgen::JsValue;
 
 /// Local or session storage or a custom store that is a `web_sys::Storage`.

src/core/url.rs

@@ -1,4 +1,4 @@
-use leptos::window;
+use leptos::prelude::*;
 
 #[cfg_attr(feature = "ssr", allow(dead_code))]
 fn get() -> web_sys::Url {

src/core/use_rw_signal.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 
 pub enum UseRwSignal<T: 'static> {
     Separate(Signal<T>, WriteSignal<T>),

src/docs/boolean_display.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 
 #[component]
 pub fn BooleanDisplay(

src/docs/demo.rs

@@ -1,4 +1,4 @@
-use leptos::document;
+use leptos::prelude::*;
 use wasm_bindgen::JsCast;
 
 pub fn demo_or_body() -> web_sys::HtmlElement {

src/docs/note.rs

@@ -1,4 +1,4 @@
-use leptos::*;
+use leptos::prelude::*;
 
 #[component]
 pub fn Note(#[prop(optional, into)] class: String, children: Children) -> impl IntoView {

src/is_err.rs

@@ -1,5 +1,6 @@
 use crate::utils::use_derive_signal;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 
 use_derive_signal!(
     /// Reactive `Result::is_err()`.
@@ -7,12 +8,12 @@ use_derive_signal!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::is_err;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (example, set_example) = create_signal(
+    /// let (example, set_example) = signal(
     ///     if js_sys::Math::random() < 0.5 { Ok("Example") } else { Err(()) }
     /// );
     ///

src/is_none.rs

@@ -1,5 +1,6 @@
 use crate::utils::use_derive_signal;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 
 use_derive_signal!(
     /// Reactive `Option::is_none()`.
@@ -7,12 +8,12 @@ use_derive_signal!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::is_none;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (example, set_example) = create_signal(
+    /// let (example, set_example) = signal(
     ///     if js_sys::Math::random() < 0.5 { Some("Example") } else { None }
     /// );
     ///

src/is_ok.rs

@@ -1,5 +1,5 @@
 use crate::utils::use_derive_signal;
-use leptos::*;
+use leptos::prelude::*;
 
 use_derive_signal!(
     /// Reactive `Result::is_ok()`.
@@ -7,12 +7,12 @@ use_derive_signal!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::is_ok;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (example, set_example) = create_signal(
+    /// let (example, set_example) = signal(
     ///     if js_sys::Math::random() < 0.5 { Ok("Example") } else { Err(()) }
     /// );
     ///

src/is_some.rs

@@ -1,5 +1,6 @@
 use crate::utils::use_derive_signal;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 
 use_derive_signal!(
     /// Reactive `Option::is_some()`.
@@ -7,12 +8,12 @@ use_derive_signal!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::is_some;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (example, set_example) = create_signal(
+    /// let (example, set_example) = signal(
     ///     if js_sys::Math::random() < 0.5 { Some("Example") } else { None }
     /// );
     ///

src/math/use_abs.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_simple_math;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use num::Float;
 use paste::paste;
 
@@ -13,12 +14,12 @@ use_simple_math!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_abs;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (value, set_value) = create_signal(-32.25);
+    /// let (value, set_value) = signal(-32.25);
     /// let result: Signal<f64> = use_abs(value); // 32.25
     /// #
     /// # assert_eq!(result.get(), 32.25);

src/math/use_and.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_binary_logic;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use paste::paste;
 
 use_binary_logic!(
@@ -12,13 +13,13 @@ use_binary_logic!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_and;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (a, set_a) = create_signal(true);
-    /// let (b, set_b) = create_signal(false);
+    /// let (a, set_a) = signal(true);
+    /// let (b, set_b) = signal(false);
     ///
     /// let a_and_b = use_and(a, b);
     /// #

src/math/use_ceil.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_simple_math;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use num::Float;
 use paste::paste;
 
@@ -13,12 +14,12 @@ use_simple_math!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_ceil;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (value, set_value) = create_signal(44.15);
+    /// let (value, set_value) = signal(44.15);
     /// let result: Signal<f64> = use_ceil(value); // 45
     /// #
     /// # assert_eq!(result.get(), 45.0);

src/math/use_floor.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_simple_math;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use num::Float;
 use paste::paste;
 
@@ -13,12 +14,12 @@ use_simple_math!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_floor;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (value, set_value) = create_signal(45.95);
+    /// let (value, set_value) = signal(45.95);
     /// let result: Signal<f64> = use_floor(value); // 45
     /// #
     /// # assert_eq!(result.get(), 45.0);

src/math/use_max.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_partial_cmp;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use std::cmp::Ordering;
 
 use_partial_cmp!(
@@ -14,12 +15,12 @@ use_partial_cmp!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_max;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (values, set_values) = create_signal(vec![1.0, 2.0, 3.0, f32::NAN, 4.0, 5.0]);
+    /// let (values, set_values) = signal(vec![1.0, 2.0, 3.0, f32::NAN, 4.0, 5.0]);
     /// let result = use_max::<Vec<f32>, _, _>(values); // Some(5.0)
     /// #
     /// # assert_eq!(result.get(), Some(5.0));

src/math/use_min.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_partial_cmp;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use std::cmp::Ordering;
 
 use_partial_cmp!(
@@ -14,12 +15,12 @@ use_partial_cmp!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_min;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (values, set_values) = create_signal(vec![1.0, 2.0, 3.0, f32::NAN, 4.0, 5.0]);
+    /// let (values, set_values) = signal(vec![1.0, 2.0, 3.0, f32::NAN, 4.0, 5.0]);
     /// let result = use_min::<Vec<f32>, _, _>(values); // Some(1.0)
     /// #
     /// # assert_eq!(result.get(), Some(1.0));

src/math/use_not.rs

@@ -1,4 +1,5 @@
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 
 /// Reactive `NOT` condition.
 ///
@@ -9,12 +10,12 @@ use leptos::*;
 /// ## Usage
 ///
 /// ```
-/// # use leptos::*;
+/// # use leptos::prelude::*;
 /// # use leptos_use::math::use_not;
 /// #
 /// # #[component]
 /// # fn Demo() -> impl IntoView {
-/// let (a, set_a) = create_signal(true);
+/// let (a, set_a) = signal(true);
 ///
 /// let not_a = use_not(a);
 /// #

src/math/use_or.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_binary_logic;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use paste::paste;
 
 use_binary_logic!(
@@ -12,13 +13,13 @@ use_binary_logic!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_or;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (a, set_a) = create_signal(true);
-    /// let (b, set_b) = create_signal(false);
+    /// let (a, set_a) = signal(true);
+    /// let (b, set_b) = signal(false);
     ///
     /// let a_or_b = use_or(a, b);
     /// #

src/math/use_round.rs

@@ -1,5 +1,6 @@
 use crate::math::shared::use_simple_math;
-use leptos::*;
+use leptos::prelude::wrappers::read::Signal;
+use leptos::prelude::*;
 use num::Float;
 use paste::paste;
 
@@ -13,12 +14,12 @@ use_simple_math!(
     /// ## Usage
     ///
     /// ```
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # use leptos_use::math::use_round;
     /// #
     /// # #[component]
     /// # fn Demo() -> impl IntoView {
-    /// let (value, set_value) = create_signal(45.95);
+    /// let (value, set_value) = signal(45.95);
     /// let result: Signal<f64> = use_round(value); // 46
     /// #
     /// # assert_eq!(result.get(), 46.0);