Port most everything to bslib

* feat: Fully reload ui/server when autoreload occurs

* chore: remove stray empty line

* chore: clean up function names and add comments

* docs: Add news item

* feat: Use {watcher} for autoreload file watching (#4185)

* feat: Use {watcher}

* chore: shikokuchuo/watcher@dev

* chore: watcher is on CRAN now

* chore: Undo air format changes

* feat: Use `shiny.autoreload.interval` for watcher latency

* chore: Simply track last time auto-reload changed

* docs: rewrite options docs for clarity

* chore: code style

* docs: global.R changes are not applied

* feat(ui/server): Autoreload also reloads global and R support files

* chore: remove outdated comment

* chore: safer comparisons

* chore: Restore legacy autoreload watcher if {watcher} not installed

* rename: autoload_r_support_if_needed()

* chore: use `rlang::is_false()`

* chore: use_build_ignore("_dev")

.Rbuildignore

@@ -26,7 +26,6 @@
 ^\.vscode$
 ^\.madgerc$
 ^\.prettierrc\.yml$
-^babel\.config\.json$
 ^jest\.config\.js$
 ^package\.json$
 ^tsconfig\.json$
@@ -37,3 +36,4 @@
 ^\.browserslistrc$
 ^\.eslintrc\.yml$
 ^\.yarnrc\.yml$
+^_dev$

.eslintrc.yml

@@ -35,10 +35,6 @@ rules:
 
   default-case:
     - error
-  indent:
-    - error
-    - 2
-    - SwitchCase: 1
   linebreak-style:
     - error
     - unix

.github/ISSUE_TEMPLATE/question.md

@@ -1,7 +1,7 @@
 ---
 name  : Ask a Question
-about : The issue tracker is not for questions -- please ask questions at https://community.rstudio.com/c/shiny.
+about : The issue tracker is not for questions -- please ask questions at https://forum.posit.co/tags/shiny.
 ---
 
-The issue tracker is not for questions. If you have a question, please feel free to ask it on our community site, at https://community.rstudio.com/c/shiny.
+The issue tracker is not for questions. If you have a question, please feel free to ask it on our community site, at https://forum.posit.co/c/shiny.
 

.vscode/extensions.json

@@ -1,6 +1,5 @@
 {
   "recommendations": [
-    "arcanis.vscode-zipfs",
     "dbaeumer.vscode-eslint",
     "esbenp.prettier-vscode"
   ]

DESCRIPTION

@@ -1,7 +1,7 @@
 Package: shiny
 Type: Package
 Title: Web Application Framework for R
-Version: 1.8.1.9001
+Version: 1.10.0.9001
 Authors@R: c(
     person("Winston", "Chang", role = c("aut", "cre"), email = "winston@posit.co", comment = c(ORCID = "0000-0002-1576-2126")),
     person("Joe", "Cheng", role = "aut", email = "joe@posit.co"),
@@ -83,22 +83,23 @@ Imports:
     R6 (>= 2.0),
     sourcetools,
     later (>= 1.0.0),
-    promises (>= 1.1.0),
+    promises (>= 1.3.2),
     tools,
-    crayon,
+    cli,
     rlang (>= 0.4.10),
     fastmap (>= 1.1.1),
     withr,
     commonmark (>= 1.7),
     glue (>= 1.3.2),
-    bslib (>= 0.3.0),
-    cachem,
+    bslib (>= 0.6.0),
+    cachem (>= 1.1.0),
     lifecycle (>= 0.2.0)
 Suggests:
+    coro (>= 1.1.0),
     datasets,
     DT,
     Cairo (>= 1.5-5),
-    testthat (>= 3.0.0),
+    testthat (>= 3.2.1),
     knitr (>= 1.6),
     markdown,
     rmarkdown,
@@ -110,7 +111,8 @@ Suggests:
     dygraphs,
     ragg,
     showtext,
-    sass
+    sass,
+    watcher 
 URL: https://shiny.posit.co/,
     https://github.com/rstudio/shiny
 BugReports: https://github.com/rstudio/shiny/issues
@@ -206,10 +208,9 @@ Collate:
     'version_selectize.R'
     'version_strftime.R'
     'viewer.R'
-RoxygenNote: 7.3.1
+RoxygenNote: 7.3.2
 Encoding: UTF-8
 Roxygen: list(markdown = TRUE)
-RdMacros: lifecycle
 Config/testthat/edition: 3
 Config/Needs/check:
   shinytest2

NAMESPACE

@@ -216,6 +216,7 @@ export(reactiveVal)
 export(reactiveValues)
 export(reactiveValuesToList)
 export(reactlog)
+export(reactlogAddMark)
 export(reactlogReset)
 export(reactlogShow)
 export(registerInputHandler)

NEWS.md

@@ -1,16 +1,108 @@
 # shiny (development version)
 
+## New features
+
+* `textInput()`, `textAreaInput()`, `numericInput()` and `passwordInput()` all gain an `updateOn` option. `updateOn = "change"` is the default and previous behavior, where the input value updates immediately whenever the value changes. With `updateOn = "blur"`, the input value will update only when the text input loses focus or when the user presses Enter (or Cmd/Ctrl + Enter for `textAreaInput()`). (#4183)
+
+* `textAreaInput()` gains a `autoresize` option, which automatically resizes the text area to fit its content.
+
+* The `callback` argument of Shiny.js' `InputBinding.subscribe()` method gains support for a value of `"event"`. This makes it possible for an input binding to use event priority when updating the value (i.e., send immediately and always resend, even if the value hasn't changed).
+
+## Changes
+
+* Shiny no longer suspends input changes when _any_ `<input type="submit">` or `<button type="submit">` is on the page. Instead, it now only suspends when a `submitButton()` is present. If you have reason for creating a submit button from custom HTML, add a CSS class of `shiny-submit-button` to the button.
+
+## Improvements
+
+* When auto-reload is enabled, Shiny now reloads the entire app when support files, like Shiny modules, additional script files, or web assets, change. To enable auto-reload, call `devmode(TRUE)` to enable Shiny's developer mode, or set `options(shiny.autoreload = TRUE)` to specifically enable auto-reload. You can choose which files are watched for changes with the `shiny.autoreload.pattern` option. (#4184)
+
+* When busy indicators are enabled (i.e., `useBusyIndicators()`), Shiny now:
+    * Shows a spinner on recalculating htmlwidgets that have previously rendered an error (including `req()` and `validate()`). (#4172)
+    * Shows a spinner on `tableOutput()`. (#4172)
+    * Places a minimum height on recalculating outputs so that the spinner is always visible. (#4172)
+
+* Shiny now uses `{cli}` instead of `{crayon}` for rich log messages. (@olivroy #4170)
+
+* Shiny's Typescript assets are now compiled to ES2021 instead of ES5. (#4066)
+
+## Bug fixes
+
+* Fixed a bug with modals where calling `removeModal()` too quickly after `showModal()` would fail to remove the modal if the remove modal message was received while the modal was in the process of being revealed. (#4173)
+
+* The Shiny Client Console (enabled with `shiny::devmode()`) no longer displays duplicate warning or error message. (#4177)
+
+* Updated the JavaScript used when inserting a tab to avoid rendering dynamic UI elements twice when adding the new tab via `insertTab()` or `bslib::nav_insert()`. (#4179)
+
+# shiny 1.10.0
+
 ## New features and improvements
 
-* Added new functions, `useBusyIndicators()` and `busyIndicatorOptions()`, for enabling and customizing busy indication. Busy indicators provide a visual cue to users when the server is busy calculating outputs or otherwise serving requests to the client. When enabled, a spinner is shown on each calculating/recalculating output, and a pulsing banner is shown at the top of the page when the app is otherwise busy. (#4040)
+* When busy indicators are enabled (i.e., `useBusyIndicators()` is in the UI), Shiny now:
+    * Shows the pulse indicator when dynamic UI elements are recalculating and no other spinners are visible in the app. (#4137)
+    * Makes the pulse indicator slightly smaller by default and improves its appearance to better blend with any background. (#4122)
+
+* Improve collection of deep stack traces (stack traces that are tracked across steps in an async promise chain) with `{coro}` async generators such as `{elmer}` chat streams. Previously, Shiny treated each iteration of an async generator as a distinct deep stack, leading to pathologically long stack traces; now, Shiny only keeps/prints unique deep stack trace, discarding duplicates. (#4156)
+
+* Added an example to the `ExtendedTask` documentation. (@daattali #4087)
+
+## Bug fixes
+
+* Fixed a bug in `conditionalPanel()` that would cause the panel to repeatedly show/hide itself when the provided condition was not boolean. (@kamilzyla, #4127)
+
+* Fixed a bug with `sliderInput()` when used as a range slider that made it impossible to change the slider value when both handles were at the maximum value. (#4131)
+
+* `dateInput()` and `dateRangeInput()` no longer send immediate updates to the server when the user is typing a date input. Instead, it waits until the user presses Enter or clicks out of the field to send the update, avoiding spurious and incorrect date values. Note that an update is still sent immediately when the field is cleared. (#3664)
+
+* Fixed a bug in `onBookmark()` hook that caused elements to not be excluded from URL bookmarking. (#3762)
+
+* Fixed a bug with stack trace capturing that caused reactives with very long async promise chains (hundreds/thousands of steps) to become extremely slow. Chains this long are unlikely to be written by hand, but `{coro}` async generators and `{elmer}` async streaming were easily creating problematically long chains. (#4155)
+
+* Duplicate input and output IDs -- e.g. using `"debug"` for two inputs or two outputs -- or shared IDs -- e.g. using `"debug"` as the `inputId` for an input and an output -- now result in a console warning message, but not an error. When `devmode()` is enabled, an informative message is shown in the Shiny Client Console. We recommend all Shiny devs enable `devmode()` when developing Shiny apps locally. (#4101)
+
+* Updating the choices of a `selectizeInput()` via `updateSelectizeInput()` with `server = TRUE` no longer retains the selected choice as a deselected option if the current value is not part of the new choices. (@dvg-p4 #4142)
+
+* Fixed a bug where stack traces from `observeEvent()` were being stripped of stack frames too aggressively. (#4163)
+
+# shiny 1.9.1
+
+## Bug fixes
+
+* Fixed a bug introduced in v1.9.0 where the boundaries of hover/click/brush regions on plots were being incorrectly scaled when browser zoom was used. (#4111)
+
+# shiny 1.9.0
+
+## New busy indication feature
+
+Add the new `useBusyIndicators()` function to any UI definition to:
+  1. Add a spinner overlay on calculating/recalculating outputs.
+  2. Show a page-level pulsing banner when Shiny is busy calculating something (e.g., a download, side-effect, etc), but no calculating/recalculating outputs are visible.
+
+In a future version of Shiny, busy indication will be enabled by default, so we encourage you to try it out now, provide feedback, and report any issues.
+
+In addition, various properties of the spinners and pulse can be customized with `busyIndicatorOptions()`. For more details, see `?busyIndicatorOptions`. (#4040, #4104)
+
+## New features and improvements
+
+* The client-side TypeScript code for Shiny has been refactored so that the `Shiny` object is now an instance of class `ShinyClass`. (#4063)
+
+* In TypeScript, the `Shiny` object has a new property `initializedPromise`, which is a Promise-like object that can be `await`ed or chained with `.then()`. This Promise-like object corresponds to the `shiny:sessioninitialized` JavaScript event, but is easier to use because it can be used both before and after the events have occurred. (#4063)
+
 * Output bindings now include the `.recalculating` CSS class when they are first bound, up until the first render. This makes it possible/easier to show progress indication when the output is calculating for the first time. (#4039)
 
+* A new `shiny.client_devmode` option controls client-side devmode features, in particular the client-side error console introduced in shiny 1.8.1, independently of the R-side features of `shiny::devmode()`. This usage is primarily intended for automatic use in Shinylive. (#4073)
+
+* Added function `reactlogAddMark()` to programmatically add _mark_ed locations in the reactlog log without the requirement of keyboard bindings during an idle reactive moment. (#4103)
+
 ## Bug fixes
 
 * `downloadButton()` and `downloadLink()` are now disabled up until they are fully initialized. This prevents the user from clicking the button/link before the download is ready. (#4041)
+
 * Output bindings that are removed, invalidated, then inserted again (while invalidated) now correctly include the `.recalculating` CSS class. (#4039)
+
 * Fixed a recent issue with `uiOutput()` and `conditionalPanel()` not properly lower opacity when recalculation (in a Bootstrap 5 context). (#4027)
 
+* Image outputs that were scaled by CSS had certain regions that were unresponsive to hover/click/brush handlers. (#3234)
+
 # shiny 1.8.1.1
 
 * In v1.8.1, shiny.js starting throwing an error when input/output bindings have duplicate IDs. This error is now only thrown when `shiny::devmode(TRUE)` is enabled, so the issue is still made discoverable through the JS error console, but avoids unnecessarily breaking apps that happen to work with duplicate IDs. (#4019)
@@ -23,7 +115,7 @@
 
 * Added a JavaScript error dialog, reporting errors that previously were only discoverable by opening the browser's devtools open. Since this dialog is mainly useful for debugging and development, it must be enabled with `shiny::devmode()`. (#3931)
 
-* `runExamples()` now uses the `{bslib}` package to generate a better looking result. It also gains a `package` argument so that other packages can leverage this same function to run Shiny app examples. For more, see `?runExamples`. (#3963, #4005)
+* `runExample()` now uses the `{bslib}` package to generate a better looking result. It also gains a `package` argument so that other packages can leverage this same function to run Shiny app examples. For more, see `?runExample`. (#3963, #4005)
 
 * Added `onUnhandledError()` to register a function that will be called when an unhandled error occurs in a Shiny app. Note that this handler doesn't stop the error or prevent the session from closing, but it can be used to log the error or to clean up session-specific resources. (thanks @JohnCoene, #3993)
 
@@ -993,7 +1085,7 @@ Shiny can now display notifications on the client browser by using the `showNoti
 <img src="http://shiny.rstudio.com/images/notification.png" alt="notification" width="50%"/>
 </p>
 
-[Here](https://shiny.rstudio.com/articles/notifications.html)'s our article about it, and the [reference documentation](https://shiny.rstudio.com/reference/shiny/latest/showNotification.html).
+[Here](https://shiny.rstudio.com/articles/notifications.html)'s our article about it, and the [reference documentation](https://shiny.posit.co/r/reference/shiny/latest/shownotification.html).
 
 ## Progress indicators
 
@@ -1002,7 +1094,7 @@ If your Shiny app contains computations that take a long time to complete, a pro
 **_Important note_:**
 > If you were already using progress bars and had customized them with your own CSS, you can add the `style = "old"` argument to your `withProgress()` call (or `Progress$new()`). This will result in the same appearance as before. You can also call `shinyOptions(progress.style = "old")` in your app's server function to make all progress indicators use the old styling.
 
-To see new progress bars in action, see [this app](https://gallery.shinyapps.io/085-progress/) in the gallery. You can also learn more about this in [our article](https://shiny.rstudio.com/articles/progress.html) and in the reference documentation (either for the easier [`withProgress` functional API](https://shiny.rstudio.com/reference/shiny/latest/withProgress.html) or the more complicated, but more powerful, [`Progress` object-oriented API](https://shiny.rstudio.com/reference/shiny/latest/Progress.html).
+To see new progress bars in action, see [this app](https://gallery.shinyapps.io/085-progress/) in the gallery. You can also learn more about this in [our article](https://shiny.rstudio.com/articles/progress.html) and in the reference documentation (either for the easier [`withProgress` functional API](https://shiny.posit.co/r/reference/shiny/latest/withprogress.html) or the more complicated, but more powerful, [`Progress` object-oriented API](https://shiny.posit.co/r/reference/shiny/latest/progress.html).
 
 ## Reconnection
 
@@ -1016,7 +1108,7 @@ Shiny has now built-in support for displaying modal dialogs like the one below (
 <img src="http://shiny.rstudio.com/images/modal-dialog.png" alt="modal-dialog" width="50%"/>
 </p>
 
-To learn more about this, read [our article](https://shiny.rstudio.com/articles/modal-dialogs.html) and the [reference documentation](https://shiny.rstudio.com/reference/shiny/latest/modalDialog.html).
+To learn more about this, read [our article](https://shiny.rstudio.com/articles/modal-dialogs.html) and the [reference documentation](https://shiny.posit.co/r/reference/shiny/latest/modaldialog.html).
 
 ## `insertUI` and `removeUI`
 
@@ -1024,7 +1116,7 @@ Sometimes in a Shiny app, arbitrary HTML UI may need to be created on-the-fly in
 
 See [this simple demo app](https://gallery.shinyapps.io/111-insert-ui/) of how one could use `insertUI` and `removeUI` to insert and remove text elements using a queue. Also see [this other app](https://gallery.shinyapps.io/insertUI/) that demonstrates how to insert and remove a few common Shiny input objects. Finally, [this app](https://gallery.shinyapps.io/insertUI-modules/) shows how to dynamically insert modules using `insertUI`.
 
-For more, read [our article](https://shiny.rstudio.com/articles/dynamic-ui.html) about dynamic UI generation and the reference documentation about [`insertUI`](https://shiny.rstudio.com/reference/shiny/latest/insertUI.html) and [`removeUI`](https://shiny.rstudio.com/reference/shiny/latest/insertUI.html).
+For more, read [our article](https://shiny.rstudio.com/articles/dynamic-ui.html) about dynamic UI generation and the reference documentation about [`insertUI`](https://shiny.posit.co/r/reference/shiny/latest/insertui.html) and [`removeUI`](https://shiny.posit.co/r/reference/shiny/latest/insertui.html).
 
 ## Documentation for connecting to an external database
 
@@ -1058,7 +1150,7 @@ There are many more minor features, small improvements, and bug fixes than we ca
       <img src="http://shiny.rstudio.com/images/render-table.png" alt="render-table" width="75%"/>
       </p>
 
-      For more, read our [short article](https://shiny.rstudio.com/articles/render-table.html) about this update, experiment with all the new features in this [demo app](https://gallery.shinyapps.io/109-render-table/), or check out the [reference documentation](https://shiny.rstudio.com/reference/shiny/latest/renderTable.html).
+      For more, read our [short article](https://shiny.rstudio.com/articles/render-table.html) about this update, experiment with all the new features in this [demo app](https://gallery.shinyapps.io/109-render-table/), or check out the [reference documentation](https://shiny.posit.co/r/reference/shiny/latest/rendertable.html).
 
 ## Full changelog
 

R/bind-cache.R

@@ -177,7 +177,7 @@ utils::globalVariables(".GenericCallEnv", add = TRUE)
 #'   cache by putting this at the top of your app.R, server.R, or global.R:
 #'
 #'   ```
-#'   shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache"))
+#'   shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache")))
 #'   ```
 #'
 #'   This will create a subdirectory in your system temp directory named

R/bookmark-state.R

@@ -99,13 +99,13 @@ saveShinySaveState <- function(state) {
 
 # Encode the state to a URL. This does not save to disk.
 encodeShinySaveState <- function(state) {
-  exclude <- c(state$exclude, "._bookmark_")
-  inputVals <- serializeReactiveValues(state$input, exclude, stateDir = NULL)
-
   # Allow user-supplied onSave function to do things like add state$values.
   if (!is.null(state$onSave))
     isolate(state$onSave(state))
 
+  exclude <- c(state$exclude, "._bookmark_")
+  inputVals <- serializeReactiveValues(state$input, exclude, stateDir = NULL)
+
   inputVals <- vapply(inputVals,
     function(x) toJSON(x, strict_atomic = FALSE),
     character(1),

R/bootstrap.R

@@ -172,9 +172,10 @@ setCurrentTheme <- function(theme) {
 
 #' Register a theme dependency
 #'
-#' This function registers a function that returns an [htmlDependency()] or list
-#' of such objects. If `session$setCurrentTheme()` is called, the function will
-#' be re-executed, and the resulting html dependency will be sent to the client.
+#' This function registers a function that returns an
+#' [htmltools::htmlDependency()] or list of such objects. If
+#' `session$setCurrentTheme()` is called, the function will be re-executed, and
+#' the resulting html dependency will be sent to the client.
 #'
 #' Note that `func` should **not** be an anonymous function, or a function which
 #' is defined within the calling function. This is so that,
@@ -1112,7 +1113,7 @@ plotOutput <- function(outputId, width = "100%", height="400px",
 #' @rdname renderTable
 #' @export
 tableOutput <- function(outputId) {
-  div(id = outputId, class="shiny-html-output")
+  div(id = outputId, class="shiny-html-output shiny-table-output")
 }
 
 dataTableDependency <- list(

R/busy-indicators.R

@@ -19,6 +19,8 @@
 #'   output.
 #' @param pulse Whether to show a pulsing banner at the top of the page when the
 #'   app is busy.
+#' @param fade Whether to fade recalculating outputs. A value of `FALSE` is
+#'   equivalent to `busyIndicatorOptions(fade_opacity=1)`.
 #'
 #' @export
 #' @seealso [busyIndicatorOptions()] for customizing the appearance of the busy
@@ -48,7 +50,7 @@
 #' }
 #'
 #' shinyApp(ui, server)
-useBusyIndicators <- function(..., spinners = TRUE, pulse = TRUE) {
+useBusyIndicators <- function(..., spinners = TRUE, pulse = TRUE, fade = TRUE) {
 
   rlang::check_dots_empty()
 
@@ -62,20 +64,33 @@ useBusyIndicators <- function(..., spinners = TRUE, pulse = TRUE) {
     }
   })
 
-  js <- HTML(paste(js, collapse = "\n"))
-
   # TODO: it'd be nice if htmltools had something like a page_attrs() that allowed us
   # to do this without needing to inject JS into the head.
-  tags$script(js)
+  res <- tags$script(HTML(paste(js, collapse = "\n")))
+
+  if (!fade) {
+    res <- tagList(res, fadeOptions(opacity = 1))
+  }
+
+  res
 }
 
 #' Customize busy indicator options
 #'
-#' When busy indicators are enabled (see [useBusyIndicators()]), a spinner is
-#' shown on each calculating/recalculating output, and a pulsing banner is shown
-#' at the top of the page when the app is otherwise busy. This function allows
-#' you to customize the appearance of those busy indicators. To apply the
-#' customization, include the result of this function inside the app's UI.
+#' @description
+#' Shiny automatically includes busy indicators, which more specifically means:
+#'   1. Calculating/recalculating outputs have a spinner overlay.
+#'   2. Outputs fade out/in when recalculating.
+#'   3. When no outputs are calculating/recalculating, but Shiny is busy
+#'     doing something else (e.g., a download, side-effect, etc), a page-level
+#'     pulsing banner is shown.
+#'
+#' This function allows you to customize the appearance of these busy indicators
+#' by including the result of this function inside the app's UI. Note that,
+#' unless `spinner_selector` (or `fade_selector`) is specified, the spinner/fade
+#' customization applies to the parent element. If the customization should
+#' instead apply to the entire page, set `spinner_selector = 'html'` and
+#' `fade_selector = 'html'`.
 #'
 #' @param ... Currently ignored.
 #' @param spinner_type The type of spinner. Pre-bundled types include:
@@ -97,6 +112,11 @@ useBusyIndicators <- function(..., spinners = TRUE, pulse = TRUE) {
 #' @param spinner_selector A character string containing a CSS selector for
 #'   scoping the spinner customization. The default (`NULL`) will apply the
 #'   spinner customization to the parent element of the spinner.
+#' @param fade_opacity The opacity (a number between 0 and 1) for recalculating
+#'   output. Set to 1 to "disable" the fade.
+#' @param fade_selector A character string containing a CSS selector for
+#'   scoping the spinner customization. The default (`NULL`) will apply the
+#'   spinner customization to the parent element of the spinner.
 #' @param pulse_background A CSS background definition for the pulse. The
 #'   default uses a
 #'   [linear-gradient](https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient)
@@ -107,7 +127,7 @@ useBusyIndicators <- function(..., spinners = TRUE, pulse = TRUE) {
 #'   time.
 #'
 #' @export
-#' @seealso [useBusyIndicators()] for enabling/disabling busy indicators.
+#' @seealso [useBusyIndicators()] to disable/enable busy indicators.
 #' @examplesIf rlang::is_interactive()
 #'
 #' library(bslib)
@@ -162,6 +182,8 @@ busyIndicatorOptions <- function(
   spinner_size = NULL,
   spinner_delay = NULL,
   spinner_selector = NULL,
+  fade_opacity = NULL,
+  fade_selector = NULL,
   pulse_background = NULL,
   pulse_height = NULL,
   pulse_speed = NULL
@@ -177,6 +199,7 @@ busyIndicatorOptions <- function(
       delay = spinner_delay,
       selector = spinner_selector
     ),
+    fadeOptions(opacity = fade_opacity, selector = fade_selector),
     pulseOptions(
       background = pulse_background,
       height = pulse_height,
@@ -224,6 +247,26 @@ spinnerOptions <- function(type = NULL, color = NULL, size = NULL, delay = NULL,
   tags$style(css, id = id)
 }
 
+fadeOptions <- function(opacity = NULL, selector = NULL) {
+  if (is.null(opacity) && is.null(selector)) {
+    return(NULL)
+  }
+
+  css_vars <- htmltools::css(
+    "--shiny-fade-opacity" = opacity
+  )
+
+  id <- NULL
+  if (is.null(selector)) {
+    id <- paste0("fade-options-", p_randomInt(100, 1000000))
+    selector <- sprintf(":has(> #%s)", id)
+  }
+
+  css <- HTML(paste0(selector, " {", css_vars, "}"))
+
+  tags$style(css, id = id)
+}
+
 pulseOptions <- function(background = NULL, height = NULL, speed = NULL) {
   if (is.null(background) && is.null(height) && is.null(speed))  {
     return(NULL)
@@ -244,6 +287,8 @@ busyIndicatorDependency <- function() {
     version = get_package_version("shiny"),
     src = "www/shared/busy-indicators",
     package = "shiny",
-    stylesheet = "busy-indicators.css"
+    stylesheet = "busy-indicators.css",
+    # TODO-future: In next release make spinners and pulse opt-out
+    # head = as.character(useBusyIndicators())
   )
 }

R/conditions.R

@@ -130,6 +130,44 @@ captureStackTraces <- function(expr) {
 #' @include globals.R
 .globals$deepStack <- NULL
 
+getCallStackDigest <- function(callStack, warn = FALSE) {
+  dg <- attr(callStack, "shiny.stack.digest", exact = TRUE)
+  if (!is.null(dg)) {
+    return(dg)
+  }
+
+  if (isTRUE(warn)) {
+    rlang::warn(
+      "Call stack doesn't have a cached digest; expensively computing one now",
+      .frequency = "once",
+      .frequency_id = "deepstack-uncached-digest-warning"
+    )
+  }
+
+  rlang::hash(getCallNames(callStack))
+}
+
+saveCallStackDigest <- function(callStack) {
+  attr(callStack, "shiny.stack.digest") <- getCallStackDigest(callStack, warn = FALSE)
+  callStack
+}
+
+# Appends a call stack to a list of call stacks, but only if it's not already
+# in the list. The list is deduplicated by digest; ideally the digests on the
+# list are cached before calling this function (you will get a warning if not).
+appendCallStackWithDedupe <- function(lst, x) {
+  digests <- vapply(lst, getCallStackDigest, character(1), warn = TRUE)
+  xdigest <- getCallStackDigest(x, warn = TRUE)
+  stopifnot(all(nzchar(digests)))
+  stopifnot(length(xdigest) == 1)
+  stopifnot(nzchar(xdigest))
+  if (xdigest %in% digests) {
+    return(lst)
+  } else {
+    return(c(lst, list(x)))
+  }
+}
+
 createStackTracePromiseDomain <- function() {
   # These are actually stateless, we wouldn't have to create a new one each time
   # if we didn't want to. They're pretty cheap though.
@@ -142,13 +180,14 @@ createStackTracePromiseDomain <- function() {
         currentStack <- sys.calls()
         currentParents <- sys.parents()
         attr(currentStack, "parents") <- currentParents
+        currentStack <- saveCallStackDigest(currentStack)
         currentDeepStack <- .globals$deepStack
       }
       function(...) {
         # Fulfill time
         if (deepStacksEnabled()) {
           origDeepStack <- .globals$deepStack
-          .globals$deepStack <- c(currentDeepStack, list(currentStack))
+          .globals$deepStack <- appendCallStackWithDedupe(currentDeepStack, currentStack)
           on.exit(.globals$deepStack <- origDeepStack, add = TRUE)
         }
 
@@ -165,13 +204,14 @@ createStackTracePromiseDomain <- function() {
         currentStack <- sys.calls()
         currentParents <- sys.parents()
         attr(currentStack, "parents") <- currentParents
+        currentStack <- saveCallStackDigest(currentStack)
         currentDeepStack <- .globals$deepStack
       }
       function(...) {
         # Fulfill time
         if (deepStacksEnabled()) {
           origDeepStack <- .globals$deepStack
-          .globals$deepStack <- c(currentDeepStack, list(currentStack))
+          .globals$deepStack <- appendCallStackWithDedupe(currentDeepStack, currentStack)
           on.exit(.globals$deepStack <- origDeepStack, add = TRUE)
         }
 
@@ -199,6 +239,7 @@ doCaptureStack <- function(e) {
     calls <- sys.calls()
     parents <- sys.parents()
     attr(calls, "parents") <- parents
+    calls <- saveCallStackDigest(calls)
     attr(e, "stack.trace") <- calls
   }
   if (deepStacksEnabled()) {
@@ -281,88 +322,115 @@ printStackTrace <- function(cond,
   full = get_devmode_option("shiny.fullstacktrace", FALSE),
   offset = getOption("shiny.stacktraceoffset", TRUE)) {
 
-  should_drop <- !full
-  should_strip <- !full
-  should_prune <- !full
-
-  stackTraceCalls <- c(
+  stackTraces <- c(
     attr(cond, "deep.stack.trace", exact = TRUE),
     list(attr(cond, "stack.trace", exact = TRUE))
   )
 
-  stackTraceParents <- lapply(stackTraceCalls, attr, which = "parents", exact = TRUE)
-  stackTraceCallNames <- lapply(stackTraceCalls, getCallNames)
-  stackTraceCalls <- lapply(stackTraceCalls, offsetSrcrefs, offset = offset)
-
-  # Use dropTrivialFrames logic to remove trailing bits (.handleSimpleError, h)
-  if (should_drop) {
-    # toKeep is a list of logical vectors, of which elements (stack frames) to keep
-    toKeep <- lapply(stackTraceCallNames, dropTrivialFrames)
-    # We apply the list of logical vector indices to each data structure
-    stackTraceCalls <- mapply(stackTraceCalls, FUN = `[`, toKeep, SIMPLIFY = FALSE)
-    stackTraceCallNames <- mapply(stackTraceCallNames, FUN = `[`, toKeep, SIMPLIFY = FALSE)
-    stackTraceParents <- mapply(stackTraceParents, FUN = `[`, toKeep, SIMPLIFY = FALSE)
+  # Stripping of stack traces is the one step where the different stack traces
+  # interact. So we need to do this in one go, instead of individually within
+  # printOneStackTrace.
+  if (!full) {
+    stripResults <- stripStackTraces(lapply(stackTraces, getCallNames))
+  } else {
+    # If full is TRUE, we don't want to strip anything
+    stripResults <- rep_len(list(TRUE), length(stackTraces))
   }
 
-  delayedAssign("all_true", {
-    # List of logical vectors that are all TRUE, the same shape as
-    # stackTraceCallNames. Delay the evaluation so we don't create it unless
-    # we need it, but if we need it twice then we don't pay to create it twice.
-    lapply(stackTraceCallNames, function(st) {
-      rep_len(TRUE, length(st))
-    })
-  })
-
-  # stripStackTraces and lapply(stackTraceParents, pruneStackTrace) return lists
-  # of logical vectors. Use mapply(FUN = `&`) to boolean-and each pair of the
-  # logical vectors.
-  toShow <- mapply(
-    if (should_strip) stripStackTraces(stackTraceCallNames) else all_true,
-    if (should_prune) lapply(stackTraceParents, pruneStackTrace) else all_true,
-    FUN = `&`,
+  mapply(
+    seq_along(stackTraces),
+    rev(stackTraces),
+    rev(stripResults),
+    FUN = function(i, trace, stripResult) {
+      if (is.integer(trace)) {
+        noun <- if (trace > 1L) "traces" else "trace"
+        message("[ reached getOption(\"shiny.deepstacktrace\") -- omitted ", trace, " more stack ", noun, " ]")
+      } else {
+        if (i != 1) {
+          message("From earlier call:")
+        }
+        printOneStackTrace(
+          stackTrace = trace,
+          stripResult = stripResult,
+          full = full,
+          offset = offset
+        )
+      }
+      # No mapply return value--we're just printing
+      NULL
+    },
     SIMPLIFY = FALSE
   )
 
-  dfs <- mapply(seq_along(stackTraceCalls), rev(stackTraceCalls), rev(stackTraceCallNames), rev(toShow), FUN = function(i, calls, nms, index) {
-    st <- data.frame(
-      num = rev(which(index)),
-      call = rev(nms[index]),
-      loc = rev(getLocs(calls[index])),
-      category = rev(getCallCategories(calls[index])),
-      stringsAsFactors = FALSE
-    )
-
-    if (i != 1) {
-      message("From earlier call:")
-    }
-
-    if (nrow(st) == 0) {
-      message("  [No stack trace available]")
-    } else {
-      width <- floor(log10(max(st$num))) + 1
-      formatted <- paste0(
-        "  ",
-        formatC(st$num, width = width),
-        ": ",
-        mapply(paste0(st$call, st$loc), st$category, FUN = function(name, category) {
-          if (category == "pkg")
-            crayon::silver(name)
-          else if (category == "user")
-            crayon::blue$bold(name)
-          else
-            crayon::white(name)
-        }),
-        "\n"
-      )
-      cat(file = stderr(), formatted, sep = "")
-    }
-
-    st
-  }, SIMPLIFY = FALSE)
-
   invisible()
 }
 
+printOneStackTrace <- function(stackTrace, stripResult, full, offset) {
+  calls <- offsetSrcrefs(stackTrace, offset = offset)
+  callNames <- getCallNames(stackTrace)
+  parents <- attr(stackTrace, "parents", exact = TRUE)
+
+  should_drop <- !full
+  should_strip <- !full
+  should_prune <- !full
+
+  if (should_drop) {
+    toKeep <- dropTrivialFrames(callNames)
+    calls <- calls[toKeep]
+    callNames <- callNames[toKeep]
+    parents <- parents[toKeep]
+    stripResult <- stripResult[toKeep]
+  }
+
+  toShow <- rep(TRUE, length(callNames))
+  if (should_prune) {
+    toShow <- toShow & pruneStackTrace(parents)
+  }
+  if (should_strip) {
+    toShow <- toShow & stripResult
+  }
+
+  # If we're running in testthat, hide the parts of the stack trace that can
+  # vary based on how testthat was launched. It's critical that this is not
+  # happen at the same time as dropTrivialFrames, which happens before
+  # pruneStackTrace; because dropTrivialTestFrames removes calls from the top
+  # (or bottom? whichever is the oldest?) of the stack, it breaks `parents`
+  # which is based on absolute indices of calls. dropTrivialFrames gets away
+  # with this because it only removes calls from the opposite side of the stack.
+  toShow <- toShow & dropTrivialTestFrames(callNames)
+
+  st <- data.frame(
+    num = rev(which(toShow)),
+    call = rev(callNames[toShow]),
+    loc = rev(getLocs(calls[toShow])),
+    category = rev(getCallCategories(calls[toShow])),
+    stringsAsFactors = FALSE
+  )
+
+  if (nrow(st) == 0) {
+    message("  [No stack trace available]")
+  } else {
+    width <- floor(log10(max(st$num))) + 1
+    formatted <- paste0(
+      "  ",
+      formatC(st$num, width = width),
+      ": ",
+      mapply(paste0(st$call, st$loc), st$category, FUN = function(name, category) {
+        if (category == "pkg")
+          cli::col_silver(name)
+        else if (category == "user")
+          cli::style_bold(cli::col_blue(name))
+        else
+          cli::col_white(name)
+      }),
+      "\n"
+    )
+    cat(file = stderr(), formatted, sep = "")
+  }
+
+  invisible(st)
+}
+
 stripStackTraces <- function(stackTraces, values = FALSE) {
   score <- 1L  # >=1: show, <=0: hide
   lapply(seq_along(stackTraces), function(i) {
@@ -458,6 +526,33 @@ dropTrivialFrames <- function(callnames) {
   )
 }
 
+dropTrivialTestFrames <- function(callnames) {
+  if (!identical(Sys.getenv("TESTTHAT_IS_SNAPSHOT"), "true")) {
+    return(rep_len(TRUE, length(callnames)))
+  }
+
+  hideable <- callnames %in% c(
+    "test",
+    "devtools::test",
+    "test_check",
+    "testthat::test_check",
+    "test_dir",
+    "testthat::test_dir",
+    "test_file",
+    "testthat::test_file",
+    "test_local",
+    "testthat::test_local"
+  )
+
+  firstGoodCall <- min(which(!hideable))
+  toRemove <- firstGoodCall - 1L
+
+  c(
+    rep_len(FALSE, toRemove),
+    rep_len(TRUE, length(callnames) - toRemove)
+  )
+}
+
 offsetSrcrefs <- function(calls, offset = TRUE) {
   if (offset) {
     srcrefs <- getSrcRefs(calls)

R/devmode.R

@@ -128,6 +128,12 @@ in_devmode <- function() {
     !identical(Sys.getenv("TESTTHAT"), "true")
 }
 
+in_client_devmode <- function() {
+  # Client-side devmode enables client-side only dev features without local
+  # devmode. Currently, the main feature is the client-side error console.
+  isTRUE(getOption("shiny.client_devmode", FALSE))
+}
+
 #' @describeIn devmode Temporarily set Shiny Developer Mode and Developer
 #'   message verbosity
 #' @param code Code to execute with the temporary Dev Mode options set

R/extended-task.R

@@ -41,6 +41,54 @@
 #'   is, a function that quickly returns a promise) and allows even that very
 #'   session to immediately unblock and carry on with other user interactions.
 #'
+#' @examplesIf rlang::is_interactive() && rlang::is_installed("future")
+#'
+#' library(shiny)
+#' library(bslib)
+#' library(future)
+#' plan(multisession)
+#'
+#' ui <- page_fluid(
+#'   titlePanel("Extended Task Demo"),
+#'   p(
+#'     'Click the button below to perform a "calculation"',
+#'     "that takes a while to perform."
+#'   ),
+#'   input_task_button("recalculate", "Recalculate"),
+#'   p(textOutput("result"))
+#' )
+#'
+#' server <- function(input, output) {
+#'   rand_task <- ExtendedTask$new(function() {
+#'     future(
+#'       {
+#'         # Slow operation goes here
+#'         Sys.sleep(2)
+#'         sample(1:100, 1)
+#'       },
+#'       seed = TRUE
+#'     )
+#'   })
+#'
+#'   # Make button state reflect task.
+#'   # If using R >=4.1, you can do this instead:
+#'   # rand_task <- ExtendedTask$new(...) |> bind_task_button("recalculate")
+#'   bind_task_button(rand_task, "recalculate")
+#'
+#'   observeEvent(input$recalculate, {
+#'     # Invoke the extended in an observer
+#'     rand_task$invoke()
+#'   })
+#'
+#'   output$result <- renderText({
+#'     # React to updated results when the task completes
+#'     number <- rand_task$result()
+#'     paste0("Your number is ", number, ".")
+#'   })
+#' }
+#'
+#' shinyApp(ui, server)
+#'
 #' @export
 ExtendedTask <- R6Class("ExtendedTask", portable = TRUE, cloneable = FALSE,
   public = list(

R/graph.R

@@ -1,4 +1,3 @@
-
 # domain is like session
 
 
@@ -20,7 +19,7 @@ reactIdStr <- function(num) {
 #' dependencies and execution in your application.
 #'
 #' To use the reactive log visualizer, start with a fresh R session and
-#' run the command `options(shiny.reactlog=TRUE)`; then launch your
+#' run the command `reactlog::reactlog_enable()`; then launch your
 #' application in the usual way (e.g. using [runApp()]). At
 #' any time you can hit Ctrl+F3 (or for Mac users, Command+F3) in your
 #' web browser to launch the reactive log visualization.
@@ -43,16 +42,20 @@ reactIdStr <- function(num) {
 #' call `reactlogShow()` explicitly.
 #'
 #' For security and performance reasons, do not enable
-#' `shiny.reactlog` in production environments. When the option is
-#' enabled, it's possible for any user of your app to see at least some
-#' of the source code of your reactive expressions and observers.
+#' `options(shiny.reactlog=TRUE)` (or `reactlog::reactlog_enable()`) in
+#' production environments. When the option is enabled, it's possible
+#' for any user of your app to see at least some of the source code of
+#' your reactive expressions and observers. In addition, reactlog
+#' should be considered a memory leak as it will constantly grow and
+#' will never reset until the R session is restarted.
 #'
 #' @name reactlog
 NULL
 
 
-#' @describeIn reactlog Return a list of reactive information.  Can be used in conjunction with
-#'   [reactlog::reactlog_show] to later display the reactlog graph.
+#' @describeIn reactlog Return a list of reactive information.  Can be used in
+#'   conjunction with [reactlog::reactlog_show] to later display the reactlog
+#'   graph.
 #' @export
 reactlog <- function() {
   rLog$asList()
@@ -67,12 +70,34 @@ reactlogShow <- function(time = TRUE) {
   reactlog::reactlog_show(reactlog(), time = time)
 }
 
-#' @describeIn reactlog Resets the entire reactlog stack.  Useful for debugging and removing all prior reactive history.
+#' @describeIn reactlog Resets the entire reactlog stack.  Useful for debugging
+#' and removing all prior reactive history.
 #' @export
 reactlogReset <- function() {
   rLog$reset()
 }
 
+#' @describeIn reactlog Adds "mark" entry into the reactlog stack. This is
+#' useful for programmatically adding a marked entry in the reactlog, rather
+#' than using your keyboard's key combination.
+#'
+#' For example, we can _mark_ the reactlog at the beginning of an
+#' `observeEvent`'s calculation:
+#' ```r
+#' observeEvent(input$my_event_trigger, {
+#'   # Add a mark in the reactlog
+#'   reactlogAddMark()
+#'   # Run your regular event reaction code here...
+#'   ....
+#' })
+#' ```
+#' @param session The Shiny session to assign the mark to. Defaults to the
+#' current session.
+#' @export
+reactlogAddMark <- function(session = getDefaultReactiveDomain()) {
+  rLog$userMark(session)
+}
+
 # called in "/reactlog" middleware
 renderReactlog <- function(sessionToken = NULL, time = TRUE) {
   check_reactlog()
@@ -98,7 +123,6 @@ RLog <- R6Class(
   private = list(
     option = "shiny.reactlog",
     msgOption = "shiny.reactlog.console",
-
     appendEntry = function(domain, logEntry) {
       if (self$isLogging()) {
         sessionToken <- if (is.null(domain)) NULL else domain$token
@@ -113,20 +137,19 @@ RLog <- R6Class(
   public = list(
     msg = "<MessageLogger>",
     logStack = "<Stack>",
-
     noReactIdLabel = "NoCtxReactId",
     noReactId = reactIdStr("NoCtxReactId"),
     dummyReactIdLabel = "DummyReactId",
     dummyReactId = reactIdStr("DummyReactId"),
-
     asList = function() {
       ret <- self$logStack$as_list()
       attr(ret, "version") <- "1"
       ret
     },
-
     ctxIdStr = function(ctxId) {
-      if (is.null(ctxId) || identical(ctxId, "")) return(NULL)
+      if (is.null(ctxId) || identical(ctxId, "")) {
+        return(NULL)
+      }
       paste0("ctx", ctxId)
     },
     namesIdStr = function(reactId) {
@@ -141,7 +164,6 @@ RLog <- R6Class(
     keyIdStr = function(reactId, key) {
       paste0(reactId, "$", key)
     },
-
     valueStr = function(value, n = 200) {
       if (!self$isLogging()) {
         # return a placeholder string to avoid calling str
@@ -151,10 +173,9 @@ RLog <- R6Class(
         # only capture the first level of the object
         utils::capture.output(utils::str(value, max.level = 1))
       })
-      outputTxt <- paste0(output, collapse="\n")
+      outputTxt <- paste0(output, collapse = "\n")
       msg$shortenString(outputTxt, n = n)
     },
-
     initialize = function(rlogOption = "shiny.reactlog", msgOption = "shiny.reactlog.console") {
       private$option <- rlogOption
       private$msgOption <- msgOption
@@ -174,7 +195,6 @@ RLog <- R6Class(
     isLogging = function() {
       isTRUE(getOption(private$option, FALSE))
     },
-
     define = function(reactId, value, label, type, domain) {
       valueStr <- self$valueStr(value)
       if (msg$hasReact(reactId)) {
@@ -205,9 +225,10 @@ RLog <- R6Class(
     defineObserver = function(reactId, label, domain) {
       self$define(reactId, value = NULL, label, "observer", domain)
     },
-
     dependsOn = function(reactId, depOnReactId, ctxId, domain) {
-      if (is.null(reactId)) return()
+      if (is.null(reactId)) {
+        return()
+      }
       ctxId <- ctxIdStr(ctxId)
       msg$log("dependsOn:", msg$reactStr(reactId), " on", msg$reactStr(depOnReactId), msg$ctxStr(ctxId))
       private$appendEntry(domain, list(
@@ -220,7 +241,6 @@ RLog <- R6Class(
     dependsOnKey = function(reactId, depOnReactId, key, ctxId, domain) {
       self$dependsOn(reactId, self$keyIdStr(depOnReactId, key), ctxId, domain)
     },
-
     dependsOnRemove = function(reactId, depOnReactId, ctxId, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       msg$log("dependsOnRemove:", msg$reactStr(reactId), " on", msg$reactStr(depOnReactId), msg$ctxStr(ctxId))
@@ -234,7 +254,6 @@ RLog <- R6Class(
     dependsOnKeyRemove = function(reactId, depOnReactId, key, ctxId, domain) {
       self$dependsOnRemove(reactId, self$keyIdStr(depOnReactId, key), ctxId, domain)
     },
-
     createContext = function(ctxId, label, type, prevCtxId, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       prevCtxId <- self$ctxIdStr(prevCtxId)
@@ -245,10 +264,9 @@ RLog <- R6Class(
         label = msg$shortenString(label),
         type = type,
         prevCtxId = prevCtxId,
-        srcref = as.vector(attr(label, "srcref")), srcfile=attr(label, "srcfile")
+        srcref = as.vector(attr(label, "srcref")), srcfile = attr(label, "srcfile")
       ))
     },
-
     enter = function(reactId, ctxId, type, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       if (identical(type, "isolate")) {
@@ -291,7 +309,6 @@ RLog <- R6Class(
         ))
       }
     },
-
     valueChange = function(reactId, value, domain) {
       valueStr <- self$valueStr(value)
       msg$log("valueChange:", msg$reactStr(reactId), msg$valueStr(valueStr))
@@ -313,8 +330,6 @@ RLog <- R6Class(
     valueChangeKey = function(reactId, key, value, domain) {
       self$valueChange(self$keyIdStr(reactId, key), value, domain)
     },
-
-
     invalidateStart = function(reactId, ctxId, type, domain) {
       ctxId <- self$ctxIdStr(ctxId)
       if (identical(type, "isolate")) {
@@ -357,7 +372,6 @@ RLog <- R6Class(
         ))
       }
     },
-
     invalidateLater = function(reactId, runningCtx, millis, domain) {
       msg$log("invalidateLater: ", millis, "ms", msg$reactStr(reactId), msg$ctxStr(runningCtx))
       private$appendEntry(domain, list(
@@ -367,14 +381,12 @@ RLog <- R6Class(
         millis = millis
       ))
     },
-
     idle = function(domain = NULL) {
       msg$log("idle")
       private$appendEntry(domain, list(
         action = "idle"
       ))
     },
-
     asyncStart = function(domain = NULL) {
       msg$log("asyncStart")
       private$appendEntry(domain, list(
@@ -387,7 +399,6 @@ RLog <- R6Class(
         action = "asyncStop"
       ))
     },
-
     freezeReactiveVal = function(reactId, domain) {
       msg$log("freeze:", msg$reactStr(reactId))
       private$appendEntry(domain, list(
@@ -398,7 +409,6 @@ RLog <- R6Class(
     freezeReactiveKey = function(reactId, key, domain) {
       self$freezeReactiveVal(self$keyIdStr(reactId, key), domain)
     },
-
     thawReactiveVal = function(reactId, domain) {
       msg$log("thaw:", msg$reactStr(reactId))
       private$appendEntry(domain, list(
@@ -409,54 +419,60 @@ RLog <- R6Class(
     thawReactiveKey = function(reactId, key, domain) {
       self$thawReactiveVal(self$keyIdStr(reactId, key), domain)
     },
-
     userMark = function(domain = NULL) {
       msg$log("userMark")
       private$appendEntry(domain, list(
         action = "userMark"
       ))
     }
-
   )
 )
 
-MessageLogger = R6Class(
+MessageLogger <- R6Class(
   "MessageLogger",
   portable = FALSE,
   public = list(
     depth = 0L,
     reactCache = list(),
     option = "shiny.reactlog.console",
-
     initialize = function(option = "shiny.reactlog.console", depth = 0L) {
       if (!missing(depth)) self$depth <- depth
       if (!missing(option)) self$option <- option
     },
-
     isLogging = function() {
       isTRUE(getOption(self$option))
     },
     isNotLogging = function() {
-      ! isTRUE(getOption(self$option))
+      !isTRUE(getOption(self$option))
     },
     depthIncrement = function() {
-      if (self$isNotLogging()) return(NULL)
+      if (self$isNotLogging()) {
+        return(NULL)
+      }
       self$depth <- self$depth + 1L
     },
     depthDecrement = function() {
-      if (self$isNotLogging()) return(NULL)
+      if (self$isNotLogging()) {
+        return(NULL)
+      }
       self$depth <- self$depth - 1L
     },
     hasReact = function(reactId) {
-      if (self$isNotLogging()) return(FALSE)
+      if (self$isNotLogging()) {
+        return(FALSE)
+      }
       !is.null(self$getReact(reactId))
     },
     getReact = function(reactId, force = FALSE) {
-      if (identical(force, FALSE) && self$isNotLogging()) return(NULL)
+      if (identical(force, FALSE) && self$isNotLogging()) {
+        return(NULL)
+      }
       self$reactCache[[reactId]]
     },
     setReact = function(reactObj, force = FALSE) {
-      if (identical(force, FALSE) && self$isNotLogging()) return(NULL)
+      if (identical(force, FALSE) && self$isNotLogging()) {
+        return(NULL)
+      }
       self$reactCache[[reactObj$reactId]] <- reactObj
     },
     shortenString = function(txt, n = 250) {
@@ -475,13 +491,17 @@ MessageLogger = R6Class(
     },
     valueStr = function(valueStr) {
       paste0(
-        " '",  self$shortenString(self$singleLine(valueStr)), "'"
+        " '", self$shortenString(self$singleLine(valueStr)), "'"
       )
     },
     reactStr = function(reactId) {
-      if (self$isNotLogging()) return(NULL)
+      if (self$isNotLogging()) {
+        return(NULL)
+      }
       reactInfo <- self$getReact(reactId)
-      if (is.null(reactInfo)) return(" <UNKNOWN_REACTID>")
+      if (is.null(reactInfo)) {
+        return(" <UNKNOWN_REACTID>")
+      }
       paste0(
         " ", reactInfo$reactId, ":'", self$shortenString(self$singleLine(reactInfo$label)), "'"
       )
@@ -490,11 +510,15 @@ MessageLogger = R6Class(
       self$ctxStr(ctxId = NULL, type = type)
     },
     ctxStr = function(ctxId = NULL, type = NULL) {
-      if (self$isNotLogging()) return(NULL)
+      if (self$isNotLogging()) {
+        return(NULL)
+      }
       self$ctxPrevCtxStr(ctxId = ctxId, prevCtxId = NULL, type = type)
     },
     ctxPrevCtxStr = function(ctxId = NULL, prevCtxId = NULL, type = NULL, preCtxIdTxt = " in ") {
-      if (self$isNotLogging()) return(NULL)
+      if (self$isNotLogging()) {
+        return(NULL)
+      }
       paste0(
         if (!is.null(ctxId)) paste0(preCtxIdTxt, ctxId),
         if (!is.null(prevCtxId)) paste0(" from ", prevCtxId),
@@ -502,7 +526,9 @@ MessageLogger = R6Class(
       )
     },
     log = function(...) {
-      if (self$isNotLogging()) return(NULL)
+      if (self$isNotLogging()) {
+        return(NULL)
+      }
       msg <- paste0(
         paste0(rep("= ", depth), collapse = ""), "- ", paste0(..., collapse = ""),
         collapse = ""

R/input-date.R

@@ -153,6 +153,12 @@ datePickerDependency <- function(theme) {
   )
 }
 
+datePickerSass <- function() {
+  sass::sass_file(
+    system_file(package = "shiny", "www/shared/datepicker/scss/build3.scss")
+  )
+}
+
 datePickerCSS <- function(theme) {
   if (!is_bs_theme(theme)) {
     return(htmlDependency(
@@ -164,10 +170,8 @@ datePickerCSS <- function(theme) {
     ))
   }
 
-  scss_file <- system_file(package = "shiny", "www/shared/datepicker/scss/build3.scss")
-
   bslib::bs_dependency(
-    input = sass::sass_file(scss_file),
+    input = datePickerSass(),
     theme = theme,
     name = "bootstrap-datepicker",
     version = version_bs_date_picker,

R/input-numeric.R

@@ -29,22 +29,36 @@
 #' A numeric vector of length 1.
 #'
 #' @export
-numericInput <- function(inputId, label, value, min = NA, max = NA, step = NA,
-  width = NULL) {
+numericInput <- function(
+  inputId,
+  label,
+  value,
+  min = NA,
+  max = NA,
+  step = NA,
+  width = NULL,
+  ...,
+  updateOn = c("change", "blur")
+) {
+  rlang::check_dots_empty()
+  updateOn <- rlang::arg_match(updateOn)
 
   value <- restoreInput(id = inputId, default = value)
 
   # build input tag
-  inputTag <- tags$input(id = inputId, type = "number", class="shiny-input-number form-control",
-                         value = formatNoSci(value))
-  if (!is.na(min))
-    inputTag$attribs$min = min
-  if (!is.na(max))
-    inputTag$attribs$max = max
-  if (!is.na(step))
-    inputTag$attribs$step = step
+  inputTag <- tags$input(
+    id = inputId,
+    type = "number",
+    class = "shiny-input-number form-control",
+    value = formatNoSci(value),
+    `data-update-on` = updateOn
+  )
+  if (!is.na(min)) inputTag$attribs$min = min
+  if (!is.na(max)) inputTag$attribs$max = max
+  if (!is.na(step)) inputTag$attribs$step = step
 
-  div(class = "form-group shiny-input-container",
+  div(
+    class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
     inputTag

R/input-password.R

@@ -30,12 +30,29 @@
 #' shinyApp(ui, server)
 #' }
 #' @export
-passwordInput <- function(inputId, label, value = "", width = NULL,
-                          placeholder = NULL) {
-  div(class = "form-group shiny-input-container",
+passwordInput <- function(
+  inputId,
+  label,
+  value = "",
+  width = NULL,
+  placeholder = NULL,
+  ...,
+  updateOn = c("change", "blur")
+) {
+  rlang::check_dots_empty()
+  updateOn <- rlang::arg_match(updateOn)
+
+  div(
+    class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
-    tags$input(id = inputId, type="password", class="shiny-input-password form-control", value=value,
-               placeholder = placeholder)
+    tags$input(
+      id = inputId,
+      type = "password",
+      class = "shiny-input-password form-control",
+      value = value,
+      placeholder = placeholder,
+      `data-update-on` = updateOn
+    )
   )
 }

R/input-select.R

@@ -241,11 +241,8 @@ selectizeDependencyFunc <- function(theme) {
     return(selectizeStaticDependency(version_selectize))
   }
 
-  selectizeDir <- system_file(package = "shiny", "www/shared/selectize/")
   bs_version <- bslib::theme_version(theme)
-  stylesheet <- file.path(
-    selectizeDir, "scss", paste0("selectize.bootstrap", bs_version, ".scss")
-  )
+
   # It'd be cleaner to ship the JS in a separate, href-based,
   # HTML dependency (which we currently do for other themable widgets),
   # but DT, crosstalk, and maybe other pkgs include selectize JS/CSS
@@ -253,10 +250,11 @@ selectizeDependencyFunc <- function(theme) {
   # name, the JS/CSS would be loaded/included twice, which leads to
   # strange issues, especially since we now include a 3rd party
   # accessibility plugin https://github.com/rstudio/shiny/pull/3153
+  selectizeDir <- system_file(package = "shiny", "www/shared/selectize/")
   script <- file.path(selectizeDir, selectizeScripts())
 
   bslib::bs_dependency(
-    input = sass::sass_file(stylesheet),
+    input = selectizeSass(bs_version),
     theme = theme,
     name = "selectize",
     version = version_selectize,
@@ -265,6 +263,14 @@ selectizeDependencyFunc <- function(theme) {
   )
 }
 
+selectizeSass <- function(bs_version) {
+  selectizeDir <- system_file(package = "shiny", "www/shared/selectize/")
+  stylesheet <- file.path(
+    selectizeDir, "scss", paste0("selectize.bootstrap", bs_version, ".scss")
+  )
+  sass::sass_file(stylesheet)
+}
+
 selectizeStaticDependency <- function(version) {
   htmlDependency(
     "selectize",

R/input-slider.R

@@ -222,6 +222,15 @@ ionRangeSliderDependency <- function() {
   )
 }
 
+ionRangeSliderDependencySass <- function() {
+  list(
+    list(accent = "$component-active-bg"),
+    sass::sass_file(
+      system_file(package = "shiny", "www/shared/ionrangeslider/scss/shiny.scss")
+    )
+  )
+}
+
 ionRangeSliderDependencyCSS <- function(theme) {
   if (!is_bs_theme(theme)) {
     return(htmlDependency(
@@ -234,12 +243,7 @@ ionRangeSliderDependencyCSS <- function(theme) {
   }
 
   bslib::bs_dependency(
-    input = list(
-      list(accent = "$component-active-bg"),
-      sass::sass_file(
-        system_file(package = "shiny", "www/shared/ionrangeslider/scss/shiny.scss")
-      )
-    ),
+    input = ionRangeSliderDependencySass(),
     theme = theme,
     name = "ionRangeSlider",
     version = version_ion_range_slider,

R/input-submit.R

@@ -57,7 +57,7 @@ submitButton <- function(text = "Apply Changes", icon = NULL, width = NULL) {
   div(
     tags$button(
       type="submit",
-      class="btn btn-primary",
+      class="btn btn-primary submit-button",
       style = css(width = validateCssUnit(width)),
       list(icon, text)
     )

R/input-text.R

@@ -10,6 +10,14 @@
 #' @param placeholder A character string giving the user a hint as to what can
 #'   be entered into the control. Internet Explorer 8 and 9 do not support this
 #'   option.
+#' @param ... Ignored, included to require named arguments and for future
+#'   feature expansion.
+#' @param updateOn A character vector specifying when the input should be
+#'   updated. Options are `"change"` (default) and `"blur"`. Use `"change"` to
+#'   update the input immediately whenever the value changes. Use `"blur"`to
+#'   delay the input update until the input loses focus (the user moves away
+#'   from the input), or when Enter is pressed (or Cmd/Ctrl + Enter for
+#'   [textAreaInput()]).
 #' @return A text input control that can be added to a UI definition.
 #'
 #' @family input elements
@@ -34,15 +42,31 @@
 #' unless `value` is provided.
 #'
 #' @export
-textInput <- function(inputId, label, value = "", width = NULL,
-  placeholder = NULL) {
+textInput <- function(
+  inputId,
+  label,
+  value = "",
+  width = NULL,
+  placeholder = NULL,
+  ...,
+  updateOn = c("change", "blur")
+) {
+  rlang::check_dots_empty()
+  updateOn <- rlang::arg_match(updateOn)
 
   value <- restoreInput(id = inputId, default = value)
 
-  div(class = "form-group shiny-input-container",
+  div(
+    class = "form-group shiny-input-container",
     style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
-    tags$input(id = inputId, type="text", class="shiny-input-text form-control", value=value,
-      placeholder = placeholder)
+    tags$input(
+      id = inputId,
+      type = "text",
+      class = "shiny-input-text form-control",
+      value = value,
+      placeholder = placeholder,
+      `data-update-on` = updateOn
+    )
   )
 }

R/input-textarea.R

@@ -16,6 +16,8 @@
 #' @param resize Which directions the textarea box can be resized. Can be one of
 #'   `"both"`, `"none"`, `"vertical"`, and `"horizontal"`. The default, `NULL`,
 #'   will use the client browser's default setting for resizing textareas.
+#' @param autoresize If `TRUE`, the textarea will automatically resize to fit
+#'   the input text.
 #' @return A textarea input control that can be added to a UI definition.
 #'
 #' @family input elements
@@ -41,8 +43,22 @@
 #' unless `value` is provided.
 #'
 #' @export
-textAreaInput <- function(inputId, label, value = "", width = NULL, height = NULL,
-  cols = NULL, rows = NULL, placeholder = NULL, resize = NULL) {
+textAreaInput <- function(
+  inputId,
+  label,
+  value = "",
+  width = NULL,
+  height = NULL,
+  cols = NULL,
+  rows = NULL,
+  placeholder = NULL,
+  resize = NULL,
+  ...,
+  autoresize = FALSE,
+  updateOn = c("change", "blur")
+) {
+  rlang::check_dots_empty()
+  updateOn <- rlang::arg_match(updateOn)
 
   value <- restoreInput(id = inputId, default = value)
 
@@ -50,23 +66,30 @@ textAreaInput <- function(inputId, label, value = "", width = NULL, height = NUL
     resize <- match.arg(resize, c("both", "none", "vertical", "horizontal"))
   }
 
-  style <- css(
-    # The width is specified on the parent div.
-    width = if (!is.null(width)) "100%",
-    height = validateCssUnit(height),
-    resize = resize
-  )
+  classes <- c("shiny-input-textarea", "form-control")
+  if (autoresize) {
+    classes <- c(classes, "textarea-autoresize")
+    if (is.null(rows)) {
+      rows <- 1
+    }
+  }
 
-  div(class = "form-group shiny-input-container",
+  div(
+    class = "form-group shiny-input-container",
+    style = css(width = validateCssUnit(width)),
     shinyInputLabel(inputId, label),
-    style = if (!is.null(width)) paste0("width: ", validateCssUnit(width), ";"),
     tags$textarea(
       id = inputId,
-      class = "shiny-input-textarea form-control",
+      class = classes,
       placeholder = placeholder,
-      style = style,
+      style = css(
+        width = if (!is.null(width)) "100%",
+        height = validateCssUnit(height),
+        resize = resize
+      ),
       rows = rows,
       cols = cols,
+      `data-update-on` = updateOn,
       value
     )
   )

R/react.R

@@ -53,10 +53,12 @@ Context <- R6Class(
 
       promises::with_promise_domain(reactivePromiseDomain(), {
         withReactiveDomain(.domain, {
-          env <- .getReactiveEnvironment()
-          rLog$enter(.reactId, id, .reactType, .domain)
-          on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE)
-          env$runWith(self, func)
+          captureStackTraces({
+            env <- .getReactiveEnvironment()
+            rLog$enter(.reactId, id, .reactType, .domain)
+            on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE)
+            env$runWith(self, func)
+          })
         })
       })
     },
@@ -223,9 +225,7 @@ wrapForContext <- function(func, ctx) {
 
   function(...) {
     .getReactiveEnvironment()$runWith(ctx, function() {
-      captureStackTraces(
-        func(...)
-      )
+      func(...)
     })
   }
 }

R/reactives.R

@@ -951,7 +951,10 @@ Observable <- R6Class(
 #' See the [Shiny tutorial](https://shiny.rstudio.com/tutorial/) for
 #' more information about reactive expressions.
 #'
-#' @param x For `is.reactive()`, an object to test. For `reactive()`, an expression. When passing in a [`quo()`]sure with `reactive()`, remember to use [`rlang::inject()`] to distinguish that you are passing in the content of your quosure, not the expression of the quosure.
+#' @param x For `is.reactive()`, an object to test. For `reactive()`, an
+#'   expression. When passing in a [`rlang::quo()`]sure with `reactive()`,
+#'   remember to use [`rlang::inject()`] to distinguish that you are passing in
+#'   the content of your quosure, not the expression of the quosure.
 #' @template param-env
 #' @templateVar x x
 #' @templateVar env env
@@ -2301,7 +2304,7 @@ observeEvent <- function(eventExpr, handlerExpr,
     priority = priority,
     domain = domain,
     autoDestroy = TRUE,
-    ..stacktraceon = FALSE # TODO: Does this go in the bindEvent?
+    ..stacktraceon = TRUE
   ))
 
   o <- inject(bindEvent(

R/runapp.R

@@ -445,7 +445,9 @@ stopApp <- function(returnValue = invisible()) {
 #' @param host The IPv4 address that the application should listen on. Defaults
 #'   to the `shiny.host` option, if set, or `"127.0.0.1"` if not.
 #' @param display.mode The mode in which to display the example. Defaults to
-#'   `showcase`, but may be set to `normal` to see the example without
+#'   `"auto"`, which uses the value of `DisplayMode` in the example's
+#'   `DESCRIPTION` file. Set to `"showcase"` to show the app code and
+#'   description with the running app, or `"normal"` to see the example without
 #'   code or commentary.
 #' @param package The package in which to find the example (defaults to
 #'   `"shiny"`).

R/shiny-options.R

@@ -65,16 +65,20 @@ getShinyOption <- function(name, default = NULL) {
 #'   changes are detected, all connected Shiny sessions are reloaded. This
 #'   allows for fast feedback loops when tweaking Shiny UI.
 #'
-#'   Since monitoring for changes is expensive (we simply poll for last
-#'   modified times), this feature is intended only for development.
+#'   Monitoring for changes is no longer expensive, thanks to the \pkg{watcher}
+#'   package, 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"))`
+#'   shiny.autoreload.pattern option. For example, to monitor only `ui.R`:
+#'   `options(shiny.autoreload.pattern = glob2rx("ui.R"))`. 
 #'
-#'   The default polling interval is 500 milliseconds. You can change this
-#'   by setting e.g. `options(shiny.autoreload.interval = 2000)` (every
-#'   two seconds).}
+#'   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
+#'   `options(shiny.autoreload.interval = 2000)` (in milliseconds). This value
+#'   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
 #'   [shinyDeprecated()] for more information.}
@@ -151,6 +155,11 @@ getShinyOption <- function(name, default = NULL) {
 # ' \item{shiny.devmode.verbose (defaults to `TRUE`)}{If `TRUE`, will display messages printed
 # '   about which options are being set. See [devmode()] for more details. }
 ### (end not documenting 'shiny.devmode.verbose')
+### start shiny.client_devmode is primarily for niche, internal shinylive usage
+# ' \item{shiny.client_devmode (defaults to `FALSE`)}{If `TRUE`, enables client-
+# '  side devmode features. Currently the primary feature is the client-side
+# '  error console.}
+### end shiny.client_devmode
 #' }
 #'
 #'

R/shiny.R

@@ -2024,7 +2024,7 @@ ShinySession <- R6Class(
         tmpdata <- tempfile(fileext = ext)
         return(Context$new(getDefaultReactiveDomain(), '[download]')$run(function() {
           promises::with_promise_domain(reactivePromiseDomain(), {
-            promises::with_promise_domain(createStackTracePromiseDomain(), {
+            captureStackTraces({
               self$incrementBusyCount()
               hybrid_chain(
                 # ..stacktraceon matches with the top-level ..stacktraceoff..

R/shinyapp.R

@@ -162,11 +162,29 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
     sharedEnv <- globalenv()
   }
 
+  # To enable hot-reloading of support files, this function is called
+  # whenever the UI or Server func source is updated. To avoid loading
+  # support files 2x, we follow the last cache update trigger timestamp.
+  autoload_r_support_if_needed <- local({
+    autoload_last_loaded <- -1
+    function() {
+      if (!isTRUE(getOption("shiny.autoload.r", TRUE))) return()
+      
+      last_cache_trigger <- cachedAutoReloadLastChanged$get()
+      if (identical(autoload_last_loaded, last_cache_trigger)) return()
+
+      loadSupport(appDir, renv = sharedEnv, globalrenv = globalenv())
+
+      autoload_last_loaded <<- last_cache_trigger
+    }
+  })
+
   # uiHandlerSource is a function that returns an HTTP handler for serving up
   # ui.R as a webpage. The "cachedFuncWithFile" call makes sure that the closure
   # we're creating here only gets executed when ui.R's contents change.
   uiHandlerSource <- cachedFuncWithFile(appDir, "ui.R", case.sensitive = FALSE,
     function(uiR) {
+      autoload_r_support_if_needed()
       if (file.exists(uiR)) {
         # If ui.R contains a call to shinyUI (which sets .globals$ui), use that.
         # If not, then take the last expression that's returned from ui.R.
@@ -197,6 +215,7 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
 
   serverSource <- cachedFuncWithFile(appDir, "server.R", case.sensitive = FALSE,
     function(serverR) {
+      autoload_r_support_if_needed()
       # If server.R contains a call to shinyServer (which sets .globals$server),
       # use that. If not, then take the last expression that's returned from
       # server.R.
@@ -232,10 +251,9 @@ shinyAppDir_serverR <- function(appDir, options=list()) {
   onStart <- function() {
     oldwd <<- getwd()
     setwd(appDir)
-    # TODO: we should support hot reloading on global.R and R/*.R changes.
     if (getOption("shiny.autoload.r", TRUE)) {
-      loadSupport(appDir, renv=sharedEnv, globalrenv=globalenv())
-    }  else {
+      autoload_r_support_if_needed()
+    } else {
       if (file.exists(file.path.ci(appDir, "global.R")))
         sourceUTF8(file.path.ci(appDir, "global.R"))
     }
@@ -290,33 +308,77 @@ initAutoReloadMonitor <- function(dir) {
     return(function(){})
   }
 
-  filePattern <- getOption("shiny.autoreload.pattern",
-    ".*\\.(r|html?|js|css|png|jpe?g|gif)$")
+  filePattern <- getOption(
+    "shiny.autoreload.pattern",
+    ".*\\.(r|html?|js|css|png|jpe?g|gif)$"
+  )
 
-  lastValue <- NULL
-  observeLabel <- paste0("File Auto-Reload - '", basename(dir), "'")
-  obs <- 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
+  
+  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"
+      )
+    }
 
-    invalidateLater(getOption("shiny.autoreload.interval", 500))
-  })
+    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
+  }
 
-  onStop(obs$destroy)
-
-  obs$destroy
+  invisible(watcher)
 }
 
 #' Load an app's supporting R files
@@ -421,8 +483,6 @@ shinyAppDir_appR <- function(fileName, appDir, options=list())
       wasDir <- setwd(appDir)
       on.exit(setwd(wasDir))
 
-      # TODO: we should support hot reloading on R/*.R changes.
-      # In an upcoming version of shiny, this option will go away.
       if (getOption("shiny.autoload.r", TRUE)) {
         # Create a child env which contains all the helpers and will be the shared parent
         # of the ui.R and server.R load.

R/shinyui.R

@@ -69,7 +69,7 @@ renderPage <- function(ui, showcase=0, testMode=FALSE) {
       )
   }
 
-  if (in_devmode()) {
+  if (in_devmode() || in_client_devmode()) {
     # If we're in dev mode, add a simple script to the head that injects a
     # global variable for the client to use to detect dev mode.
     shiny_deps[[length(shiny_deps) + 1]] <-
@@ -135,6 +135,14 @@ shinyDependencies <- function() {
   )
 }
 
+shinyDependencySass <- function(bs_version) {
+  bootstrap_scss <- paste0("shiny.bootstrap", bs_version, ".scss")
+
+  scss_home <- system_file("www/shared/shiny_scss", package = "shiny")
+  scss_files <- file.path(scss_home, c(bootstrap_scss, "shiny.scss"))
+  lapply(scss_files, sass::sass_file)
+}
+
 shinyDependencyCSS <- function(theme) {
   version <- get_package_version("shiny")
 
@@ -150,14 +158,9 @@ shinyDependencyCSS <- function(theme) {
   }
 
   bs_version <- bslib::theme_version(theme)
-  bootstrap_scss <- paste0("shiny.bootstrap", bs_version, ".scss")
-
-  scss_home <- system_file("www/shared/shiny_scss", package = "shiny")
-  scss_files <- file.path(scss_home, c(bootstrap_scss, "shiny.scss"))
-  scss_files <- lapply(scss_files, sass::sass_file)
 
   bslib::bs_dependency(
-    input = scss_files,
+    input = shinyDependencySass(bs_version),
     theme = theme,
     name = "shiny-sass",
     version = version,

R/shinywrappers.R

@@ -383,8 +383,10 @@ markOutputAttrs <- function(renderFunc, snapshotExclude = NULL,
 #' The corresponding HTML output tag should be `div` or `img` and have
 #' the CSS class name `shiny-image-output`.
 #'
-#' @seealso For more details on how the images are generated, and how to control
+#' @seealso 
+#' * For more details on how the images are generated, and how to control
 #'   the output, see [plotPNG()].
+#' * Use [outputOptions()] to set general output options for an image output.
 #'
 #' @param expr An expression that returns a list.
 #' @inheritParams renderUI
@@ -598,6 +600,7 @@ isTemp <- function(path, tempDir = tempdir(), mustExist) {
 #'   used in an interactive RMarkdown document.
 #'
 #' @example res/text-example.R
+#' @seealso [outputOptions()]
 #' @export
 renderPrint <- function(expr, env = parent.frame(), quoted = FALSE,
                         width = getOption('width'), outputArgs=list())
@@ -719,7 +722,7 @@ renderText <- function(expr, env = parent.frame(), quoted = FALSE,
 #'   call to [uiOutput()] when `renderUI` is used in an
 #'   interactive R Markdown document.
 #'
-#' @seealso [uiOutput()]
+#' @seealso [uiOutput()], [outputOptions()]
 #' @export
 #' @examples
 #' ## Only run examples in interactive R sessions
@@ -809,6 +812,13 @@ renderUI <- function(expr, env = parent.frame(), quoted = FALSE,
 #'
 #' shinyApp(ui, server)
 #' }
+#'
+#' @seealso
+#' * The download handler, like other outputs, is suspended (disabled) by
+#'   default for download buttons and links that are hidden. Use 
+#'   [outputOptions()] to control this behavior, e.g. to set 
+#'   `suspendWhenHidden = FALSE` if the download is initiated by 
+#'   programmatically clicking on the download button using JavaScript.
 #' @export
 downloadHandler <- function(filename, content, contentType=NULL, outputArgs=list()) {
   renderFunc <- function(shinysession, name, ...) {

R/test.R

@@ -158,8 +158,7 @@ print.shiny_runtests <- function(x, ..., reporter = "summary") {
 
 
   if (any(x$pass)) {
-    # TODO in future... use clisymbols::symbol$tick and crayon green
-    cat("* Success\n")
+    cli::cat_bullet("Success", bullet = "tick", bullet_col = "green")
     mapply(
       x$file,
       x$pass,
@@ -171,9 +170,8 @@ print.shiny_runtests <- function(x, ..., reporter = "summary") {
       }
     )
   }
-  if (any(!x$pass)) {
-    # TODO in future... use clisymbols::symbol$cross and crayon red
-    cat("* Failure\n")
+  if (!all(x$pass)) {
+    cli::cat_bullet("Failure", bullet = "cross", bullet_col = "red")
     mapply(
       x$file,
       x$pass,

R/utils-lang.R

@@ -53,8 +53,8 @@ formalsAndBody <- function(x) {
 
 #' @describeIn createRenderFunction convert a quosure to a function.
 #' @param q Quosure of the expression `x`. When capturing expressions to create
-#'   your quosure, it is recommended to use [`enquo0()`] to not unquote the
-#'   object too early. See [`enquo0()`] for more details.
+#'   your quosure, it is recommended to use [`rlang::enquo0()`] to not unquote
+#'   the object too early. See [`rlang::enquo0()`] for more details.
 #' @inheritParams installExprFunction
 #' @export
 quoToFunction <- function(

R/utils.R

@@ -770,22 +770,45 @@ formatNoSci <- function(x) {
   format(x, scientific = FALSE, digits = 15)
 }
 
+# A simple getter/setting to track the last time the auto-reload process
+# updated. This value is used by `cachedFuncWithFile()` when auto-reload is
+# enabled to reload app/ui/server files when watched supporting files change.
+cachedAutoReloadLastChanged <- local({
+  last_update <- 0
+
+  list(
+    set = function() {
+      last_update <<- as.integer(Sys.time())
+      invisible(last_update)
+    },
+    get = function() {
+      last_update
+    }
+  )
+})
+
 # Returns a function that calls the given func and caches the result for
 # subsequent calls, unless the given file's mtime changes.
 cachedFuncWithFile <- function(dir, file, func, case.sensitive = FALSE) {
-  dir <- normalizePath(dir, mustWork=TRUE)
-  mtime <- NA
+  dir <- normalizePath(dir, mustWork = TRUE)
+
   value <- NULL
+  last_mtime_file <- NA
+  last_autoreload <- 0
+
   function(...) {
-    fname <- if (case.sensitive)
-      file.path(dir, file)
-    else
+    fname <- if (case.sensitive) { 
+      file.path(dir, file) 
+    } else {
       file.path.ci(dir, file)
+    }
 
     now <- file.info(fname)$mtime
-    if (!identical(mtime, now)) {
+    autoreload <- last_autoreload < cachedAutoReloadLastChanged$get()
+    if (autoreload || !identical(last_mtime_file, now)) {
       value <<- func(fname, ...)
-      mtime <<- now
+      last_mtime_file <<- now
+      last_autoreload <<- cachedAutoReloadLastChanged$get()
     }
     value
   }

babel.config.json

@@ -1,15 +0,0 @@
-{
-  "presets": [
-    "@babel/preset-typescript",
-    [
-      "@babel/preset-env",
-      {
-        "useBuiltIns": "usage",
-        "corejs": "3.12"
-      }
-    ]
-  ],
-  "ignore":[
-    "node_modules/core-js"
-  ]
-}

cran-comments.md

@@ -0,0 +1,40 @@
+## revdepcheck results
+
+We checked 1278 reverse dependencies (1277 from CRAN + 1 from Bioconductor), comparing R CMD check results across CRAN and dev versions of shiny.
+
+ * We saw 2 new problems (NOTEs only)
+ * We failed to check 19 packages due to installation issues
+
+Issues with CRAN packages are summarised below.
+
+### New problems
+
+R CMD check displayed NOTEs for two packages, unrelated to changes in shiny.
+
+* HH
+  checking installed package size ... NOTE
+
+* PopED
+  checking installed package size ... NOTE
+
+### Failed to check
+
+* animalEKF
+* AovBay
+* Certara.VPCResults
+* chipPCR
+* ctsem
+* dartR.sim
+* diveR
+* gap
+* jsmodule
+* loon.shiny
+* robmedExtra
+* rstanarm
+* SensMap
+* Seurat
+* shinyTempSignal
+* Signac
+* statsr
+* TestAnaAPP
+* tidyvpc

inst/www/shared/busy-indicators/busy-indicators.css

@@ -1,2 +1,2 @@
-/*! shiny 1.8.1.9001 | (c) 2012-2024 RStudio, PBC. | License: GPL-3 | file LICENSE */
-:where([data-shiny-busy-spinners] .recalculating){position:relative}[data-shiny-busy-spinners] .recalculating{opacity:1}[data-shiny-busy-spinners] .recalculating:after{position:absolute;content:"";--_shiny-spinner-url: var(--shiny-spinner-url, url(spinners/ring.svg));--_shiny-spinner-color: var(--shiny-spinner-color, var(--bs-primary, #007bc2));--_shiny-spinner-size: var(--shiny-spinner-size, 32px);--_shiny-spinner-delay: var(--shiny-spinner-delay, 1s);background:var(--_shiny-spinner-color);width:var(--_shiny-spinner-size);height:var(--_shiny-spinner-size);inset:calc(50% - var(--_shiny-spinner-size) / 2);mask-image:var(--_shiny-spinner-url);-webkit-mask-image:var(--_shiny-spinner-url);opacity:0;animation-delay:var(--_shiny-spinner-delay);animation-name:fade-in;animation-duration:.25s}[data-shiny-busy-spinners] .recalculating>*:not(.recalculating){opacity:.2;transition:opacity .25s ease var(--shiny-spinner-delay, 1s)}[data-shiny-busy-spinners] .recalculating.shiny-html-output:after{display:none}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:after{--_shiny-pulse-background: var( --shiny-pulse-background, linear-gradient( 120deg, var(--bs-body-bg, #fff), var(--bs-indigo, #4b00c1), var(--bs-purple, #74149c), var(--bs-pink, #bf007f), var(--bs-body-bg, #fff) ) );--_shiny-pulse-height: var(--shiny-pulse-height, 5px);--_shiny-pulse-speed: var(--shiny-pulse-speed, 1.85s);position:fixed;top:0;left:0;height:var(--_shiny-pulse-height);background:var(--_shiny-pulse-background);z-index:9999;animation-name:busy-page-pulse;animation-duration:var(--_shiny-pulse-speed);animation-iteration-count:infinite;animation-timing-function:ease-in-out;content:""}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:has(.recalculating):after{display:none}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:has(#shiny-disconnected-overlay):after{display:none}[data-shiny-busy-pulse]:not([data-shiny-busy-spinners]).shiny-busy:after{--_shiny-pulse-background: var( --shiny-pulse-background, linear-gradient( 120deg, var(--bs-body-bg, #fff), var(--bs-indigo, #4b00c1), var(--bs-purple, #74149c), var(--bs-pink, #bf007f), var(--bs-body-bg, #fff) ) );--_shiny-pulse-height: var(--shiny-pulse-height, 5px);--_shiny-pulse-speed: var(--shiny-pulse-speed, 1.85s);position:fixed;top:0;left:0;height:var(--_shiny-pulse-height);background:var(--_shiny-pulse-background);z-index:9999;animation-name:busy-page-pulse;animation-duration:var(--_shiny-pulse-speed);animation-iteration-count:infinite;animation-timing-function:ease-in-out;content:""}[data-shiny-busy-pulse]:not([data-shiny-busy-spinners]).shiny-busy:has(#shiny-disconnected-overlay):after{display:none}@keyframes fade-in{0%{opacity:0}to{opacity:1}}@keyframes busy-page-pulse{0%{left:-75%;width:75%}50%{left:100%;width:75%}to{left:-75%;width:75%}}
+/*! shiny 1.10.0.9000 | (c) 2012-2025 Posit Software, PBC. | License: GPL-3 | file LICENSE */
+:where([data-shiny-busy-spinners] .recalculating){position:relative}[data-shiny-busy-spinners] .recalculating{min-height:var(--shiny-spinner-size, 32px)}[data-shiny-busy-spinners] .recalculating:after{position:absolute;content:"";--_shiny-spinner-url: var(--shiny-spinner-url, url(spinners/ring.svg));--_shiny-spinner-color: var(--shiny-spinner-color, var(--bs-primary, #007bc2));--_shiny-spinner-size: var(--shiny-spinner-size, 32px);--_shiny-spinner-delay: var(--shiny-spinner-delay, 1s);background:var(--_shiny-spinner-color);width:var(--_shiny-spinner-size);height:var(--_shiny-spinner-size);inset:calc(50% - var(--_shiny-spinner-size) / 2);mask-image:var(--_shiny-spinner-url);-webkit-mask-image:var(--_shiny-spinner-url);opacity:0;animation-delay:var(--_shiny-spinner-delay);animation-name:fade-in;animation-duration:.25s;animation-fill-mode:forwards}[data-shiny-busy-spinners] .recalculating:has(>*),[data-shiny-busy-spinners] .recalculating:empty{opacity:1}[data-shiny-busy-spinners] .recalculating>*:not(.recalculating){opacity:var(--_shiny-fade-opacity);transition:opacity .25s ease var(--shiny-spinner-delay, 1s)}[data-shiny-busy-spinners] .recalculating.html-widget-output{visibility:inherit!important}[data-shiny-busy-spinners] .recalculating.html-widget-output>*{visibility:hidden}[data-shiny-busy-spinners] .recalculating.html-widget-output :after{visibility:visible}[data-shiny-busy-spinners] .recalculating.shiny-html-output:not(.shiny-table-output):after{display:none}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:after{--_shiny-pulse-background: var( --shiny-pulse-background, linear-gradient( 120deg, transparent, var(--bs-indigo, #4b00c1), var(--bs-purple, #74149c), var(--bs-pink, #bf007f), transparent ) );--_shiny-pulse-height: var(--shiny-pulse-height, 3px);--_shiny-pulse-speed: var(--shiny-pulse-speed, 1.2s);position:fixed;top:0;left:0;height:var(--_shiny-pulse-height);background:var(--_shiny-pulse-background);z-index:9999;animation-name:busy-page-pulse;animation-duration:var(--_shiny-pulse-speed);animation-direction:alternate;animation-iteration-count:infinite;animation-timing-function:ease-in-out;content:""}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:has(.recalculating:not(.shiny-html-output)):after{display:none}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:has(.recalculating.shiny-table-output):after{display:none}[data-shiny-busy-spinners][data-shiny-busy-pulse].shiny-busy:has(#shiny-disconnected-overlay):after{display:none}[data-shiny-busy-pulse]:not([data-shiny-busy-spinners]).shiny-busy:after{--_shiny-pulse-background: var( --shiny-pulse-background, linear-gradient( 120deg, transparent, var(--bs-indigo, #4b00c1), var(--bs-purple, #74149c), var(--bs-pink, #bf007f), transparent ) );--_shiny-pulse-height: var(--shiny-pulse-height, 3px);--_shiny-pulse-speed: var(--shiny-pulse-speed, 1.2s);position:fixed;top:0;left:0;height:var(--_shiny-pulse-height);background:var(--_shiny-pulse-background);z-index:9999;animation-name:busy-page-pulse;animation-duration:var(--_shiny-pulse-speed);animation-direction:alternate;animation-iteration-count:infinite;animation-timing-function:ease-in-out;content:""}[data-shiny-busy-pulse]:not([data-shiny-busy-spinners]).shiny-busy:has(#shiny-disconnected-overlay):after{display:none}@keyframes fade-in{0%{opacity:0}to{opacity:1}}@keyframes busy-page-pulse{0%{left:-14%;right:97%}45%{left:0%;right:14%}55%{left:14%;right:0%}to{left:97%;right:-14%}}.shiny-spinner-output-container{--shiny-spinner-size: 0px}

inst/www/shared/ionrangeslider/css/ion.rangeSlider.css

@@ -235,6 +235,10 @@
   z-index: 2;
 }
 
+.irs--shiny .irs-handle.type_last {
+  z-index: 3;
+}
+
 .irs--shiny .irs-handle.state_hover, .irs--shiny .irs-handle:hover {
   background: #fff;
 }

inst/www/shared/ionrangeslider/scss/shiny.scss

@@ -143,6 +143,11 @@ $font-family: $font-family-base !default;
     border-radius: $handle_width;
     z-index: 2;
 
+    &.type_last {
+      // Ensure last-used handle is on top if it overlaps with another handle
+      z-index: 3;
+    }
+
     &.state_hover,
     &:hover {
       background: $handle_color_hover;

inst/www/shared/selectize/accessibility/js/selectize-plugin-a11y.min.js

@@ -1 +1 @@
-Selectize.define("selectize-plugin-a11y",function(c){var t=this,l=13;typeof t.accessibility=="undefined"&&(t.accessibility={}),t.accessibility.helpers={randomId:function(e){for(var r="",s=e||10,i="abcdefghijklmnopqrstuvwxyz0123456789",n=i.length,a=0;a<s;a++)r+=i[Math.floor(n*Math.random())];return r}},t.accessibility.liveRegion={$region:"",speak:function(e){var r=$("<div></div>");r.text(e),this.$region.html(r)},domListener:function(){var e=new MutationObserver(function(r){r.forEach(function(s){var i=$(s.target);if(i.hasClass("items"))if(i.hasClass("dropdown-active")){t.$control_input.attr("aria-expanded","true");for(var n=t.$dropdown_content[0].children,a=0;a<n.length;a++){var o=n[a].attributes;o.role||n[a].setAttribute("role","option"),o.id||n[a].setAttribute("id",t.accessibility.helpers.randomId())}}else t.$control_input.attr("aria-expanded","false"),t.$control_input.removeAttr("aria-activedescendant");else i.hasClass("active")&&i.attr("data-value")&&(t.$control_input.attr("aria-activedescendant",i.attr("id")),t.accessibility.liveRegion.speak(i.text(),500))})});e.observe(t.$dropdown[0],{attributes:!0,attributeFilter:["class"],subtree:!0,attributeOldValue:!0}),e.observe(t.$control[0],{attributes:!0,attributeFilter:["class"]}),e.observe(t.$control_input[0],{attributes:!0,attributeFilter:["value"]})},setAttributes:function(){this.$region.attr({"aria-live":"assertive",role:"log","aria-relevant":"additions","aria-atomic":"true"})},setStyles:function(){this.$region.css({position:"absolute",width:"1px",height:"1px","margin-top":"-1px",clip:"rect(1px, 1px, 1px, 1px)",overflow:"hidden"})},init:function(){this.$region=$("<div>"),this.setAttributes(),this.setStyles(),$("body").append(this.$region),this.domListener()}},this.setup=function(){var e=t.setup;return function(){e.apply(this,arguments);var r=t.accessibility.helpers.randomId(),s=t.accessibility.helpers.randomId();t.$control.on("keydown",function(i){i.keyCode===l&&(t.settings.openOnFocus?(t.settings.openOnFocus=!1,t.focus(),setTimeout(function(){t.settings.openOnFocus=!0},0)):t.focus())}),t.$control_input.attr({role:"combobox","aria-expanded":"false",haspopup:"listbox","aria-owns":s,"aria-label":t.$wrapper.closest("[data-accessibility-selectize-label]").attr("data-accessibility-selectize-label")}),t.$dropdown_content.attr({role:"listbox",id:s}),t.accessibility.liveRegion.init()}}(),this.destroy=function(){var e=t.destroy;return function(){return t.accessibility.liveRegion.$region.remove(),e.apply(this,arguments)}}()});
+Selectize.define("selectize-plugin-a11y",function(c){var t=this,l=13;typeof t.accessibility>"u"&&(t.accessibility={}),t.accessibility.helpers={randomId:function(e){for(var r="",s=e||10,i="abcdefghijklmnopqrstuvwxyz0123456789",n=i.length,a=0;a<s;a++)r+=i[Math.floor(n*Math.random())];return r}},t.accessibility.liveRegion={$region:"",speak:function(e){var r=$("<div></div>");r.text(e),this.$region.html(r)},domListener:function(){var e=new MutationObserver(function(r){r.forEach(function(s){var i=$(s.target);if(i.hasClass("items"))if(i.hasClass("dropdown-active")){t.$control_input.attr("aria-expanded","true");for(var n=t.$dropdown_content[0].children,a=0;a<n.length;a++){var o=n[a].attributes;o.role||n[a].setAttribute("role","option"),o.id||n[a].setAttribute("id",t.accessibility.helpers.randomId())}}else t.$control_input.attr("aria-expanded","false"),t.$control_input.removeAttr("aria-activedescendant");else i.hasClass("active")&&i.attr("data-value")&&(t.$control_input.attr("aria-activedescendant",i.attr("id")),t.accessibility.liveRegion.speak(i.text(),500))})});e.observe(t.$dropdown[0],{attributes:!0,attributeFilter:["class"],subtree:!0,attributeOldValue:!0}),e.observe(t.$control[0],{attributes:!0,attributeFilter:["class"]}),e.observe(t.$control_input[0],{attributes:!0,attributeFilter:["value"]})},setAttributes:function(){this.$region.attr({"aria-live":"assertive",role:"log","aria-relevant":"additions","aria-atomic":"true"})},setStyles:function(){this.$region.css({position:"absolute",width:"1px",height:"1px","margin-top":"-1px",clip:"rect(1px, 1px, 1px, 1px)",overflow:"hidden"})},init:function(){this.$region=$("<div>"),this.setAttributes(),this.setStyles(),$("body").append(this.$region),this.domListener()}},this.setup=function(){var e=t.setup;return function(){e.apply(this,arguments);var r=t.accessibility.helpers.randomId(),s=t.accessibility.helpers.randomId();t.$control.on("keydown",function(i){i.keyCode===l&&(t.settings.openOnFocus?(t.settings.openOnFocus=!1,t.focus(),setTimeout(function(){t.settings.openOnFocus=!0},0)):t.focus())}),t.$control_input.attr({role:"combobox","aria-expanded":"false",haspopup:"listbox","aria-owns":s,"aria-label":t.$wrapper.closest("[data-accessibility-selectize-label]").attr("data-accessibility-selectize-label")}),t.$dropdown_content.attr({role:"listbox",id:s}),t.accessibility.liveRegion.init()}}(),this.destroy=function(){var e=t.destroy;return function(){return t.accessibility.liveRegion.$region.remove(),e.apply(this,arguments)}}()});

inst/www/shared/shiny-showcase.css

@@ -1,2 +1,2 @@
-/*! shiny 1.8.1.9001 | (c) 2012-2024 RStudio, PBC. | License: GPL-3 | file LICENSE */
+/*! shiny 1.10.0.9000 | (c) 2012-2025 Posit Software, PBC. | License: GPL-3 | file LICENSE */
 #showcase-well{border-radius:0}.shiny-code{background-color:#fff;margin-bottom:0}.shiny-code code{font-family:Menlo,Consolas,Courier New,monospace}.shiny-code-container{margin-top:20px;clear:both}.shiny-code-container h3{display:inline;margin-right:15px}.showcase-header{font-size:16px;font-weight:400}.showcase-code-link{text-align:right;padding:15px}#showcase-app-container{vertical-align:top}#showcase-code-tabs{margin-right:15px}#showcase-code-tabs pre{border:none;line-height:1em}#showcase-code-tabs .nav,#showcase-code-tabs ul{margin-bottom:0}#showcase-code-tabs .tab-content{border-style:solid;border-color:#e5e5e5;border-width:0px 1px 1px 1px;overflow:auto;border-bottom-right-radius:4px;border-bottom-left-radius:4px}#showcase-app-code{width:100%}#showcase-code-position-toggle{float:right}#showcase-sxs-code{padding-top:20px;vertical-align:top}.showcase-code-license{display:block;text-align:right}#showcase-code-content pre{background-color:#fff}

inst/www/shared/shiny-testmode.js

@@ -1,3 +1,3 @@
-/*! shiny 1.8.1.9001 | (c) 2012-2024 RStudio, PBC. | License: GPL-3 | file LICENSE */
-"use strict";(function(){var a=eval;window.addEventListener("message",function(i){var e=i.data;e.code&&a(e.code)});})();
+/*! shiny 1.10.0.9000 | (c) 2012-2025 Posit Software, PBC. | License: GPL-3 | file LICENSE */
+"use strict";(()=>{var t=eval;window.addEventListener("message",function(a){let e=a.data;e.code&&t(e.code)});})();
 //# sourceMappingURL=shiny-testmode.js.map

inst/www/shared/shiny-testmode.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../srcts/src/utils/eval.ts", "../../../srcts/extras/shiny-testmode.ts"],
-  "sourcesContent": ["//esbuild.github.io/content-types/#direct-eval\n//tl/dr;\n// * Direct usage of `eval(\"x\")` is bad with bundled code.\n// * Instead, use indirect calls to `eval` such as `indirectEval(\"x\")`\n//   * Even just renaming the function works well enough.\n// > This is known as \"indirect eval\" because eval is not being called directly, and so does not trigger the grammatical special case for direct eval in the JavaScript VM. You can call indirect eval using any syntax at all except for an expression of the exact form eval('x'). For example, var eval2 = eval; eval2('x') and [eval][0]('x') and window.eval('x') are all indirect eval calls.\n// > When you use indirect eval, the code is evaluated in the global scope instead of in the inline scope of the caller.\n\nvar indirectEval = eval;\nexport { indirectEval };", "/* eslint-disable unicorn/filename-case */\nimport { indirectEval } from \"../src/utils/eval\";\n\n// Listen for messages from parent frame. This file is only added when the\n// shiny.testmode option is TRUE.\nwindow.addEventListener(\"message\", function (e) {\n  var message = e.data;\n  if (message.code) indirectEval(message.code);\n});"],
-  "mappings": ";yBAQA,IAAIA,EAAe,KCHnB,OAAO,iBAAiB,UAAW,SAAUC,EAAG,CAC9C,IAAIC,EAAUD,EAAE,KACZC,EAAQ,MAAMC,EAAaD,EAAQ,IAAI,CAC7C,CAAC",
+  "sourcesContent": ["//esbuild.github.io/content-types/#direct-eval\n//tl/dr;\n// * Direct usage of `eval(\"x\")` is bad with bundled code.\n// * Instead, use indirect calls to `eval` such as `indirectEval(\"x\")`\n//   * Even just renaming the function works well enough.\n// > This is known as \"indirect eval\" because eval is not being called directly, and so does not trigger the grammatical special case for direct eval in the JavaScript VM. You can call indirect eval using any syntax at all except for an expression of the exact form eval('x'). For example, var eval2 = eval; eval2('x') and [eval][0]('x') and window.eval('x') are all indirect eval calls.\n// > When you use indirect eval, the code is evaluated in the global scope instead of in the inline scope of the caller.\n\nconst indirectEval = eval;\n\nexport { indirectEval };\n", "/* eslint-disable unicorn/filename-case */\nimport { indirectEval } from \"../src/utils/eval\";\n\n// Listen for messages from parent frame. This file is only added when the\n// shiny.testmode option is TRUE.\nwindow.addEventListener(\"message\", function (e: { data: { code: string } }) {\n  const message = e.data;\n\n  if (message.code) indirectEval(message.code);\n});\n"],
+  "mappings": ";mBAQA,IAAMA,EAAe,KCHrB,OAAO,iBAAiB,UAAW,SAAUC,EAA+B,CAC1E,IAAMC,EAAUD,EAAE,KAEdC,EAAQ,MAAMC,EAAaD,EAAQ,IAAI,CAC7C,CAAC",
   "names": ["indirectEval", "e", "message", "indirectEval"]
 }

inst/www/shared/shiny_scss/shiny.bootstrap5.scss

@@ -44,9 +44,9 @@ div:where(.shiny-html-output) {
   /* uiOutput()/ conditionalPanel() are "pass-through" containers when they have children. */
   &:has(> *) {
     display: contents;
-      /* Pass along styles that no longer impact the pass-through container */
+    /* Pass along styles that no longer impact the pass-through container */
     &.recalculating > * {
-      opacity: 0.3;
+      opacity: var(--_shiny-fade-opacity);
     }
   }
 }

inst/www/shared/shiny_scss/shiny.scss

@@ -156,7 +156,8 @@ html.autoreload-enabled #shiny-disconnected-overlay.reloading {
 }
 
 .recalculating {
-  opacity: 0.3;
+  --_shiny-fade-opacity: var(--shiny-fade-opacity, 0.3);
+  opacity: var(--_shiny-fade-opacity);
   transition: opacity 250ms ease 500ms;
 }
 
@@ -383,6 +384,14 @@ html.autoreload-enabled #shiny-disconnected-overlay.reloading {
   width: 100%;
 }
 
+/* Styling for inputTextArea(autoresize=TRUE) */
+.textarea-autoresize textarea.form-control {
+  padding: 5px 8px;
+  resize: none;
+  overflow-y: hidden;
+  height: auto;
+}
+
 
 #shiny-notification-panel {
   position: fixed;

man/ExtendedTask.Rd

@@ -45,6 +45,56 @@ is, a function that quickly returns a promise) and allows even that very
 session to immediately unblock and carry on with other user interactions.
 }
 
+\examples{
+\dontshow{if (rlang::is_interactive() && rlang::is_installed("future")) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
+
+library(shiny)
+library(bslib)
+library(future)
+plan(multisession)
+
+ui <- page_fluid(
+  titlePanel("Extended Task Demo"),
+  p(
+    'Click the button below to perform a "calculation"',
+    "that takes a while to perform."
+  ),
+  input_task_button("recalculate", "Recalculate"),
+  p(textOutput("result"))
+)
+
+server <- function(input, output) {
+  rand_task <- ExtendedTask$new(function() {
+    future(
+      {
+        # Slow operation goes here
+        Sys.sleep(2)
+        sample(1:100, 1)
+      },
+      seed = TRUE
+    )
+  })
+
+  # Make button state reflect task.
+  # If using R >=4.1, you can do this instead:
+  # rand_task <- ExtendedTask$new(...) |> bind_task_button("recalculate")
+  bind_task_button(rand_task, "recalculate")
+
+  observeEvent(input$recalculate, {
+    # Invoke the extended in an observer
+    rand_task$invoke()
+  })
+
+  output$result <- renderText({
+    # React to updated results when the task completes
+    number <- rand_task$result()
+    paste0("Your number is ", number, ".")
+  })
+}
+
+shinyApp(ui, server)
+\dontshow{\}) # examplesIf}
+}
 \section{Methods}{
 \subsection{Public methods}{
 \itemize{

man/bindCache.Rd

@@ -182,7 +182,7 @@ If you want to use a cache that is shared across multiple R processes, you
 can use a \code{\link[cachem:cache_disk]{cachem::cache_disk()}}. You can create a application-level shared
 cache by putting this at the top of your app.R, server.R, or global.R:
 
-\if{html}{\out{<div class="sourceCode">}}\preformatted{shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache"))
+\if{html}{\out{<div class="sourceCode">}}\preformatted{shinyOptions(cache = cachem::cache_disk(file.path(dirname(tempdir()), "myapp-cache")))
 }\if{html}{\out{</div>}}
 
 This will create a subdirectory in your system temp directory named

man/busyIndicatorOptions.Rd

@@ -11,6 +11,8 @@ busyIndicatorOptions(
   spinner_size = NULL,
   spinner_delay = NULL,
   spinner_selector = NULL,
+  fade_opacity = NULL,
+  fade_selector = NULL,
   pulse_background = NULL,
   pulse_height = NULL,
   pulse_speed = NULL
@@ -45,6 +47,13 @@ if the computation finishes quickly.}
 scoping the spinner customization. The default (\code{NULL}) will apply the
 spinner customization to the parent element of the spinner.}
 
+\item{fade_opacity}{The opacity (a number between 0 and 1) for recalculating
+output. Set to 1 to "disable" the fade.}
+
+\item{fade_selector}{A character string containing a CSS selector for
+scoping the spinner customization. The default (\code{NULL}) will apply the
+spinner customization to the parent element of the spinner.}
+
 \item{pulse_background}{A CSS background definition for the pulse. The
 default uses a
 \href{https://developer.mozilla.org/en-US/docs/Web/CSS/gradient/linear-gradient}{linear-gradient}
@@ -57,11 +66,21 @@ CSS size.}
 time.}
 }
 \description{
-When busy indicators are enabled (see \code{\link[=useBusyIndicators]{useBusyIndicators()}}), a spinner is
-shown on each calculating/recalculating output, and a pulsing banner is shown
-at the top of the page when the app is otherwise busy. This function allows
-you to customize the appearance of those busy indicators. To apply the
-customization, include the result of this function inside the app's UI.
+Shiny automatically includes busy indicators, which more specifically means:
+\enumerate{
+\item Calculating/recalculating outputs have a spinner overlay.
+\item Outputs fade out/in when recalculating.
+\item When no outputs are calculating/recalculating, but Shiny is busy
+doing something else (e.g., a download, side-effect, etc), a page-level
+pulsing banner is shown.
+}
+
+This function allows you to customize the appearance of these busy indicators
+by including the result of this function inside the app's UI. Note that,
+unless \code{spinner_selector} (or \code{fade_selector}) is specified, the spinner/fade
+customization applies to the parent element. If the customization should
+instead apply to the entire page, set \code{spinner_selector = 'html'} and
+\code{fade_selector = 'html'}.
 }
 \examples{
 \dontshow{if (rlang::is_interactive()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
@@ -113,5 +132,5 @@ shinyApp(ui, server)
 \dontshow{\}) # examplesIf}
 }
 \seealso{
-\code{\link[=useBusyIndicators]{useBusyIndicators()}} for enabling/disabling busy indicators.
+\code{\link[=useBusyIndicators]{useBusyIndicators()}} to disable/enable busy indicators.
 }

man/createRenderFunction.Rd

@@ -72,8 +72,8 @@ example, some render functions call \code{\link[=createWebDependency]{createWebD
 is able to serve JS and CSS resources.}
 
 \item{q}{Quosure of the expression \code{x}. When capturing expressions to create
-your quosure, it is recommended to use \code{\link[=enquo0]{enquo0()}} to not unquote the
-object too early. See \code{\link[=enquo0]{enquo0()}} for more details.}
+your quosure, it is recommended to use \code{\link[rlang:defusing-advanced]{rlang::enquo0()}} to not unquote
+the object too early. See \code{\link[rlang:defusing-advanced]{rlang::enquo0()}} for more details.}
 
 \item{label}{A label for the object to be shown in the debugger. Defaults to
 the name of the calling function.}

man/downloadHandler.Rd

@@ -60,4 +60,14 @@ server <- function(input, output) {
 
 shinyApp(ui, server)
 }
+
+}
+\seealso{
+\itemize{
+\item The download handler, like other outputs, is suspended (disabled) by
+default for download buttons and links that are hidden. Use
+\code{\link[=outputOptions]{outputOptions()}} to control this behavior, e.g. to set
+\code{suspendWhenHidden = FALSE} if the download is initiated by
+programmatically clicking on the download button using JavaScript.
+}
 }

man/numericInput.Rd

@@ -11,7 +11,9 @@ numericInput(
   min = NA,
   max = NA,
   step = NA,
-  width = NULL
+  width = NULL,
+  ...,
+  updateOn = c("change", "blur")
 )
 }
 \arguments{
@@ -29,6 +31,16 @@ numericInput(
 
 \item{width}{The width of the input, e.g. \code{'400px'}, or \code{'100\%'};
 see \code{\link[=validateCssUnit]{validateCssUnit()}}.}
+
+\item{...}{Ignored, included to require named arguments and for future
+feature expansion.}
+
+\item{updateOn}{A character vector specifying when the input should be
+updated. Options are \code{"change"} (default) and \code{"blur"}. Use \code{"change"} to
+update the input immediately whenever the value changes. Use \code{"blur"}to
+delay the input update until the input loses focus (the user moves away
+from the input), or when Enter is pressed (or Cmd/Ctrl + Enter for
+\code{\link[=textAreaInput]{textAreaInput()}}).}
 }
 \value{
 A numeric input control that can be added to a UI definition.

man/passwordInput.Rd

@@ -4,7 +4,15 @@
 \alias{passwordInput}
 \title{Create a password input control}
 \usage{
-passwordInput(inputId, label, value = "", width = NULL, placeholder = NULL)
+passwordInput(
+  inputId,
+  label,
+  value = "",
+  width = NULL,
+  placeholder = NULL,
+  ...,
+  updateOn = c("change", "blur")
+)
 }
 \arguments{
 \item{inputId}{The \code{input} slot that will be used to access the value.}
@@ -19,6 +27,16 @@ see \code{\link[=validateCssUnit]{validateCssUnit()}}.}
 \item{placeholder}{A character string giving the user a hint as to what can
 be entered into the control. Internet Explorer 8 and 9 do not support this
 option.}
+
+\item{...}{Ignored, included to require named arguments and for future
+feature expansion.}
+
+\item{updateOn}{A character vector specifying when the input should be
+updated. Options are \code{"change"} (default) and \code{"blur"}. Use \code{"change"} to
+update the input immediately whenever the value changes. Use \code{"blur"}to
+delay the input update until the input loses focus (the user moves away
+from the input), or when Enter is pressed (or Cmd/Ctrl + Enter for
+\code{\link[=textAreaInput]{textAreaInput()}}).}
 }
 \value{
 A text input control that can be added to a UI definition.

man/reactive.Rd

@@ -18,7 +18,10 @@ reactive(
 is.reactive(x)
 }
 \arguments{
-\item{x}{For \code{is.reactive()}, an object to test. For \code{reactive()}, an expression. When passing in a \code{\link[=quo]{quo()}}sure with \code{reactive()}, remember to use \code{\link[rlang:inject]{rlang::inject()}} to distinguish that you are passing in the content of your quosure, not the expression of the quosure.}
+\item{x}{For \code{is.reactive()}, an object to test. For \code{reactive()}, an
+expression. When passing in a \code{\link[rlang:defusing-advanced]{rlang::quo()}}sure with \code{reactive()},
+remember to use \code{\link[rlang:inject]{rlang::inject()}} to distinguish that you are passing in
+the content of your quosure, not the expression of the quosure.}
 
 \item{env}{The parent environment for the reactive expression. By default,
 this is the calling environment, the same as when defining an ordinary

man/reactlog.Rd

@@ -4,6 +4,7 @@
 \alias{reactlog}
 \alias{reactlogShow}
 \alias{reactlogReset}
+\alias{reactlogAddMark}
 \title{Reactive Log Visualizer}
 \usage{
 reactlog()
@@ -11,10 +12,15 @@ reactlog()
 reactlogShow(time = TRUE)
 
 reactlogReset()
+
+reactlogAddMark(session = getDefaultReactiveDomain())
 }
 \arguments{
 \item{time}{A boolean that specifies whether or not to display the
 time that each reactive takes to calculate a result.}
+
+\item{session}{The Shiny session to assign the mark to. Defaults to the
+current session.}
 }
 \description{
 Provides an interactive browser-based tool for visualizing reactive
@@ -22,7 +28,7 @@ dependencies and execution in your application.
 }
 \details{
 To use the reactive log visualizer, start with a fresh R session and
-run the command \code{options(shiny.reactlog=TRUE)}; then launch your
+run the command \code{reactlog::reactlog_enable()}; then launch your
 application in the usual way (e.g. using \code{\link[=runApp]{runApp()}}). At
 any time you can hit Ctrl+F3 (or for Mac users, Command+F3) in your
 web browser to launch the reactive log visualization.
@@ -45,17 +51,37 @@ browser will not load new activity into the report; you will need to
 call \code{reactlogShow()} explicitly.
 
 For security and performance reasons, do not enable
-\code{shiny.reactlog} in production environments. When the option is
-enabled, it's possible for any user of your app to see at least some
-of the source code of your reactive expressions and observers.
+\code{options(shiny.reactlog=TRUE)} (or \code{reactlog::reactlog_enable()}) in
+production environments. When the option is enabled, it's possible
+for any user of your app to see at least some of the source code of
+your reactive expressions and observers. In addition, reactlog
+should be considered a memory leak as it will constantly grow and
+will never reset until the R session is restarted.
 }
 \section{Functions}{
 \itemize{
-\item \code{reactlog()}: Return a list of reactive information.  Can be used in conjunction with
-\link[reactlog:reactlog_show]{reactlog::reactlog_show} to later display the reactlog graph.
+\item \code{reactlog()}: Return a list of reactive information.  Can be used in
+conjunction with \link[reactlog:reactlog_show]{reactlog::reactlog_show} to later display the reactlog
+graph.
 
 \item \code{reactlogShow()}: Display a full reactlog graph for all sessions.
 
-\item \code{reactlogReset()}: Resets the entire reactlog stack.  Useful for debugging and removing all prior reactive history.
+\item \code{reactlogReset()}: Resets the entire reactlog stack.  Useful for debugging
+and removing all prior reactive history.
+
+\item \code{reactlogAddMark()}: Adds "mark" entry into the reactlog stack. This is
+useful for programmatically adding a marked entry in the reactlog, rather
+than using your keyboard's key combination.
+
+For example, we can \emph{mark} the reactlog at the beginning of an
+\code{observeEvent}'s calculation:
+
+\if{html}{\out{<div class="sourceCode r">}}\preformatted{observeEvent(input$my_event_trigger, \{
+  # Add a mark in the reactlog
+  reactlogAddMark()
+  # Run your regular event reaction code here...
+  ....
+\})
+}\if{html}{\out{</div>}}
 
 }}

man/registerThemeDependency.Rd

@@ -12,9 +12,10 @@ registerThemeDependency(func)
 of them.}
 }
 \description{
-This function registers a function that returns an \code{\link[=htmlDependency]{htmlDependency()}} or list
-of such objects. If \code{session$setCurrentTheme()} is called, the function will
-be re-executed, and the resulting html dependency will be sent to the client.
+This function registers a function that returns an
+\code{\link[htmltools:htmlDependency]{htmltools::htmlDependency()}} or list of such objects. If
+\code{session$setCurrentTheme()} is called, the function will be re-executed, and
+the resulting html dependency will be sent to the client.
 }
 \details{
 Note that \code{func} should \strong{not} be an anonymous function, or a function which

man/renderImage.Rd

@@ -125,6 +125,9 @@ shinyApp(ui, server)
 }
 }
 \seealso{
-For more details on how the images are generated, and how to control
+\itemize{
+\item For more details on how the images are generated, and how to control
 the output, see \code{\link[=plotPNG]{plotPNG()}}.
+\item Use \code{\link[=outputOptions]{outputOptions()}} to set general output options for an image output.
+}
 }

man/renderPrint.Rd

@@ -126,3 +126,6 @@ vecFun()
 
 })
 }
+\seealso{
+\code{\link[=outputOptions]{outputOptions()}}
+}

man/renderUI.Rd

@@ -52,5 +52,5 @@ shinyApp(ui, server)
 
 }
 \seealso{
-\code{\link[=uiOutput]{uiOutput()}}
+\code{\link[=uiOutput]{uiOutput()}}, \code{\link[=outputOptions]{outputOptions()}}
 }

man/runExample.Rd

@@ -33,7 +33,9 @@ interactive sessions only.}
 to the \code{shiny.host} option, if set, or \code{"127.0.0.1"} if not.}
 
 \item{display.mode}{The mode in which to display the example. Defaults to
-\code{showcase}, but may be set to \code{normal} to see the example without
+\code{"auto"}, which uses the value of \code{DisplayMode} in the example's
+\code{DESCRIPTION} file. Set to \code{"showcase"} to show the app code and
+description with the running app, or \code{"normal"} to see the example without
 code or commentary.}
 
 \item{package}{The package in which to find the example (defaults to

man/shinyOptions.Rd

@@ -44,16 +44,20 @@ have the extensions: r, htm, html, js, css, png, jpg, jpeg, gif. If any
 changes are detected, all connected Shiny sessions are reloaded. This
 allows for fast feedback loops when tweaking Shiny UI.
 
-Since monitoring for changes is expensive (we simply poll for last
-modified times), this feature is intended only for development.
+Monitoring for changes is no longer expensive, thanks to the \pkg{watcher}
+package, 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:
-\code{options(shiny.autoreload.pattern = glob2rx("ui.R"))}
+shiny.autoreload.pattern option. For example, to monitor only \code{ui.R}:
+\code{options(shiny.autoreload.pattern = glob2rx("ui.R"))}.
 
-The default polling interval is 500 milliseconds. You can change this
-by setting e.g. \code{options(shiny.autoreload.interval = 2000)} (every
-two seconds).}
+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
+\code{options(shiny.autoreload.interval = 2000)} (in milliseconds). This value
+converted to seconds and passed to the \code{latency} argument of
+\code{\link[watcher:watcher]{watcher::watcher()}}. The default latency is 250ms.}
 \item{shiny.deprecation.messages (defaults to \code{TRUE})}{This controls whether messages for
 deprecated functions in Shiny will be printed. See
 \code{\link[=shinyDeprecated]{shinyDeprecated()}} for more information.}

man/textAreaInput.Rd

@@ -13,7 +13,10 @@ textAreaInput(
   cols = NULL,
   rows = NULL,
   placeholder = NULL,
-  resize = NULL
+  resize = NULL,
+  ...,
+  autoresize = FALSE,
+  updateOn = c("change", "blur")
 )
 }
 \arguments{
@@ -46,6 +49,19 @@ option.}
 \item{resize}{Which directions the textarea box can be resized. Can be one of
 \code{"both"}, \code{"none"}, \code{"vertical"}, and \code{"horizontal"}. The default, \code{NULL},
 will use the client browser's default setting for resizing textareas.}
+
+\item{...}{Ignored, included to require named arguments and for future
+feature expansion.}
+
+\item{autoresize}{If \code{TRUE}, the textarea will automatically resize to fit
+the input text.}
+
+\item{updateOn}{A character vector specifying when the input should be
+updated. Options are \code{"change"} (default) and \code{"blur"}. Use \code{"change"} to
+update the input immediately whenever the value changes. Use \code{"blur"}to
+delay the input update until the input loses focus (the user moves away
+from the input), or when Enter is pressed (or Cmd/Ctrl + Enter for
+\code{\link[=textAreaInput]{textAreaInput()}}).}
 }
 \value{
 A textarea input control that can be added to a UI definition.

man/textInput.Rd

@@ -4,7 +4,15 @@
 \alias{textInput}
 \title{Create a text input control}
 \usage{
-textInput(inputId, label, value = "", width = NULL, placeholder = NULL)
+textInput(
+  inputId,
+  label,
+  value = "",
+  width = NULL,
+  placeholder = NULL,
+  ...,
+  updateOn = c("change", "blur")
+)
 }
 \arguments{
 \item{inputId}{The \code{input} slot that will be used to access the value.}
@@ -19,6 +27,16 @@ see \code{\link[=validateCssUnit]{validateCssUnit()}}.}
 \item{placeholder}{A character string giving the user a hint as to what can
 be entered into the control. Internet Explorer 8 and 9 do not support this
 option.}
+
+\item{...}{Ignored, included to require named arguments and for future
+feature expansion.}
+
+\item{updateOn}{A character vector specifying when the input should be
+updated. Options are \code{"change"} (default) and \code{"blur"}. Use \code{"change"} to
+update the input immediately whenever the value changes. Use \code{"blur"}to
+delay the input update until the input loses focus (the user moves away
+from the input), or when Enter is pressed (or Cmd/Ctrl + Enter for
+\code{\link[=textAreaInput]{textAreaInput()}}).}
 }
 \value{
 A text input control that can be added to a UI definition.

man/useBusyIndicators.Rd

@@ -4,7 +4,7 @@
 \alias{useBusyIndicators}
 \title{Enable/disable busy indication}
 \usage{
-useBusyIndicators(..., spinners = TRUE, pulse = TRUE)
+useBusyIndicators(..., spinners = TRUE, pulse = TRUE, fade = TRUE)
 }
 \arguments{
 \item{...}{Currently ignored.}
@@ -14,6 +14,9 @@ output.}
 
 \item{pulse}{Whether to show a pulsing banner at the top of the page when the
 app is busy.}
+
+\item{fade}{Whether to fade recalculating outputs. A value of \code{FALSE} is
+equivalent to \code{busyIndicatorOptions(fade_opacity=1)}.}
 }
 \description{
 Busy indicators provide a visual cue to users when the server is busy

package.json

@@ -3,7 +3,7 @@
   "homepage": "https://shiny.rstudio.com",
   "repository": "github:rstudio/shiny",
   "name": "@types/rstudio-shiny",
-  "version": "1.8.1-alpha.9001",
+  "version": "1.10.0-alpha.9000",
   "license": "GPL-3.0-only",
   "main": "",
   "browser": "",
@@ -28,11 +28,6 @@
     "lit": "^3.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.14.3",
-    "@babel/plugin-proposal-class-properties": "^7.13.0",
-    "@babel/preset-env": "^7.14.2",
-    "@babel/preset-typescript": "^7.13.0",
-    "@babel/runtime": "^7.14.0",
     "@deanc/esbuild-plugin-postcss": "^1.0.2",
     "@selectize/selectize": "https://github.com/selectize/selectize.js.git#e3f2e0b4aa251375bc21b5fcd8ca7d374a921f08",
     "@testing-library/dom": "^7.31.0",
@@ -51,7 +46,6 @@
     "caniuse-lite": "^1.0.30001312",
     "core-js": "^3.13.0",
     "esbuild": "^0.15.10",
-    "esbuild-plugin-babel": "https://github.com/schloerke/esbuild-plugin-babel#patch-2",
     "esbuild-plugin-globals": "^0.1.1",
     "esbuild-plugin-sass": "^1.0.1",
     "eslint": "^8.24.0",

revdep/README.md

@@ -1,25 +1,34 @@
 # Revdeps
 
-## Failed to check (18)
+## Failed to check (20)
 
 |package            |version |error |warning |note |
 |:------------------|:-------|:-----|:-------|:----|
-|bigPint            |?       |      |        |     |
-|bioCancer          |?       |      |        |     |
-|ctsem              |3.9.1   |1     |        |     |
+|animalEKF          |1.2     |1     |        |     |
+|AovBay             |0.1.0   |1     |        |     |
+|Certara.VPCResults |3.0.2   |1     |        |     |
+|chipPCR            |1.0-2   |1     |        |     |
+|ctsem              |3.10.1  |1     |        |     |
+|dartR.sim          |?       |      |        |     |
 |diveR              |?       |      |        |     |
-|EBImage            |?       |      |        |     |
-|g3viz              |?       |      |        |     |
-|GeneNetworkBuilder |?       |      |        |     |
-|grandR             |?       |      |        |     |
-|InterCellar        |?       |      |        |     |
-|LACE               |?       |      |        |     |
+|gap                |?       |      |        |     |
+|jsmodule           |?       |      |        |     |
 |loon.shiny         |?       |      |        |     |
-|MatrixQCvis        |?       |      |        |     |
-|modchart           |?       |      |        |     |
-|multilevelcoda     |1.2.3   |1     |        |     |
-|omicsViewer        |?       |      |        |     |
-|RQuantLib          |0.4.21  |1     |        |     |
+|robmedExtra        |0.1.1   |1     |        |     |
 |rstanarm           |2.32.1  |1     |        |     |
-|Seurat             |?       |      |        |     |
+|SensMap            |0.7     |1     |        |     |
+|Seurat             |5.1.0   |1     |        |1    |
+|shinyTempSignal    |0.0.8   |1     |        |     |
+|Signac             |1.14.0  |1     |        |     |
+|statsr             |0.3.0   |1     |        |     |
+|TestAnaAPP         |1.1.2   |1     |        |     |
+|tidyvpc            |1.5.2   |1     |        |     |
+|visR               |?       |      |        |     |
+
+## New problems (2)
+
+|package |version |error |warning |note   |
+|:-------|:-------|:-----|:-------|:------|
+|[HH](problems.md#hh)|3.1-52  |      |        |__+1__ |
+|[PopED](problems.md#poped)|0.7.0   |      |        |__+1__ |
 

revdep/cran.md

@@ -1,19 +1,39 @@
 ## revdepcheck results
 
-We checked 1201 reverse dependencies (1191 from CRAN + 10 from Bioconductor), comparing R CMD check results across CRAN and dev versions of this package.
+We checked 1278 reverse dependencies (1277 from CRAN + 1 from Bioconductor), comparing R CMD check results across CRAN and dev versions of this package.
 
- * We saw 0 new problems
- * We failed to check 8 packages
+ * We saw 2 new problems
+ * We failed to check 19 packages
 
 Issues with CRAN packages are summarised below.
 
+### New problems
+(This reports the first line of each new failure)
+
+* HH
+  checking installed package size ... NOTE
+
+* PopED
+  checking installed package size ... NOTE
+
 ### Failed to check
 
-* ctsem          (NA)
-* diveR          (NA)
-* grandR         (NA)
-* loon.shiny     (NA)
-* multilevelcoda (NA)
-* RQuantLib      (NA)
-* rstanarm       (NA)
-* Seurat         (NA)
+* animalEKF          (NA)
+* AovBay             (NA)
+* Certara.VPCResults (NA)
+* chipPCR            (NA)
+* ctsem              (NA)
+* dartR.sim          (NA)
+* diveR              (NA)
+* gap                (NA)
+* jsmodule           (NA)
+* loon.shiny         (NA)
+* robmedExtra        (NA)
+* rstanarm           (NA)
+* SensMap            (NA)
+* Seurat             (NA)
+* shinyTempSignal    (NA)
+* Signac             (NA)
+* statsr             (NA)
+* TestAnaAPP         (NA)
+* tidyvpc            (NA)

revdep/problems.md

@@ -1 +1,49 @@
-*Wow, no problems at all. :)*
+# HH
+
+<details>
+
+* Version: 3.1-52
+* GitHub: NA
+* Source code: https://github.com/cran/HH
+* Date/Publication: 2024-02-11 00:00:02 UTC
+* Number of recursive dependencies: 165
+
+Run `revdepcheck::cloud_details(, "HH")` for more info
+
+</details>
+
+## Newly broken
+
+*   checking installed package size ... NOTE
+    ```
+      installed size is  5.1Mb
+      sub-directories of 1Mb or more:
+        R      1.5Mb
+        help   1.5Mb
+    ```
+
+# PopED
+
+<details>
+
+* Version: 0.7.0
+* GitHub: https://github.com/andrewhooker/PopED
+* Source code: https://github.com/cran/PopED
+* Date/Publication: 2024-10-07 19:30:02 UTC
+* Number of recursive dependencies: 140
+
+Run `revdepcheck::cloud_details(, "PopED")` for more info
+
+</details>
+
+## Newly broken
+
+*   checking installed package size ... NOTE
+    ```
+      installed size is  5.5Mb
+      sub-directories of 1Mb or more:
+        R      1.5Mb
+        doc    1.4Mb
+        test   1.1Mb
+    ```
+

srcts/README.md

@@ -150,12 +150,6 @@ All config files are located in the root folder to avoid opening two separate VS
   * Used by `prettier` to know how to adjust code when a file is saved in VSCode or within `eslint`'s linting process.
 * `yarnrc.yml`
   * Notifies `yarn` to use `yarn` v2, install `./node_modules` folder for `esbuild`, and any CLI plugins.
-* `babel.config.json`
-  * Used within `babel` transpilation of TypeScript -> JavaScript -> polyfilled JavaScript.
-  * Noteable options set:
-    * `"useBuiltIns": "usage"` - `core-js` polyfills are only added as they are _used_.
-    * `"corejs": "3.9"` - This number should match the installed `core-js` number.
-    * `"ignore":["node_modules/core-js"]` - The `core-js` library is directly ignored to [avoid being processed by `babel`](https://github.com/zloirock/core-js/issues/743#issuecomment-571983318).
 * `jest.config.js`
   * Used to configure [`jest` testing](https://jestjs.io/)
 * `package.json`
@@ -168,7 +162,7 @@ All config files are located in the root folder to avoid opening two separate VS
 * `tsconfig.json` -
   * TypeScript config file
   * Notable options set:
-    * `target: ES5` - Compile to es5, so babel has an easier job.
+    * `target: ES2021` - Compile to es2021.
     * `preserveConstEnums: false` - Do no preserve enum values into the final code. (If true, produces bloat / unused code)
     * `isolatedModules: true` & `esModuleInterop: true` - Requested by `esbuild`. This [allows for `esbuild`](https://esbuild.github.io/content-types/#typescript) to safely compile the files in parallel
 

srcts/TODO.md

@@ -1,108 +0,0 @@
-# Development Rules
-* Put Imports at top
-* Put Exports at bottom
-* File / Folder structure
-  * Lean towards using more many files / folder vs larger files
-  * Nest folders inside larger _ideas_
-  * Each folder should generally have an `**/index.ts` to export most everything for the folder
-    * Exception: `./src/window` folder. Must call methods directly.
-* Any `window.***` calls are done in `./src/window` folder only.
-  * Add exported values / function if necessary.
-  * This helps keep each file self contained. Trying not to have random inputs from anywhere
-* jQuery
-  * Always import `./src/jquery` instead of `"jquery"`
-    * Exeption: Test files. There, you can import `"jquery"` directly as the browser is not available to already have jQuery loaded.
-  * Prevents from installing local jquery in addition to global jquery
-    * WAY to many packages exist on the assumption that jquery is available at run time. Therefore, it can not be removed globally. :-(
-* Anything that needs to be initialized on start **must** exist in the `./src/initialize` folder.
-  * No file should produce any side effects.
-  * To capture initializations, export a `setFoo(foo_)` method that updates a locally defined `foo` variable.
-
-
-# TODO
-
-* √ Move everything into a single ts file. This will allow for the functions to find themselves
-  * √ Except the utils.js already converted
-* √ es6 shiny.js
-  * √ Pass in version using esbuild
-  * √ Move all shiny files in order to main.ts
-  * √ validate polyfills are working by finding them in the code
-* √ Produce minified shiny js
-* √ Disable $ from being found without an import
-  * √ Using a patch with yarn v2
-* √ Document `./package.json` scripts
-* √ Verify that `babel` is configurable
-  * √ Use targeting browsers
-  * √ Verify it works on phantomjs / shinytest
-* √ Set up initial jest tests
-* √ Use a global shim to avoid importing jquery directly, but make testing easy to test
-* Update the /tools/update*.R scripts to produce a version and install node dependencies
-  * √ jquery
-  * √ ion range slider
-  * √ selectize
-  * √ strftime
-  * √ bootstrap date picker
-  * font awesome?
-  * bootstrap accessibility plugin?
-
-# Round #2
-* Convert registered bindings
-  * √ Input bindings
-  * √ Output bindings
-* Add default value to `subscribe(callback)` callback function of `false`. B/c if the value was not provided, it was not truthy, therefore equivalent to `false`.
-  * √ radio
-  * √ checkboxgroup
-  * √ daterange
-  * √ actionbutton
-  * √ bootstraptabinput
-* √ snake_case to camelCase conversions.
-* √ globally import strftime from `window.strftime`
-* Remove `evt` from jQuery.on callbacks where `evt` was not used.
-  * √ checkbox.subscribe
-  * √ checkboxgroup.subscribe
-  * √ radio.subscribe
-  * √ slider.subscribe
-  * √ date.subscribe
-  * √ selectInput.subscribe
-  * √ actionButton.subscribe
-  * √ bootstraptabinput.subscribe
-* Convert usage of `+x` to `Number(x)`
-  * https://stackoverflow.com/a/15872631/591574
-  * √ slider.getValue()
-  * √ number.getValue()
-* √ Adjust tabinput.ts `setValue()` to return either `false | void`, not `false | true`.
-  * What matters is that `false` is returned, or nothing is returned. Replaced `return true;` with `return;`
-* Questions
-  * Why does `receiveMessage(data)` sometimes have a `label`?
-  * Should we have a update datatables script?
-
-
-# Later TODO
-
-* Use --strictNullChecks in tsconfig.json
-
-* Make `_*()` methods `private *()`
-* √ Each _file_ will be pulled out as possible into smaller files in separate PRs
-* √ Convert `FileProcessor` to a true class definition
-* Break up `./utils` into many files
-  * √ Remove any `: any` types
-* √ Make `@typescript-eslint/explicit-module-boundary-types` an error
-* √ Fix all `// eslint-disable-next-line no-prototype-builtins` lines
-* TypeScript other shiny files (ex: showcasemode)
-* √ Completely remove `parcel` from `./package.json` and only use `esbuild`
-* √ Delete 'shiny-es5' files
-* Delete 'old' folder
-* _Uglify_ js files (like in previous Gruntfile.js)
-  * datepicker
-  * ionrangeslider
-  * selectize
-
-
-
-# Eventual TODO
-* Use yarn PnP
-  * See `./patch/yarn_pnp.patch`
-  * Use [esbuild](https://github.com/yarnpkg/berry/tree/master/packages/esbuild-plugin-pnp#yarnpkgesbuild-plugin-pnp)
-  * Known problems:
-    * `@yarnpkg/esbuild-plugin-pnp@0.0.1` gives full file paths, not relative file paths
-    * `@testing-library/jest-dom/extend-expect` can not be found.

srcts/build/_build.ts

@@ -7,17 +7,13 @@ import type {
 } from "esbuild";
 import { build as esbuildBuild } from "esbuild";
 
-import process from "process";
 import { basename } from "path";
+import process from "process";
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore; Type definitions are not found. This occurs when `strict: true` in tsconfig.json
 import readcontrol from "readcontrol";
 
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore; Type definitions are not found. This occurs when `strict: true` in tsconfig.json
-import babelPlugin from "esbuild-plugin-babel";
-
 const outDir = "./inst/www/shared/";
 
 type ShinyDesc = { version: string; package: string; license: string };
@@ -25,7 +21,7 @@ const shinyDesc = readcontrol.readSync("./DESCRIPTION") as ShinyDesc;
 
 const bannerTxt = [
   `/*! ${shinyDesc.package} ${shinyDesc.version}`,
-  `(c) 2012-${new Date().getFullYear()} RStudio, PBC.`,
+  `(c) 2012-${new Date().getFullYear()} Posit Software, PBC.`,
   `License: ${shinyDesc.license} */`,
 ].join(" | ");
 const banner = {
@@ -79,7 +75,7 @@ async function build(
   return esbuildBuild({
     incremental: incremental,
     watch: watch,
-    target: "es5",
+    target: "es2021",
     preserveSymlinks: true,
     ...opts,
   }).then((x) => {
@@ -88,4 +84,4 @@ async function build(
   });
 }
 
-export { outDir, build, shinyDesc, banner, babelPlugin };
+export { outDir, build, shinyDesc, banner };

srcts/build/extras.ts

@@ -5,13 +5,13 @@
 
 // - TypeScript -----------------------------------------------------------
 
-import { banner, build, outDir, babelPlugin } from "./_build";
+import { banner, build, outDir } from "./_build";
 
 build({
   bundle: true,
   sourcemap: true,
   minify: true,
-  plugins: [babelPlugin()],
+  plugins: [],
   banner: banner,
   entryPoints: [
     "srcts/extras/shiny-autoreload.ts",

srcts/build/shiny.ts

@@ -3,9 +3,9 @@
 // yarn build
 // ```
 
-import { banner, build, outDir, shinyDesc, babelPlugin } from "./_build";
-import globalsPlugin from "esbuild-plugin-globals";
 import type { BuildOptions } from "esbuild";
+import globalsPlugin from "esbuild-plugin-globals";
+import { banner, build, outDir, shinyDesc } from "./_build";
 import { verifyJqueryImport } from "./_jquery";
 
 const opts: BuildOptions = {
@@ -18,7 +18,6 @@ const opts: BuildOptions = {
       //// Loaded dynamically. MUST use `window.strftime` within code
       // strftime: "window.strftime",
     }),
-    babelPlugin(),
   ],
   define: {
     // eslint-disable-next-line @typescript-eslint/naming-convention

srcts/extras/busy-indicators/busy-indicators.scss

@@ -7,6 +7,8 @@
 
   .recalculating {
 
+    min-height: var(--shiny-spinner-size, 32px);
+
     &::after {
       position: absolute;
       content: "";
@@ -29,6 +31,7 @@
       animation-delay: var(--_shiny-spinner-delay);
       animation-name: fade-in;
       animation-duration: 250ms;
+      animation-fill-mode: forwards;
     }
 
     /*
@@ -36,19 +39,39 @@
       the spinner. Undo that, but still apply (smaller) opacity to immediate children
       that aren't recalculating.
     */
-    opacity: 1;
+    &:has(> *), &:empty {
+      opacity: 1;
+    }
     > *:not(.recalculating) {
-      opacity: 0.2;
+      opacity: var(--_shiny-fade-opacity);
       transition: opacity 250ms ease var(--shiny-spinner-delay, 1s);
     }
 
+    /*
+      When htmlwidget errors are rendered, an inline `visibility:hidden` is put
+      on the html-widget-output, and the error message (if any) is put in a
+      sibling element that overlays the output container (this way, the height
+      of the output container doesn't change). Work around this by making the
+      output container itself visible and making the children (except the
+      spinner) invisible.
+    */
+    &.html-widget-output {
+      visibility: inherit !important;
+      > * {
+        visibility: hidden;
+      }
+      ::after {
+        visibility: visible;
+      }
+    }
+
     /*
       Disable spinner on uiOutput() mainly because (for other reasons) it has
       `display:contents`, which breaks the ::after positioning.
       Note that, even if we could position it, we'd probably want to disable it
       if it has recalculating children.
     */
-    &.shiny-html-output::after {
+    &.shiny-html-output:not(.shiny-table-output)::after {
       display: none;
     }
   }
@@ -61,15 +84,15 @@
     --shiny-pulse-background,
     linear-gradient(
       120deg,
-      var(--bs-body-bg, #fff),
+      transparent,
       var(--bs-indigo, #4b00c1),
       var(--bs-purple, #74149c),
       var(--bs-pink, #bf007f),
-      var(--bs-body-bg, #fff)
+      transparent
     )
   );
-  --_shiny-pulse-height: var(--shiny-pulse-height, 5px);
-  --_shiny-pulse-speed: var(--shiny-pulse-speed, 1.85s);
+  --_shiny-pulse-height: var(--shiny-pulse-height, 3px);
+  --_shiny-pulse-speed: var(--shiny-pulse-speed, 1.2s);
 
   /* Color, sizing, & positioning */
   position: fixed;
@@ -82,6 +105,7 @@
   /* Animation */
   animation-name: busy-page-pulse;
   animation-duration: var(--_shiny-pulse-speed);
+  animation-direction: alternate;
   animation-iteration-count: infinite;
   animation-timing-function: ease-in-out;
 
@@ -96,7 +120,12 @@
   &.shiny-busy::after {
     @include shiny-page-busy;
   }
-  &.shiny-busy:has(.recalculating)::after {
+  // Hide the pulse if there are spinners on the page
+  // (Note: UI outputs don't get spinners)
+  &.shiny-busy:has(.recalculating:not(.shiny-html-output))::after {
+    display: none;
+  }
+  &.shiny-busy:has(.recalculating.shiny-table-output)::after {
     display: none;
   }
   &.shiny-busy:has(#shiny-disconnected-overlay)::after {
@@ -127,16 +156,31 @@
 /* Keyframes for the pulsing banner */
 @keyframes busy-page-pulse {
   0% {
-    left: -75%;
-    width: 75%;
+    left: -14%;
+    right: 97%;
   }
-  50% {
-    left: 100%;
-    width: 75%;
+
+  45% {
+    left: 0%;
+    right: 14%;
   }
-  /* Go back */
-  100% {
-    left: -75%;
-    width: 75%;
+
+  55% {
+    left: 14%;
+    right: 0%;
+  }
+
+  to {
+    left: 97%;
+    right: -14%;
   }
 }
+
+
+// Effectively disable the spinner when it's wrapped in shinycssloader::withSpinner()
+// since that's a sign our spinner isn't needed.
+// The reason this sets size to 0px instead of display:none is so, if someone
+// really wants to show the spinner, they can override this with a custom size.
+.shiny-spinner-output-container {
+  --shiny-spinner-size: 0px;
+}

srcts/extras/globalShiny.ts

@@ -2,19 +2,12 @@
 // Project: Shiny <https://shiny.rstudio.com/>
 // Definitions by: RStudio <https://www.rstudio.com/>
 
-import type { Shiny as RStudioShiny } from "../src/shiny/index";
+import type { ShinyClass } from "../src/shiny/index";
 
 declare global {
-  // Tell Shiny variable globally exists
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const Shiny: RStudioShiny;
-
   // Tell window.Shiny exists
   interface Window {
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    Shiny: RStudioShiny;
+    Shiny: ShinyClass;
   }
-
-  // Make `Shiny` a globally available type definition. (No need to import the type)
-  type Shiny = RStudioShiny;
 }

srcts/extras/textarea-autoresize.css

@@ -0,0 +1,6 @@
+.textarea-autoresize textarea.form-control {
+  padding: 5px 8px;
+  resize: none;
+  overflow-y: hidden;
+  height: auto;
+}

srcts/patch/README.md

@@ -1,9 +0,0 @@
-# `yarn` Patch files
-
-* `yarn_pnp.patch`
-  * This file is currently not used and is outdated.
-  * This provides a good game plan on how to use PnP with Yarn once esbuild can easily be integrated with Yarn PnP.
-  * Using PnP removes the `node_modules` folder, but adds a zip of each package. I **do not** like Yarn's suggestion to commit these zip files to support their [Zero Installs](https://next.yarnpkg.com/features/zero-installs) philosophy.
-  * Reference:
-    * https://next.yarnpkg.com/features/pnp
-    * https://yarnpkg.com/api/modules/esbuild_plugin_pnp.html

srcts/patch/yarn_pnp.patch

@@ -1,250 +0,0 @@
-diff --git a/srcts/TODO.md b/srcts/TODO.md
-index dbe275f1..e36ced9e 100644
---- a/srcts/TODO.md
-+++ b/srcts/TODO.md
-@@ -36,6 +36,7 @@
-   * √ Verify it works on phantomjs / shinytest
- * √ Set up initial jest tests
- * √ Use a global shim to avoid importing jquery directly, but make testing easy to test
-+* √ Use yarn PnP
- 
- # Later TODO
- 
-@@ -49,12 +50,3 @@
- * Completely remove `parcel` from `./package.json` and only use `esbuild`
- * Delete 'shiny-es5' files
- * Delete 'old' folder
--
--
--# Eventual TODO
--* Use yarn PnP
--  * Use [esbuild](https://github.com/yarnpkg/berry/tree/master/packages/esbuild-plugin-pnp#yarnpkgesbuild-plugin-pnp)
--  * Remove `./.yarnrc.yaml` `nodeLinker` key
--  * TODO - Figure out how to call the esbuild command with the missing packages. Currently Yarn can't ifnd `esbuild` and suggests `esbuild-X.Y.Z-SHA` (or something other than `esbuild`) which does not make sense.
--    * Calling `yarn node esbuild.config.mjs` does not work
--    * Calling `yarn pnpify node esbuild.config.mjs` does not work
-diff --git a/srcts/esbuild.config.js b/srcts/esbuild.config.js
-new file mode 100644
-index 00000000..8e4a0801
---- /dev/null
-+++ b/srcts/esbuild.config.js
-@@ -0,0 +1,54 @@
-+/* eslint-disable no-undef */
-+/* eslint-disable @typescript-eslint/no-var-requires */
-+
-+// !! Do not convert this file to a module (aka using `import` statements) as VSCode suggests to do
-+// Yarn shims the `require` function to make PnP work. It does not work on import statements
-+
-+const esbuild = require("esbuild");
-+const babel = require("esbuild-plugin-babel");
-+const readcontrol = require("readcontrol");
-+const pnpPlugin = require("esbuild-plugin-pnp");
-+const process = require("process");
-+const globalsPlugin = require("esbuild-plugin-globals");
-+
-+let watch = process.argv.length >= 3 && process.argv[2] == "--watch";
-+
-+let outdir = "../inst/www/shared/";
-+let opts = {
-+  entryPoints: ["src/index.ts"],
-+  bundle: true,
-+  watch: watch,
-+  plugins: [
-+    globalsPlugin({
-+      jquery: "window.jQuery",
-+    }),
-+    pnpPlugin(),
-+    babel(),
-+  ],
-+  target: "es5",
-+  sourcemap: true,
-+  define: {
-+    "process.env.SHINY_VERSION": `"${
-+      readcontrol.readSync("../DESCRIPTION").version
-+    }"`,
-+  },
-+};
-+
-+console.log("Building shiny.js");
-+esbuild
-+  .build({
-+    ...opts,
-+    outfile: outdir + "shiny.js",
-+  })
-+  .then(() => {
-+    console.log("Building shiny.min.js");
-+    esbuild.build({
-+      ...opts,
-+      outfile: outdir + "shiny.min.js",
-+      minify: true,
-+    });
-+  })
-+  .catch((reason) => {
-+    console.error(reason);
-+    process.exit(1);
-+  });
-diff --git a/srcts/esbuild.config.mjs b/srcts/esbuild.config.mjs
-deleted file mode 100644
-index ffdb855b..00000000
---- a/srcts/esbuild.config.mjs
-+++ /dev/null
-@@ -1,40 +0,0 @@
--import esbuild from "esbuild";
--import babel from "esbuild-plugin-babel";
--import readcontrol from "readcontrol";
--import process from "process";
--import globalsPlugin from "esbuild-plugin-globals";
--
--let watch = process.argv.length >= 3 && process.argv[2] == "--watch";
--
--let outdir = "../inst/www/shared/";
--let opts = {
--  entryPoints: ["src/index.ts"],
--  bundle: true,
--  watch: watch,
--  plugins: [
--    globalsPlugin({
--      jquery: "window.jQuery",
--    }),
--    babel(),
--  ],
--  target: "es5",
--  sourcemap: true,
--  define: {
--    "process.env.SHINY_VERSION": `"${
--      readcontrol.readSync("../DESCRIPTION").version
--    }"`,
--  },
--};
--
--console.log("Building shiny.js");
--await esbuild.build({
--  ...opts,
--  outfile: outdir + "shiny.js",
--});
--
--console.log("Building shiny.min.js");
--await esbuild.build({
--  ...opts,
--  outfile: outdir + "shiny.min.js",
--  minify: true,
--});
-diff --git a/srcts/package.json b/srcts/package.json
-index c7f6b66b..edff5ce9 100644
---- a/srcts/package.json
-+++ b/srcts/package.json
-@@ -21,8 +21,9 @@
-     "@typescript-eslint/parser": "^4",
-     "browserslist": "^4.16.3",
-     "esbuild": "^0.8.50",
--    "esbuild-plugin-babel": "0.2.3",
-+    "esbuild-plugin-babel": "patch:esbuild-plugin-babel@0.2.3#./patch/esbuild-plugin-babel.patch",
-     "esbuild-plugin-globals": "^0.1.1",
-+    "esbuild-plugin-pnp": "^0.3.0",
-     "eslint": "^7",
-     "eslint-config-prettier": "^7",
-     "eslint-plugin-jest": "^24",
-@@ -45,7 +46,7 @@
-     "build": "yarn run build_shiny",
-     "setup_build_shiny": "yarn run lint && yarn run typescript-check",
-     "build_shiny": "yarn run setup_build_shiny && yarn run bundle_shiny",
--    "bundle_shiny": "node esbuild.config.mjs",
-+    "bundle_shiny": "node esbuild.config.js",
-     "bundle_shiny_parcel2": "parcel build -d ../inst/www/shared --no-minify -o shiny.js src/index.ts",
-     "watch_parcel2": "yarn run setup_build_shiny && parcel run -d ../inst/www/shared -o shiny.js srcjs/index.ts",
-     "replace_shiny_version2": "replace --silent '\"[^\"]+\"; // @VERSION@' \"\\\"`node -e 'console.log(require(\"readcontrol\").readSync(\"../DESCRIPTION\").version)'`\\\"; // @VERSION@\" src/shiny.ts",
-diff --git a/srcts/patch/esbuild-plugin-babel.patch b/srcts/patch/esbuild-plugin-babel.patch
-new file mode 100644
-index 00000000..24cc9425
---- /dev/null
-+++ b/srcts/patch/esbuild-plugin-babel.patch
-@@ -0,0 +1,33 @@
-+diff --git a/package.json b/package.json
-+index 6b9cdb89e2bbf0f5b5ad65adb53951d129f265ca..4e9b0e08e1c9850ff637eb6a47b5f3cfa33bbb55 100644
-+--- a/package.json
-++++ b/package.json
-+@@ -7,7 +7,6 @@
-+ 	"license": "ISC",
-+ 	"exports": "./src/index.js",
-+ 	"main": "src/index.js",
-+-	"type": "module",
-+ 	"scripts": {
-+ 		"format": "prettier --write --ignore-unknown '**/*'"
-+ 	},
-+diff --git a/src/index.js b/src/index.js
-+index b3cff90a292daa6cfac0566ee73bab142ac627df..d06ecf8873a45a5ea3cda7edb3814e8034efed32 100644
-+--- a/src/index.js
-++++ b/src/index.js
-+@@ -1,6 +1,7 @@
-+-import babel from '@babel/core';
-+-import fs from 'fs';
-+-import path from 'path';
-++const babel = require('@babel/core');
-++const fs = require('fs');
-++const path = require('path');
-++
-+
-+ const pluginBabel = (options = {}) => ({
-+ 	name: 'babel',
-+@@ -41,4 +42,4 @@ const pluginBabel = (options = {}) => ({
-+ 	}
-+ });
-+
-+-export default pluginBabel;
-++module.exports = pluginBabel;
-diff --git a/srcts/yarn.lock b/srcts/yarn.lock
-index 90d3fd04..1ca29eba 100644
---- a/srcts/yarn.lock
-+++ b/srcts/yarn.lock
-@@ -4334,7 +4334,7 @@ __metadata:
-   languageName: node
-   linkType: hard
- 
--"esbuild-plugin-babel@npm:0.2.3":
-+esbuild-plugin-babel@0.2.3:
-   version: 0.2.3
-   resolution: "esbuild-plugin-babel@npm:0.2.3"
-   peerDependencies:
-@@ -4343,6 +4343,15 @@ __metadata:
-   languageName: node
-   linkType: hard
- 
-+"esbuild-plugin-babel@patch:esbuild-plugin-babel@0.2.3#./patch/esbuild-plugin-babel.patch::locator=root-workspace-0b6124%40workspace%3A.":
-+  version: 0.2.3
-+  resolution: "esbuild-plugin-babel@patch:esbuild-plugin-babel@npm%3A0.2.3#./patch/esbuild-plugin-babel.patch::version=0.2.3&hash=80b9d8&locator=root-workspace-0b6124%40workspace%3A."
-+  peerDependencies:
-+    "@babel/core": ^7.0.0
-+  checksum: 91e0a233ed255b4798b3a1d9b2d9fbc8ea3c107561c69b31790f02c556a4687770a13d2b4c58f3dc638198bcddd5c6d7d26496a6578da730cd635dea1dd8450c
-+  languageName: node
-+  linkType: hard
-+
- "esbuild-plugin-globals@npm:^0.1.1":
-   version: 0.1.1
-   resolution: "esbuild-plugin-globals@npm:0.1.1"
-@@ -4350,6 +4359,15 @@ __metadata:
-   languageName: node
-   linkType: hard
- 
-+"esbuild-plugin-pnp@npm:^0.3.0":
-+  version: 0.3.0
-+  resolution: "esbuild-plugin-pnp@npm:0.3.0"
-+  peerDependencies:
-+    esbuild: ^0.8.1
-+  checksum: b80ab17bea35ab6eaf9a9adc14c52667c0a5e2c7c8c8e97194c57feb7d14b7247228745a3ad34f69447d6c5241081f38b9786948b879bf0051a479ce74450edc
-+  languageName: node
-+  linkType: hard
-+
- "esbuild@npm:^0.8.50":
-   version: 0.8.50
-   resolution: "esbuild@npm:0.8.50"
-@@ -9295,8 +9313,9 @@ fsevents@^2.1.2:
-     browserslist: ^4.16.3
-     core-js: ^3.9
-     esbuild: ^0.8.50
--    esbuild-plugin-babel: 0.2.3
-+    esbuild-plugin-babel: "patch:esbuild-plugin-babel@0.2.3#./patch/esbuild-plugin-babel.patch"
-     esbuild-plugin-globals: ^0.1.1
-+    esbuild-plugin-pnp: ^0.3.0
-     eslint: ^7
-     eslint-config-prettier: ^7
-     eslint-plugin-jest: ^24

srcts/src/bindings/input/date.ts

@@ -40,19 +40,15 @@ class DateInputBindingBase extends InputBinding {
     el;
   }
   subscribe(el: HTMLElement, callback: (x: boolean) => void): void {
-    $(el).on(
-      "keyup.dateInputBinding input.dateInputBinding",
-      // event: Event
-      function () {
-        // Use normal debouncing policy when typing
-        callback(true);
-      }
-    );
+    // Don't update when in the middle of typing; listening on keyup or input
+    // tends to send spurious values to the server, based on unpredictable
+    // browser-dependant interpretation of partially-typed date strings.
     $(el).on(
       "changeDate.dateInputBinding change.dateInputBinding",
       // event: Event
       function () {
         // Send immediately when clicked
+        // Or if typing, when enter pressed or focus lost
         callback(false);
       }
     );

srcts/src/bindings/input/daterange.ts

@@ -161,19 +161,15 @@ class DateRangeInputBinding extends DateInputBindingBase {
     this._setMax($endinput[0], $endinput.data("max-date"));
   }
   subscribe(el: HTMLElement, callback: (x: boolean) => void): void {
-    $(el).on(
-      "keyup.dateRangeInputBinding input.dateRangeInputBinding",
-      // event: Event
-      function () {
-        // Use normal debouncing policy when typing
-        callback(true);
-      }
-    );
+    // Don't update when in the middle of typing; listening on keyup or input
+    // tends to send spurious values to the server, based on unpredictable
+    // browser-dependant interpretation of partially-typed date strings.
     $(el).on(
       "changeDate.dateRangeInputBinding change.dateRangeInputBinding",
       // event: Event
       function () {
         // Send immediately when clicked
+        // Or if typing, when enter pressed or focus lost
         callback(false);
       }
     );

srcts/src/bindings/input/index.ts

@@ -18,11 +18,10 @@ import { TextInputBinding } from "./text";
 import { TextareaInputBinding } from "./textarea";
 
 // TODO-barret make this an init method
-type InitInputBindings = {
+function initInputBindings(): {
   inputBindings: BindingRegistry<InputBinding>;
   fileInputBinding: FileInputBinding;
-};
-function initInputBindings(): InitInputBindings {
+} {
   const inputBindings = new BindingRegistry<InputBinding>();
 
   inputBindings.register(new TextInputBinding(), "shiny.textInput");

srcts/src/bindings/input/inputBinding.ts

@@ -1,3 +1,4 @@
+import type { EventPriority } from "../../inputPolicies/inputPolicy";
 import type { RatePolicyModes } from "../../inputPolicies/inputRateDecorator";
 import type { BindScope } from "../../shiny/bind";
 
@@ -26,10 +27,16 @@ class InputBinding {
     el; // unused var
   }
 
-  // The callback method takes one argument, whose value is boolean. If true,
-  // allow deferred (debounce or throttle) sending depending on the value of
-  // getRatePolicy. If false, send value immediately. Default behavior is `false`
-  subscribe(el: HTMLElement, callback: (value: boolean) => void): void {
+  // Historically, the callback value could only be boolean. In this case:
+  //   * false: send value immediately (i.e., priority = "immediate")
+  //   * true: send value later (i.e., priority = "deferred")
+  //     * The input rate policy is also consulted on whether to debounce or throttle
+  // In recent versions, the value can also be "event", meaning that the
+  // value should be sent regardless of whether it has changed.
+  subscribe(
+    el: HTMLElement,
+    callback: (value: EventPriority | boolean) => void
+  ): void {
     // empty
     el; // unused var
     callback; // unused var

srcts/src/bindings/input/selectInput.ts

@@ -142,13 +142,13 @@ class SelectInputBinding extends InputBinding {
         };
       };
 
+      // Calling selectize.clear() first works around https://github.com/selectize/selectize.js/issues/2146
+      // As of selectize.js >= v0.13.1, .clearOptions() clears the selection,
+      // but does NOT remove the previously-selected options. So unless we call
+      // .clear() first, the current selection(s) will remain as (deselected)
+      // options. See #3966 #4142
+      selectize.clear();
       selectize.clearOptions();
-      // If a new `selected` value is provided, also clear the current selection (otherwise it gets added as an option).
-      // Note: although the selectize docs suggest otherwise, as of selectize.js >v0.15.2,
-      // .clearOptions() no longer implicitly .clear()s (see #3967)
-      if (hasDefinedProperty(data, "value")) {
-        selectize.clear();
-      }
       let loaded = false;
 
       selectize.settings.load = function (query: string, callback: CallbackFn) {

srcts/src/bindings/input/text.ts

@@ -1,6 +1,7 @@
 import $ from "jquery";
 import { $escape, hasDefinedProperty, updateLabel } from "../../utils";
 
+import type { EventPriority } from "../../inputPolicies/inputPolicy";
 import { InputBinding } from "./inputBinding";
 
 // interface TextHTMLElement extends NameValueHTMLElement {
@@ -49,22 +50,42 @@ class TextInputBindingBase extends InputBinding {
     value;
   }
 
-  subscribe(el: TextHTMLElement, callback: (x: boolean) => void): void {
-    $(el).on(
-      "keyup.textInputBinding input.textInputBinding",
-      // event: Event
-      function () {
-        callback(true);
-      }
-    );
-    $(el).on(
-      "change.textInputBinding",
-      // event: Event
-      function () {
+  subscribe(
+    el: TextHTMLElement,
+    callback: (x: EventPriority | boolean) => void
+  ): void {
+    const $el = $(el);
+    const updateOn = $el.data("update-on") || "change";
+
+    if (updateOn === "change") {
+      $el.on(
+        "keyup.textInputBinding input.textInputBinding",
+        // event: Event
+        function () {
+          callback(true);
+        }
+      );
+    } else if (updateOn === "blur") {
+      $el.on("blur.textInputBinding", function () {
         callback(false);
+      });
+      $el.on("keydown.textInputBinding", function (event: JQuery.Event) {
+        if (event.key !== "Enter") return;
+        if ($el.is("textarea")) {
+          if (!(event.ctrlKey || event.metaKey)) return;
+        }
+        callback(false);
+      });
+    }
+
+    $el.on("change.textInputBinding", function () {
+      if (updateOn === "blur" && $el.is(":focus")) {
+        return;
       }
-    );
+      callback(false);
+    });
   }
+
   unsubscribe(el: TextHTMLElement): void {
     $(el).off(".textInputBinding");
   }

srcts/src/bindings/input/textarea.ts

@@ -2,11 +2,96 @@ import $ from "jquery";
 
 import { TextInputBinding } from "./text";
 
-class TextareaInputBinding extends TextInputBinding {
+export class TextareaInputBinding extends TextInputBinding {
   find(scope: HTMLElement): JQuery<HTMLElement> {
     // Inputs now also have the .shiny-input-textarea class
     return $(scope).find("textarea");
   }
 }
 
-export { TextareaInputBinding };
+/*************************************************************
+ * Code below this point is for textAreaInput(autoresize=TRUE)
+ ************************************************************/
+
+interface DOMEvent<T extends EventTarget> extends Event {
+  readonly target: T;
+}
+
+function onDelegatedEvent(
+  eventName: string,
+  selector: string,
+  callback: (target: HTMLTextAreaElement) => void
+) {
+  document.addEventListener(eventName, (e) => {
+    const e2 = e as DOMEvent<HTMLTextAreaElement>;
+    if (e2.target.matches(selector)) {
+      callback(e2.target);
+    }
+  });
+}
+
+// Use a single intersectionObserver as they are slow to create / use.
+let textAreaIntersectionObserver: IntersectionObserver | null = null;
+
+function callUpdateHeightWhenTargetIsVisible(target: HTMLTextAreaElement) {
+  if (textAreaIntersectionObserver === null) {
+    // Create a single observer to watch for the textarea becoming visible
+    textAreaIntersectionObserver = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        // Quit if the entry is not visible
+        if (!entry.isIntersecting) {
+          return;
+        }
+        // If the entry is visible (even if it's just a single pixel)
+        // Stop observing the target
+        textAreaIntersectionObserver?.unobserve(entry.target);
+
+        // Update the height of the textarea
+        updateHeight(entry.target as HTMLTextAreaElement);
+      });
+    });
+  }
+
+  textAreaIntersectionObserver.observe(target);
+}
+
+function updateHeight(target: HTMLTextAreaElement) {
+  if (target.scrollHeight > 0) {
+    // Automatically resize the textarea to fit its content.
+    target.style.height = "auto";
+    target.style.height = target.scrollHeight + "px";
+  } else {
+    // The textarea is not visible on the page, therefore it has a 0 scroll height.
+
+    // If we should autoresize the text area height, then we can wait for the textarea to
+    // become visible and call `updateHeight` again. Hopefully the scroll height is no
+    // longer 0
+    callUpdateHeightWhenTargetIsVisible(target);
+  }
+}
+
+// Update on change
+onDelegatedEvent(
+  "input",
+  "textarea.textarea-autoresize",
+  (target: HTMLTextAreaElement) => {
+    updateHeight(target);
+  }
+);
+
+// Update on load
+function updateOnLoad() {
+  if (document.readyState === "loading") {
+    // Document still loading, wait 10ms to check again.
+    setTimeout(updateOnLoad, 10);
+    return;
+  }
+
+  // document.readyState in ["interactive", "complete"];\
+  const textAreas = document.querySelectorAll(
+    "textarea.textarea-autoresize"
+  ) as NodeListOf<HTMLTextAreaElement>;
+  textAreas.forEach(updateHeight);
+}
+
+updateOnLoad();

srcts/src/components/errorConsole.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 
 import { css, html, LitElement } from "lit";
+import { Shiny } from "..";
 import { ShinyClientError } from "../shiny/error";
 
 const buttonStyles = css`
@@ -199,6 +200,42 @@ class ShinyErrorConsole extends LitElement {
     });
   }
 
+  static createClientMessageElement({ headline, message }: ShinyClientMessage) {
+    const msg = document.createElement("shiny-error-message");
+    msg.setAttribute("headline", headline || "");
+    msg.setAttribute("message", message);
+    return msg;
+  }
+
+  appendConsoleMessage({ headline, message }: ShinyClientMessage) {
+    const content =
+      this.shadowRoot?.querySelector<HTMLSlotElement>("slot.content");
+
+    if (content) {
+      const nodeKey = (node: Element) => {
+        const headline = node.getAttribute("headline") || "";
+        const message = node.getAttribute("message") || "";
+        return `${headline}::${message}`;
+      };
+      const newKey = `${headline}::${message}`;
+
+      for (const node of content.assignedElements()) {
+        if (node.tagName.toLowerCase() === "shiny-error-message") {
+          if (nodeKey(node) === newKey) {
+            // Do nothing, this message is already in the console
+            // TODO: Increase count of message here
+            return;
+          }
+        }
+      }
+    }
+
+    this.appendChild(
+      ShinyErrorConsole.createClientMessageElement({ headline, message })
+    );
+    return;
+  }
+
   render() {
     return html` <div class="header">
         <span class="title"> Shiny Client Errors </span>
@@ -306,6 +343,7 @@ export class ShinyErrorMessage extends LitElement {
 
       .error-message {
         font-family: "Courier New", Courier, monospace;
+        white-space: pre-wrap;
       }
 
       .decoration-container {
@@ -488,6 +526,48 @@ export class ShinyErrorMessage extends LitElement {
 
 customElements.define("shiny-error-message", ShinyErrorMessage);
 
+export type ShinyClientMessage = {
+  message: string;
+  headline?: string;
+  status?: "error" | "info" | "warning";
+};
+
+function showShinyClientMessage({
+  headline = "",
+  message,
+  status = "warning",
+}: ShinyClientMessage): void {
+  const consoleMessage = `[shiny] ${headline}${
+    headline ? " - " : ""
+  }${message}`;
+
+  switch (status) {
+    case "error":
+      console.error(consoleMessage);
+      break;
+    case "warning":
+      console.warn(consoleMessage);
+      break;
+    default:
+      console.log(consoleMessage);
+      break;
+  }
+
+  if (!Shiny.inDevMode()) {
+    return;
+  }
+
+  // Check to see if an Error Console Container element already exists. If it
+  // doesn't we need to add it before putting an error on the screen
+  let sec = document.querySelector<ShinyErrorConsole>("shiny-error-console");
+  if (!sec) {
+    sec = document.createElement("shiny-error-console") as ShinyErrorConsole;
+    document.body.appendChild(sec);
+  }
+
+  sec.appendConsoleMessage({ headline, message });
+}
+
 /**
  * Function to show an error message to user in shiny-error-message web
  * component. Only shows the error if we're in development mode.
@@ -496,11 +576,6 @@ customElements.define("shiny-error-message", ShinyErrorMessage);
  * object.
  */
 export function showErrorInClientConsole(e: unknown): void {
-  if (!Shiny.inDevMode()) {
-    // If we're in production, don't show the error to the user
-    return;
-  }
-
   let errorMsg: string | null = null;
   let headline = "Error on client while running Shiny app";
 
@@ -515,17 +590,24 @@ export function showErrorInClientConsole(e: unknown): void {
     errorMsg = "Unknown error";
   }
 
-  // Check to see if an Error Console Container element already exists. If it
-  // doesn't we need to add it before putting an error on the screen
-  let errorConsoleContainer = document.querySelector("shiny-error-console");
-  if (!errorConsoleContainer) {
-    errorConsoleContainer = document.createElement("shiny-error-console");
-    document.body.appendChild(errorConsoleContainer);
-  }
-
-  const errorConsole = document.createElement("shiny-error-message");
-  errorConsole.setAttribute("headline", headline || "");
-  errorConsole.setAttribute("message", errorMsg);
-
-  errorConsoleContainer.appendChild(errorConsole);
+  showShinyClientMessage({ headline, message: errorMsg, status: "error" });
 }
+
+export class ShinyClientMessageEvent extends CustomEvent<ShinyClientMessage> {
+  constructor(detail: ShinyClientMessage) {
+    super("shiny:client-message", { detail, bubbles: true, cancelable: true });
+  }
+}
+
+window.addEventListener("shiny:client-message", (ev: Event) => {
+  if (!(ev instanceof CustomEvent)) {
+    throw new Error("[shiny] shiny:client-message expected a CustomEvent");
+  }
+  const { headline, message, status } = ev.detail;
+  if (!message) {
+    throw new Error(
+      "[shiny] shiny:client-message expected a `message` property in `event.detail`."
+    );
+  }
+  showShinyClientMessage({ headline, message, status });
+});

srcts/src/imageutils/initCoordmap.ts

@@ -162,8 +162,8 @@ function initCoordmap(
     const bounds = {
       top: 0,
       left: 0,
-      right: img.clientWidth - 1,
-      bottom: img.clientHeight - 1,
+      right: img.naturalWidth - 1,
+      bottom: img.naturalHeight - 1,
     };
 
     coordmap_.panels[0] = {
@@ -290,11 +290,10 @@ function initCoordmap(
 
     const matches = []; // Panels that match
     const dists = []; // Distance of offset to each matching panel
-    let b;
     let i;
 
     for (i = 0; i < coordmap.panels.length; i++) {
-      b = coordmap.panels[i].range;
+      const b = coordmap.panels[i].range;
 
       if (
         x <= b.right + expandImg.x &&
@@ -413,5 +412,5 @@ function initCoordmap(
   return coordmap;
 }
 
+export { findOrigin, initCoordmap };
 export type { Coordmap, CoordmapInit };
-export { initCoordmap, findOrigin };

srcts/src/index.ts

@@ -1,3 +1,4 @@
 import { init } from "./initialize";
+export { Shiny, type ShinyClass } from "./initialize";
 
 init();

srcts/src/initialize/index.ts

@@ -2,15 +2,20 @@ import { determineBrowserInfo } from "./browser";
 import { disableFormSubmission } from "./disableForm";
 import { trackHistory } from "./history";
 
-import { setShiny } from "../shiny";
+import { ShinyClass } from "../shiny";
 import { setUserAgent } from "../utils/userAgent";
-import { windowShiny } from "../window/libraries";
 import { windowUserAgent } from "../window/userAgent";
 
 import { initReactlog } from "../shiny/reactlog";
 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+let Shiny: ShinyClass;
+
 function init(): void {
-  setShiny(windowShiny());
+  if (window.Shiny) {
+    throw new Error("Trying to create window.Shiny, but it already exists!");
+  }
+  Shiny = window.Shiny = new ShinyClass();
   setUserAgent(windowUserAgent()); // before determineBrowserInfo()
 
   determineBrowserInfo();
@@ -21,4 +26,4 @@ function init(): void {
   initReactlog();
 }
 
-export { init };
+export { init, Shiny, type ShinyClass };

srcts/src/shiny/bind.ts

@@ -1,23 +1,34 @@
 import $ from "jquery";
+import { Shiny } from "..";
 import type { InputBinding, OutputBinding } from "../bindings";
 import { OutputBindingAdapter } from "../bindings/outputAdapter";
 import type { BindingRegistry } from "../bindings/registry";
+import { ShinyClientMessageEvent } from "../components/errorConsole";
 import type {
   InputRateDecorator,
   InputValidateDecorator,
 } from "../inputPolicies";
-import { ShinyClientError } from "./error";
+import type { InputPolicyOpts } from "../inputPolicies/inputPolicy";
 import { shinyAppBindOutput, shinyAppUnbindOutput } from "./initedMethods";
 import { sendImageSizeFns } from "./sendImageSize";
 
 type BindScope = HTMLElement | JQuery<HTMLElement>;
 
+/**
+ * Type guard to check if a value is a jQuery object containing HTMLElements
+ * @param value The value to check
+ * @returns A type predicate indicating if the value is a jQuery<HTMLElement>
+ */
+function isJQuery<T = HTMLElement>(value: unknown): value is JQuery<T> {
+  return Boolean(value && (value as any).jquery);
+}
+
 // todo make sure allowDeferred can NOT be supplied and still work
 function valueChangeCallback(
   inputs: InputValidateDecorator,
   binding: InputBinding,
   el: HTMLElement,
-  allowDeferred: boolean
+  priority: InputPolicyOpts["priority"]
 ) {
   let id = binding.getId(el);
 
@@ -27,17 +38,7 @@ function valueChangeCallback(
 
     if (type) id = id + ":" + type;
 
-    const opts: {
-      priority: "deferred" | "immediate";
-      binding: typeof binding;
-      el: typeof el;
-    } = {
-      priority: allowDeferred ? "deferred" : "immediate",
-      binding: binding,
-      el: el,
-    };
-
-    inputs.setInput(id, value, opts);
+    inputs.setInput(id, value, { priority, binding, el });
   }
 }
 
@@ -74,14 +75,17 @@ const bindingsRegistry = (() => {
    * accessibility and other reasons. However, in practice our bindings still
    * work as long as inputs the IDs within a binding type don't overlap.
    *
-   * @returns ShinyClientError if current ID bindings are invalid, otherwise
-   * returns an ok status.
+   * @returns ShinyClientMessageEvent if current ID bindings are invalid,
+   * otherwise returns an ok status.
    */
-  function checkValidity():
-    | { status: "error"; error: ShinyClientError }
-    | { status: "ok" } {
+  function checkValidity(scope: BindScope): void {
+    if (!isJQuery(scope) && !(scope instanceof HTMLElement)) {
+      return;
+    }
+
     type BindingCounts = { [T in BindingTypes]: number };
     const duplicateIds = new Map<string, BindingCounts>();
+    const problems: Set<string> = new Set();
 
     // count duplicate IDs of each binding type
     bindings.forEach((idTypes, id) => {
@@ -89,22 +93,30 @@ const bindingsRegistry = (() => {
 
       idTypes.forEach((type) => (counts[type] += 1));
 
-      // If there's a single duplication of ids across both binding types, then
-      // when we're not in devmode, we allow this to pass because a good amount of
-      // existing applications use this pattern even though its invalid. Eventually
-      // this behavior should be removed.
-      if (counts.input === 1 && counts.output === 1 && !Shiny.inDevMode()) {
+      if (counts.input + counts.output < 2) {
         return;
       }
+      // We have duplicated IDs, add them to the set of duplicated IDs to be
+      // reported to the user.
+      duplicateIds.set(id, counts);
 
-      // If we have duplicated IDs, then add them to the set of duplicated IDs
-      // to be reported to the user.
-      if (counts.input + counts.output > 1) {
-        duplicateIds.set(id, counts);
+      if (counts.input > 1) {
+        problems.add("input");
+      }
+      if (counts.output > 1) {
+        problems.add("output");
+      }
+      if (counts.input >= 1 && counts.output >= 1) {
+        problems.add("shared");
       }
     });
 
-    if (duplicateIds.size === 0) return { status: "ok" };
+    if (duplicateIds.size === 0) return;
+    // Duplicated IDs are now always a warning. Before the ShinyClient console
+    // was added duplicate output IDs were errors in "production" mode. After
+    // the Shiny Client console was introduced, duplicate IDs were no longer
+    // production errors but *would* break apps in dev mode. Now, in v1.10+,
+    // duplicate IDs are always warnings in all modes for consistency.
 
     const duplicateIdMsg = Array.from(duplicateIds.entries())
       .map(([id, counts]) => {
@@ -119,15 +131,27 @@ const bindingsRegistry = (() => {
       })
       .join("\n");
 
-    return {
-      status: "error",
-      error: new ShinyClientError({
-        headline: "Duplicate input/output IDs found",
-        message: `The following ${
-          duplicateIds.size === 1 ? "ID was" : "IDs were"
-        } repeated:\n${duplicateIdMsg}`,
-      }),
-    };
+    let txtVerb = "Duplicate";
+    let txtNoun = "input/output";
+    if (problems.has("input") && problems.has("output")) {
+      // base case
+    } else if (problems.has("input")) {
+      txtNoun = "input";
+    } else if (problems.has("output")) {
+      txtNoun = "output";
+    } else if (problems.has("shared")) {
+      txtVerb = "Shared";
+    }
+
+    const txtIdsWere = duplicateIds.size == 1 ? "ID was" : "IDs were";
+    const headline = `${txtVerb} ${txtNoun} ${txtIdsWere} found`;
+    const message = `The following ${txtIdsWere} used for more than one ${
+      problems.has("shared") ? "input/output" : txtNoun
+    }:\n${duplicateIdMsg}`;
+
+    const event = new ShinyClientMessageEvent({ headline, message });
+    const scopeElement = isJQuery(scope) ? scope.get(0) : scope;
+    (scopeElement || window).dispatchEvent(event);
   }
 
   /**
@@ -239,8 +263,17 @@ function bindInputs(
         const thisBinding = binding;
         const thisEl = el;
 
-        return function (allowDeferred: boolean) {
-          valueChangeCallback(inputs, thisBinding, thisEl, allowDeferred);
+        // Historically speaking, this callback has only accepted a boolean value,
+        // but in recent versions it can also accept a input priority.
+        return function (priority: InputPolicyOpts["priority"] | boolean) {
+          const normalizedPriority =
+            typeof priority !== "boolean"
+              ? priority
+              : priority
+              ? "deferred"
+              : "immediate";
+
+          valueChangeCallback(inputs, thisBinding, thisEl, normalizedPriority);
         };
       })();
 
@@ -422,15 +455,7 @@ async function _bindAll(
   // complete error message that contains everything they will need to fix. If
   // we threw as we saw collisions then the user would fix the first collision,
   // re-run, and then see the next collision, etc.
-  const bindingValidity = bindingsRegistry.checkValidity();
-  if (bindingValidity.status === "error") {
-    // Only throw if we're in dev mode. Otherwise, just log a warning.
-    if (Shiny.inDevMode()) {
-      throw bindingValidity.error;
-    } else {
-      console.warn("[shiny] " + bindingValidity.error.message);
-    }
-  }
+  bindingsRegistry.checkValidity(scope);
 
   return currentInputs;
 }