feat(watch): enable full functional fs watcher in wasm

hyf0 · hyf0 · commit 6c50eacfc910 · 2026-03-07T10:32:06.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -194,8 +194,8 @@ pnp = "0.12.7"
 rayon = "1.10.0"
 regex = "1.11.1"
 regress = "0.10.3"
-rolldown-notify = "10.1.0"
-rolldown-notify-debouncer-full = "0.7.4"
+rolldown-notify = "10.2.0"
+rolldown-notify-debouncer-full = "0.7.5"
 ropey = "1.6.1"
 rustc-hash = { version = "2.1.1" }
 schemars = "1.0.0"
diff --git a/crates/rolldown_fs_watcher/Cargo.toml b/crates/rolldown_fs_watcher/Cargo.toml
@@ -10,10 +10,8 @@ description = "Filesystem watching implementation for Rolldown"
 
 [dependencies]
 rolldown-notify = { workspace = true }
-rolldown_error = { workspace = true }
-
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
 rolldown-notify-debouncer-full = { workspace = true }
+rolldown_error = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/rolldown_fs_watcher/src/lib.rs b/crates/rolldown_fs_watcher/src/lib.rs
@@ -11,19 +11,13 @@ mod paths_mut;
 mod recommended_fs_watcher;
 mod utils;
 
-#[cfg(not(target_family = "wasm"))]
 mod poll_fs_watcher;
-#[cfg(not(target_family = "wasm"))]
 pub use poll_fs_watcher::PollFsWatcher;
 
-#[cfg(not(target_family = "wasm"))]
 mod debounced_poll_fs_watcher;
-#[cfg(not(target_family = "wasm"))]
 pub use debounced_poll_fs_watcher::DebouncedPollFsWatcher;
 
-#[cfg(not(target_family = "wasm"))]
 mod debounced_recommended_fs_watcher;
-#[cfg(not(target_family = "wasm"))]
 pub use debounced_recommended_fs_watcher::DebouncedRecommendedFsWatcher;
 
 pub use crate::{
@@ -48,23 +42,16 @@ pub fn create_fs_watcher<F: FsEventHandler>(
   event_handler: F,
   config: FsWatcherConfig,
 ) -> rolldown_error::BuildResult<DynFsWatcher> {
-  #[cfg(not(target_family = "wasm"))]
-  {
-    match (config.use_polling, config.use_debounce) {
-      (true, false) => Ok(PollFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher()),
-      (true, true) => {
-        Ok(DebouncedPollFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
-      }
-      (false, false) => {
-        Ok(RecommendedFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
-      }
-      (false, true) => {
-        Ok(DebouncedRecommendedFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
-      }
+  match (config.use_polling, config.use_debounce) {
+    (true, false) => Ok(PollFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher()),
+    (true, true) => {
+      Ok(DebouncedPollFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
+    }
+    (false, false) => {
+      Ok(RecommendedFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
+    }
+    (false, true) => {
+      Ok(DebouncedRecommendedFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
     }
-  }
-  #[cfg(target_family = "wasm")]
-  {
-    Ok(RecommendedFsWatcher::with_config(event_handler, config)?.into_dyn_fs_watcher())
   }
 }
diff --git a/crates/rolldown_fs_watcher/src/utils.rs b/crates/rolldown_fs_watcher/src/utils.rs
@@ -1,11 +1,9 @@
 use crate::{FsEventHandler, fs_event::FsEvent};
 use notify::{RecursiveMode, TargetMode, WatchMode};
+use notify_debouncer_full::{DebounceEventHandler, DebounceEventResult};
 use rolldown_error::{BuildResult, ResultExt};
 use std::{path::Path, time::Instant};
 
-#[cfg(not(target_family = "wasm"))]
-pub use non_wasm::*;
-
 pub struct NotifyEventHandlerAdapter<T: FsEventHandler>(pub T);
 
 /// Adapter that wraps notify's PathsMut to implement rolldown's PathsMut trait.
@@ -49,24 +47,17 @@ where
   }
 }
 
-#[cfg(not(target_family = "wasm"))]
-mod non_wasm {
-
-  use crate::{FsEventHandler, fs_event::FsEvent};
-  use notify_debouncer_full::{DebounceEventHandler, DebounceEventResult};
-
-  /// This makes a Rolldown `EventHandler` to be a compatible `DebounceEventHandler`.
-  /// So we could pass a Rolldown `EventHandler` to notify-debouncer-full `Debouncer`.
-  pub struct DebounceEventHandlerAdapter<T: FsEventHandler>(pub T);
+/// This makes a Rolldown `EventHandler` to be a compatible `DebounceEventHandler`.
+/// So we could pass a Rolldown `EventHandler` to notify-debouncer-full `Debouncer`.
+pub struct DebounceEventHandlerAdapter<T: FsEventHandler>(pub T);
 
-  impl<T> DebounceEventHandler for DebounceEventHandlerAdapter<T>
-  where
-    T: FsEventHandler,
-  {
-    fn handle_event(&mut self, event: DebounceEventResult) {
-      self.0.handle_event(event.map(|events| {
-        events.into_iter().map(|event| FsEvent { detail: event.event, time: event.time }).collect()
-      }));
-    }
+impl<T> DebounceEventHandler for DebounceEventHandlerAdapter<T>
+where
+  T: FsEventHandler,
+{
+  fn handle_event(&mut self, event: DebounceEventResult) {
+    self.0.handle_event(event.map(|events| {
+      events.into_iter().map(|event| FsEvent { detail: event.event, time: event.time }).collect()
+    }));
   }
 }
diff --git a/crates/rolldown_watcher/src/watcher.rs b/crates/rolldown_watcher/src/watcher.rs
@@ -9,8 +9,6 @@ use futures::future::Shared;
 use oxc_index::IndexVec;
 use rolldown::BundlerConfig;
 use rolldown_error::BuildResult;
-#[cfg(target_family = "wasm")]
-use rolldown_fs_watcher::FsWatcher;
 use rolldown_fs_watcher::FsWatcherConfig;
 use std::future::Future;
 use std::pin::Pin;
@@ -137,13 +135,8 @@ impl Watcher {
     for (index, config) in configs.into_iter().enumerate() {
       let task_index = WatchTaskIdx::from_usize(index);
       let fs_handler = TaskFsEventHandler { task_index, tx: tx.clone() };
-      #[cfg(not(target_family = "wasm"))]
       let fs_watcher =
         rolldown_fs_watcher::create_fs_watcher(fs_handler, fs_watcher_config.clone())?;
-      #[cfg(target_family = "wasm")]
-      let fs_watcher: Box<dyn FsWatcher + Send + 'static> = Box::new(
-        rolldown_fs_watcher::NoopFsWatcher::with_config(fs_handler, fs_watcher_config.clone())?,
-      );
       let task = WatchTask::new(config, fs_watcher)?;
       tasks.push(task);
     }
