Make {watcher} a required dependency for autoreload (#4403)

* Make watcher a required dependency for autoreload

Move {watcher} from Suggests to Imports and use it unconditionally for
autoreload file watching, removing the legacy polling-based fallback.

* Add PR number to NEWS

Author: shikokuchuo

DESCRIPTION

@@ -97,6 +97,7 @@ Imports:
     sourcetools,
     tools,
     utils,
+    watcher (>= 0.2.0),
     withr,
     xtable
 Suggests:
@@ -119,7 +120,6 @@ Suggests:
     shinytest2,
     showtext,
     testthat (>= 3.2.1),
-    watcher,
     yaml
 Config/Needs/check: shinyjs
 Config/roxygen2/version: 8.0.0

NEWS.md

@@ -1,5 +1,7 @@
 # shiny (development version)
 
+* `{watcher}` is now a required dependency and is always used for autoreload file watching, so it no longer needs to be installed separately. The legacy polling-based file watcher has been removed. (#4403)
+
 # shiny 1.14.0
 
 ## New features

R/shiny-options.R

@@ -65,19 +65,18 @@ getShinyOption <- function(name, default = NULL) {
 #'   changes are detected, all connected Shiny sessions are reloaded. This
 #'   allows for fast feedback loops when tweaking Shiny UI.
 #'
-#'   Monitoring for changes is no longer expensive, thanks to the \pkg{watcher}
-#'   package, but this feature is still intended only for development.
+#'   Shiny uses the \pkg{watcher} package to efficiently monitor for changes,
+#'   but this feature is still intended only for development.
 #'
 #'   You can customize the file patterns Shiny will monitor by setting the
 #'   shiny.autoreload.pattern option. For example, to monitor only `ui.R`:
 #'   `options(shiny.autoreload.pattern = glob2rx("ui.R"))`.
 #'
-#'   As mentioned above, Shiny no longer polls watched files for changes.
-#'   Instead, using \pkg{watcher}, Shiny is notified of file changes as they
-#'   occur. These changes are batched together within a customizable latency
-#'   period. You can adjust this period by setting
+#'   Using \pkg{watcher}, Shiny is notified of file changes as they occur
+#'   rather than polling. These changes are batched together within a
+#'   customizable latency period. You can adjust this period by setting
 #'   `options(shiny.autoreload.interval = 2000)` (in milliseconds). This value
-#'   converted to seconds and passed to the `latency` argument of
+#'   is converted to seconds and passed to the `latency` argument of
 #'   [watcher::watcher()]. The default latency is 250ms.}
 #' \item{shiny.deprecation.messages (defaults to `TRUE`)}{This controls whether messages for
 #'   deprecated functions in Shiny will be printed. See

R/shinyapp.R

@@ -289,14 +289,13 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
   )
 }
 
-# Start a reactive observer that continually monitors dir for changes to files
-# that have the extensions: r, htm, html, js, css, png, jpg, jpeg, gif. Case is
-# ignored when checking extensions. If any changes are detected, all connected
-# Shiny sessions are reloaded.
+# Start a {watcher} file watcher that continually monitors dir for changes to
+# files that have the extensions: r, htm, html, js, css, png, jpg, jpeg, gif.
+# Case is ignored when checking extensions. If any changes are detected, all
+# connected Shiny sessions are reloaded.
 #
-# Use options(shiny.autoreload = TRUE) to enable this behavior. Since monitoring
-# for changes is expensive (we are polling for mtimes here, nothing fancy) this
-# feature is intended only for development.
+# Use options(shiny.autoreload = TRUE) to enable this behavior. This feature is
+# intended only for development.
 #
 # You can customize the file patterns Shiny will monitor by setting the
 # shiny.autoreload.pattern option. For example, to monitor only ui.R:
@@ -313,72 +312,30 @@ initAutoReloadMonitor <- function(dir) {
     ".*\\.(r|html?|js|css|png|jpe?g|gif)$"
   )
 
-  
-  if (is_installed("watcher")) {
-    check_for_update <- function(paths) {
-      paths <- grep(
-        filePattern,
-        paths,
-        ignore.case = TRUE,
-        value = TRUE
-      )
-      
-      if (length(paths) == 0) {
-        return()
-      }
-      
-      cachedAutoReloadLastChanged$set()
-      autoReloadCallbacks$invoke()
-    }
-    
-    # [garrick, 2025-02-20] Shiny <= v1.10.0 used `invalidateLater()` with an
-    # autoreload.interval in ms. {watcher} instead uses a latency parameter in
-    # seconds, which serves a similar purpose and that I'm keeping for backcompat.
-    latency <- getOption("shiny.autoreload.interval", 250) / 1000
-    watcher <- watcher::watcher(dir, check_for_update, latency = latency)
-    watcher$start()
-    onStop(watcher$stop)
-  } else {
-    # Fall back to legacy observer behavior
-    if (!is_false(getOption("shiny.autoreload.legacy_warning", TRUE))) {
-      cli::cli_warn(
-        c(
-          "Using legacy autoreload file watching. Please install {.pkg watcher} for a more performant autoreload file watcher.",
-          "i" = "Set {.run options(shiny.autoreload.legacy_warning = FALSE)} to suppress this warning."
-        ),
-        .frequency = "regularly",
-        .frequency_id = "shiny.autoreload.legacy_warning"
-      )
+  check_for_update <- function(paths) {
+    paths <- grep(
+      filePattern,
+      paths,
+      ignore.case = TRUE,
+      value = TRUE
+    )
+
+    if (length(paths) == 0) {
+      return()
     }
 
-    lastValue <- NULL
-    observeLabel <- paste0("File Auto-Reload - '", basename(dir), "'")
-    watcher <- observe(label = observeLabel, {
-      files <- sort_c(
-        list.files(dir, pattern = filePattern, recursive = TRUE, ignore.case = TRUE)
-      )
-      times <- file.info(files)$mtime
-      names(times) <- files
-  
-      if (is.null(lastValue)) {
-        # First run
-        lastValue <<- times
-      } else if (!identical(lastValue, times)) {
-        # We've changed!
-        lastValue <<- times
-        cachedAutoReloadLastChanged$set()
-        autoReloadCallbacks$invoke()
-      }
-  
-      invalidateLater(getOption("shiny.autoreload.interval", 500))
-    })
-  
-    onStop(watcher$destroy)
-  
-    watcher$destroy
+    cachedAutoReloadLastChanged$set()
+    autoReloadCallbacks$invoke()
   }
 
-  invisible(watcher)
+  # [garrick, 2025-02-20] Shiny <= v1.10.0 used `invalidateLater()` with an
+  # autoreload.interval in ms. {watcher} instead uses a latency parameter in
+  # seconds, which serves a similar purpose and that I'm keeping for backcompat.
+  latency <- getOption("shiny.autoreload.interval", 250) / 1000
+  watcher <- watcher::watcher(dir, check_for_update, latency = latency)
+  watcher$start()
+
+  invisible(watcher$stop)
 }
 
 #' Load an app's supporting R files