refactor: remove once_cell dependency and use std::sync equivalents

Cargo.toml

@@ -257,7 +257,6 @@ reqwest = "0.12.12"
 owo-colors = "4.2.0"
 ciborium = "0.2.2"
 base64 = "0.22.1"
-once_cell = "1.20.3"
 uuid = "1.15.1"
 convert_case = "0.8.0"
 tungstenite = { version = "0.26.2" }

examples/fullstack-streaming/Cargo.toml

@@ -12,7 +12,6 @@ serde = { workspace = true }
 futures = { workspace = true }
 tokio = { workspace = true, optional = true }
 futures-util.workspace = true
-once_cell = { workspace = true }
 
 [features]
 default = []

packages/cli/Cargo.toml

@@ -71,7 +71,6 @@ dunce = { workspace = true }
 dirs = { workspace = true }
 reqwest = { workspace = true, features = ["rustls-tls", "trust-dns", "json"] }
 tower = { workspace = true }
-once_cell = { workspace = true }
 
 # path lookup
 which = { version = "7.0.2" }

packages/cli/src/build/request.rs

@@ -3322,10 +3322,10 @@ impl BuildRequest {
     ///
     /// It's not guaranteed that they're different from any other folder
     pub(crate) fn prepare_build_dir(&self) -> Result<()> {
-        use once_cell::sync::OnceCell;
         use std::fs::{create_dir_all, remove_dir_all};
+        use std::sync::OnceLock;
 
-        static INITIALIZED: OnceCell<Result<()>> = OnceCell::new();
+        static INITIALIZED: OnceLock<Result<()>> = OnceLock::new();
 
         let success = INITIALIZED.get_or_init(|| {
             if self.platform != Platform::Server {

packages/cli/src/cli/create.rs

@@ -242,14 +242,14 @@ fn remove_triple_newlines(string: &str) -> String {
 // #[cfg(test)]
 // pub(crate) mod tests {
 //     use escargot::{CargoBuild, CargoRun};
-//     use once_cell::sync::Lazy;
+//     use std::sync::LazyLock;
 //     use std::fs::{create_dir_all, read_to_string};
 //     use std::path::{Path, PathBuf};
 //     use std::process::Command;
 //     use tempfile::tempdir;
 //     use toml::Value;
 
-//     static BINARY: Lazy<CargoRun> = Lazy::new(|| {
+//     static BINARY: LazyLock<CargoRun> = LazyLock::new(|| {
 //         CargoBuild::new()
 //             .bin(env!("CARGO_BIN_NAME"))
 //             .current_release()

packages/cli/src/cli/mod.rs

@@ -24,8 +24,8 @@ use crate::{error::Result, Error, StructuredOutput};
 use clap::builder::styling::{AnsiColor, Effects, Style, Styles};
 use clap::{Parser, Subcommand};
 use html_parser::Dom;
-use once_cell::sync::Lazy;
 use serde::Deserialize;
+use std::sync::LazyLock;
 use std::{
     fmt::Display,
     fs::File,
@@ -123,7 +123,7 @@ impl Display for Commands {
     }
 }
 
-pub(crate) static VERSION: Lazy<String> = Lazy::new(|| {
+pub(crate) static VERSION: LazyLock<String> = LazyLock::new(|| {
     format!(
         "{} ({})",
         crate::dx_build_info::PKG_VERSION,

packages/cli/src/cli/serve.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{AddressArguments, BuildArgs, TraceController};
 use futures_util::FutureExt;
-use once_cell::sync::OnceCell;
+use std::sync::OnceLock;
 use std::{backtrace::Backtrace, panic::AssertUnwindSafe};
 
 /// Serve the project
@@ -102,7 +102,7 @@ impl ServeArgs {
             line: u32,
             column: u32,
         }
-        static BACKTRACE: OnceCell<(Backtrace, Option<SavedLocation>)> = OnceCell::new();
+        static BACKTRACE: OnceLock<(Backtrace, Option<SavedLocation>)> = OnceLock::new();
 
         // We *don't* want printing here, since it'll break the tui and log ordering.
         //

packages/cli/src/logging.rs

@@ -18,7 +18,7 @@ use crate::{serve::ServeUpdate, Cli, Commands, Platform as TargetPlatform, Verbo
 use cargo_metadata::diagnostic::{Diagnostic, DiagnosticLevel};
 use clap::Parser;
 use futures_channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
-use once_cell::sync::OnceCell;
+use std::sync::OnceLock;
 use std::{
     collections::HashMap,
     env,
@@ -47,8 +47,8 @@ const LOG_FILE_NAME: &str = "dx.log";
 const DX_SRC_FLAG: &str = "dx_src";
 
 static TUI_ACTIVE: AtomicBool = AtomicBool::new(false);
-static TUI_TX: OnceCell<UnboundedSender<TraceMsg>> = OnceCell::new();
-pub static VERBOSITY: OnceCell<Verbosity> = OnceCell::new();
+static TUI_TX: OnceLock<UnboundedSender<TraceMsg>> = OnceLock::new();
+pub static VERBOSITY: OnceLock<Verbosity> = OnceLock::new();
 
 pub(crate) struct TraceController {
     pub(crate) tui_rx: UnboundedReceiver<TraceMsg>,

packages/cli/src/settings.rs

@@ -1,6 +1,6 @@
 use crate::{Result, TraceSrc};
-use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
+use std::sync::LazyLock;
 use std::{fs, path::PathBuf, sync::Arc};
 use tracing::{error, trace, warn};
 
@@ -33,8 +33,8 @@ pub(crate) struct CliSettings {
 impl CliSettings {
     /// Load the settings from the local, global, or default config in that order
     pub(crate) fn load() -> Arc<Self> {
-        static SETTINGS: Lazy<Arc<CliSettings>> =
-            Lazy::new(|| Arc::new(CliSettings::global_or_default()));
+        static SETTINGS: LazyLock<Arc<CliSettings>> =
+            LazyLock::new(|| Arc::new(CliSettings::global_or_default()));
         SETTINGS.clone()
     }
 

packages/core-types/Cargo.toml

@@ -11,4 +11,3 @@ keywords = ["dom", "ui", "gui", "react", ]
 
 
 [dependencies]
-once_cell = { workspace = true }

packages/core-types/src/bundled.rs

@@ -1,7 +1,7 @@
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 pub fn is_bundled_app() -> bool {
-    static BUNDLED: Lazy<bool> = Lazy::new(|| {
+    static BUNDLED: LazyLock<bool> = LazyLock::new(|| {
         // If the env var is set, we're bundled
         if std::env::var("DIOXUS_CLI_ENABLED").is_ok() {
             return true;

packages/desktop/Cargo.toml

@@ -47,7 +47,6 @@ futures-util = { workspace = true }
 urlencoding = { workspace = true }
 async-trait = { workspace = true }
 tao = { workspace = true, features = ["rwh_05"] }
-once_cell = { workspace = true }
 dioxus-history = { workspace = true }
 base64 = { workspace = true }
 libc = "0.2.170"

packages/desktop/src/android_sync_lock.rs

@@ -2,10 +2,9 @@
 ///
 /// We want to acquire this mutex before doing anything with the virtualdom directly
 pub fn android_runtime_lock() -> std::sync::MutexGuard<'static, ()> {
-    use once_cell::sync::OnceCell;
-    use std::sync::Mutex;
+    use std::sync::{Mutex, OnceLock};
 
-    static RUNTIME_LOCK: OnceCell<Mutex<()>> = OnceCell::new();
+    static RUNTIME_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 
     RUNTIME_LOCK.get_or_init(|| Mutex::new(())).lock().unwrap()
 }

packages/fullstack/Cargo.toml

@@ -41,7 +41,6 @@ dioxus-mobile = { workspace = true, optional = true }
 
 tracing = { workspace = true }
 tracing-futures = { workspace = true, optional = true }
-once_cell = { workspace = true }
 tokio-util = { workspace = true, features = ["rt"], optional = true }
 async-trait = { workspace = true, optional = true }
 

packages/fullstack/src/lib.rs

@@ -4,8 +4,6 @@
 #![deny(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
-pub use once_cell;
-
 #[cfg(all(feature = "web", feature = "document"))]
 mod web;
 

packages/mobile/Cargo.toml

@@ -15,7 +15,6 @@ dioxus-desktop = { workspace = true }
 dioxus-lib = { workspace = true }
 dioxus-cli-config = { workspace = true }
 libc = "0.2.170"
-once_cell = { workspace = true }
 
 [target.'cfg(target_os = "android")'.dependencies]
 jni = "0.21.1"

packages/playwright-tests/wasm-split-harness/Cargo.toml

@@ -15,6 +15,5 @@ js-sys = { workspace = true }
 wasm-bindgen = { workspace = true }
 wasm-bindgen-futures = { workspace = true }
 web-sys = { workspace = true, features = ["Document", "Window", "HtmlElement", "Text", "DomRectReadOnly", "console"] }
-once_cell = { workspace = true }
 getrandom = { workspace = true, features = ["js"] }
 reqwest = { workspace = true, features = ["json"] }

packages/server/Cargo.toml

@@ -39,7 +39,6 @@ dioxus-interpreter-js = { workspace = true, optional = true }
 
 tracing = { workspace = true }
 tracing-futures = { workspace = true }
-once_cell = { workspace = true }
 async-trait = { workspace = true }
 serde = { workspace = true }
 enumset = "1.1.5"
@@ -108,4 +107,3 @@ aws-lc-rs = ["dep:aws-lc-rs"]
 [package.metadata.docs.rs]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 features = ["axum", "web", "aws-lc-rs"]
-

packages/server/src/document.rs

@@ -6,10 +6,10 @@ use std::cell::RefCell;
 
 use dioxus_lib::{document::*, prelude::*};
 use dioxus_ssr::Renderer;
-use once_cell::sync::Lazy;
 use parking_lot::RwLock;
+use std::sync::LazyLock;
 
-static RENDERER: Lazy<RwLock<Renderer>> = Lazy::new(|| RwLock::new(Renderer::new()));
+static RENDERER: LazyLock<RwLock<Renderer>> = LazyLock::new(|| RwLock::new(Renderer::new()));
 
 /// Reset the static renderer to a fresh state, clearing its cache.
 pub(crate) fn reset_renderer() {

packages/server/src/server.rs

@@ -296,7 +296,7 @@ pub(crate) fn add_server_context(
 pub struct RenderHandleState {
     config: ServeConfig,
     build_virtual_dom: Arc<dyn Fn() -> VirtualDom + Send + Sync>,
-    ssr_state: once_cell::sync::OnceCell<SSRState>,
+    ssr_state: std::sync::OnceLock<SSRState>,
 }
 
 impl RenderHandleState {
@@ -329,7 +329,7 @@ impl RenderHandleState {
 
     /// Set the [`SSRState`] for this [`RenderHandleState`]. Sharing a [`SSRState`] between multiple [`RenderHandleState`]s is more efficient than creating a new [`SSRState`] for each [`RenderHandleState`].
     pub fn with_ssr_state(mut self, ssr_state: SSRState) -> Self {
-        self.ssr_state = once_cell::sync::OnceCell::new();
+        self.ssr_state = std::sync::OnceLock::new();
         if self.ssr_state.set(ssr_state).is_err() {
             panic!("SSRState already set");
         }

packages/signals/Cargo.toml

@@ -18,7 +18,6 @@ generational-box = { workspace = true }
 tracing = { workspace = true }
 serde = { workspace = true, features = ["derive"], optional = true }
 parking_lot = { workspace = true}
-once_cell = { workspace = true}
 rustc-hash = { workspace = true }
 futures-channel = { workspace = true }
 futures-util = { workspace = true }

packages/subsecond/subsecond/src/lib.rs

@@ -435,7 +435,11 @@ impl<A, M, F: HotFunction<A, M>> HotFn<A, M, F> {
     /// # Safety
     ///
     /// The [`HotFnPtr`] must be to a function whose arguments layouts haven't changed.
-    pub unsafe fn try_call_with_ptr(&mut self, ptr: HotFnPtr, args: A) -> Result<F::Return, HotFnPanic> {
+    pub unsafe fn try_call_with_ptr(
+        &mut self,
+        ptr: HotFnPtr,
+        args: A,
+    ) -> Result<F::Return, HotFnPanic> {
         if !cfg!(debug_assertions) {
             return Ok(self.inner.call_it(args));
         }