Movatterモバイル変換

Type:	Package
Title:	Web Application Framework for R
Version:	1.12.1
Description:	Makes it incredibly easy to build interactive web applications with R. Automatic "reactive" binding between inputs and outputs and extensive prebuilt widgets make it possible to build beautiful, responsive, and powerful applications with minimal effort.
License:	GPL-3 | file LICENSE
URL:	https://shiny.posit.co/,https://github.com/rstudio/shiny
BugReports:	https://github.com/rstudio/shiny/issues
Depends:	methods, R (≥ 3.0.2)
Imports:	bslib (≥ 0.6.0), cachem (≥ 1.1.0), cli, commonmark (≥2.0.0), fastmap (≥ 1.1.1), fontawesome (≥ 0.4.0), glue (≥1.3.2), grDevices, htmltools (≥ 0.5.4), httpuv (≥ 1.5.2),jsonlite (≥ 0.9.16), later (≥ 1.0.0), lifecycle (≥ 0.2.0),mime (≥ 0.3), otel, promises (≥ 1.5.0), R6 (≥ 2.0), rlang(≥ 0.4.10), sourcetools, tools, utils, withr, xtable
Suggests:	Cairo (≥ 1.5-5), coro (≥ 1.1.0), datasets, DT, dygraphs,future, ggplot2, knitr (≥ 1.6), magrittr, markdown, mirai,otelsdk (≥ 0.2.0), ragg, reactlog (≥ 1.0.0), rmarkdown, sass,showtext, testthat (≥ 3.2.1), watcher, yaml
Config/Needs/check:	shinytest2
Config/testthat/edition:	3
Encoding:	UTF-8
RoxygenNote:	7.3.3
Collate:	'globals.R' 'app-state.R' 'app_template.R' 'bind-cache.R''bind-event.R' 'bookmark-state-local.R' 'bookmark-state.R''bootstrap-deprecated.R' 'bootstrap-layout.R' 'conditions.R''map.R' 'utils.R' 'bootstrap.R' 'busy-indicators-spinners.R''busy-indicators.R' 'cache-utils.R' 'deprecated.R' 'devmode.R''diagnose.R' 'extended-task.R' 'fileupload.R' 'graph.R''reactives.R' 'reactive-domains.R' 'history.R' 'hooks.R''html-deps.R' 'image-interact-opts.R' 'image-interact.R''imageutils.R' 'input-action.R' 'input-checkbox.R''input-checkboxgroup.R' 'input-date.R' 'input-daterange.R''input-file.R' 'input-numeric.R' 'input-password.R''input-radiobuttons.R' 'input-select.R' 'input-slider.R''input-submit.R' 'input-text.R' 'input-textarea.R''input-utils.R' 'insert-tab.R' 'insert-ui.R' 'jqueryui.R''knitr.R' 'middleware-shiny.R' 'middleware.R' 'timer.R''shiny.R' 'mock-session.R' 'modal.R' 'modules.R''notifications.R' 'otel-attr-srcref.R' 'otel-collect.R''otel-enable.R' 'otel-error.R' 'otel-label.R''otel-reactive-update.R' 'otel-session.R' 'otel-shiny.R''otel-with.R' 'priorityqueue.R' 'progress.R' 'react.R''reexports.R' 'render-cached-plot.R' 'render-plot.R''render-table.R' 'run-url.R' 'runapp.R' 'serializers.R''server-input-handlers.R' 'server-resource-paths.R' 'server.R''shiny-options.R' 'shiny-package.R' 'shinyapp.R' 'shinyui.R''shinywrappers.R' 'showcase.R' 'snapshot.R' 'staticimports.R''tar.R' 'test-export.R' 'test-server.R' 'test.R''update-input.R' 'utils-lang.R' 'utils-tags.R''version_bs_date_picker.R' 'version_ion_range_slider.R''version_jquery.R' 'version_jqueryui.R' 'version_selectize.R''version_strftime.R' 'viewer.R'
NeedsCompilation:	no
Packaged:	2025-12-08 21:22:26 UTC; barret
Author:	Winston Chang [aut], Joe Cheng [aut], JJ Allaire [aut], Carson Sievert [aut, cre], Barret Schloerke [aut], Garrick Aden-Buie [aut], Yihui Xie [aut], Jeff Allen [aut], Jonathan McPherson [aut], Alan Dipert [aut], Barbara Borges [aut], Posit Software, PBC [cph, fnd], jQuery Foundation [cph] (jQuery library and jQuery UI library), jQuery contributors [ctb, cph] (jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt), jQuery UI contributors [ctb, cph] (jQuery UI library; authors listed in inst/www/shared/jqueryui/AUTHORS.txt), Mark Otto [ctb] (Bootstrap library), Jacob Thornton [ctb] (Bootstrap library), Bootstrap contributors [ctb] (Bootstrap library), Twitter, Inc [cph] (Bootstrap library), Prem Nawaz Khan [ctb] (Bootstrap accessibility plugin), Victor Tsaran [ctb] (Bootstrap accessibility plugin), Dennis Lembree [ctb] (Bootstrap accessibility plugin), Srinivasu Chakravarthula [ctb] (Bootstrap accessibility plugin), Cathy O'Connor [ctb] (Bootstrap accessibility plugin), PayPal, Inc [cph] (Bootstrap accessibility plugin), Stefan Petre [ctb, cph] (Bootstrap-datepicker library), Andrew Rowls [ctb, cph] (Bootstrap-datepicker library), Brian Reavis [ctb, cph] (selectize.js library), Salmen Bejaoui [ctb, cph] (selectize-plugin-a11y library), Denis Ineshin [ctb, cph] (ion.rangeSlider library), Sami Samhuri [ctb, cph] (Javascript strftime library), SpryMedia Limited [ctb, cph] (DataTables library), Ivan Sagalaev [ctb, cph] (highlight.js library), R Core Team [ctb, cph] (tar implementation from R)
Maintainer:	Carson Sievert <carson@posit.co>
Repository:	CRAN
Date/Publication:	2025-12-09 09:30:02 UTC

Web Application Framework for R

Description

Shiny makes it incredibly easy to build interactive web applications with R.Automatic "reactive" binding between inputs and outputs and extensiveprebuilt widgets make it possible to build beautiful, responsive, andpowerful applications with minimal effort.

Details

The Shiny tutorial athttps://shiny.rstudio.com/tutorial/ explainsthe framework in depth, walks you through building a simple application, andincludes extensive annotated examples.

Author(s)

Maintainer: Carson Sievertcarson@posit.co (ORCID)

Authors:

• Winston Changwinston@posit.co (ORCID)

• Joe Chengjoe@posit.co

• JJ Allairejj@posit.co

• Barret Schloerkebarret@posit.co (ORCID)

• Garrick Aden-Buiegarrick@adenbuie.com (ORCID)

• Yihui Xieyihui@posit.co

• Jeff Allen

• Jonathan McPhersonjonathan@posit.co

• Alan Dipert

• Barbara Borges

Other contributors:

• Posit Software, PBC (ROR) [copyright holder, funder]

• jQuery Foundation (jQuery library and jQuery UI library) [copyright holder]

• jQuery contributors (jQuery library; authors listed in inst/www/shared/jquery-AUTHORS.txt) [contributor, copyright holder]

• jQuery UI contributors (jQuery UI library; authors listed in inst/www/shared/jqueryui/AUTHORS.txt) [contributor, copyright holder]

• Mark Otto (Bootstrap library) [contributor]

• Jacob Thornton (Bootstrap library) [contributor]

• Bootstrap contributors (Bootstrap library) [contributor]

• Twitter, Inc (Bootstrap library) [copyright holder]

• Prem Nawaz Khan (Bootstrap accessibility plugin) [contributor]

• Victor Tsaran (Bootstrap accessibility plugin) [contributor]

• Dennis Lembree (Bootstrap accessibility plugin) [contributor]

• Srinivasu Chakravarthula (Bootstrap accessibility plugin) [contributor]

• Cathy O'Connor (Bootstrap accessibility plugin) [contributor]

• PayPal, Inc (Bootstrap accessibility plugin) [copyright holder]

• Stefan Petre (Bootstrap-datepicker library) [contributor, copyright holder]

• Andrew Rowls (Bootstrap-datepicker library) [contributor, copyright holder]

• Brian Reavis (selectize.js library) [contributor, copyright holder]

• Salmen Bejaoui (selectize-plugin-a11y library) [contributor, copyright holder]

• Denis Ineshin (ion.rangeSlider library) [contributor, copyright holder]

• Sami Samhuri (Javascript strftime library) [contributor, copyright holder]

• SpryMedia Limited (DataTables library) [contributor, copyright holder]

• Ivan Sagalaev (highlight.js library) [contributor, copyright holder]

• R Core Team (tar implementation from R) [contributor, copyright holder]

See Also

shiny-options for documentation about global options.

Task or computation that proceeds in the background

Description

In normal Shiny reactive code, whenever an observer, calc, oroutput is busy computing, it blocks the current session from receiving anyinputs or attempting to proceed with any other computation related to thatsession.

TheExtendedTask class allows you to have an expensive operation that isstarted by a reactive effect, and whose (eventual) results can be accessedby a regular observer, calc, or output; but during the course of theoperation, the current session is completely unblocked, allowing the userto continue using the rest of the app while the operation proceeds in thebackground.

Note that eachExtendedTask object does not represent asingleinvocation of its long-running function. Rather, it's an object that isused to invoke the function with different arguments, keeps track ofwhether an invocation is in progress, and provides ways to get at thecurrent status or results of the operation. A singleExtendedTask objectdoes not permit overlapping invocations: if theinvoke() method is calledbefore the previousinvoke() is completed, the new invocation will notbegin until the previous invocation has completed.

ExtendedTask versus asynchronous reactives

Shiny has long supportedusing {promises}to write asynchronous observers, calcs, or outputs. You may be wonderingwhat the differences are between those techniques and this class.

Asynchronous observers, calcs, and outputs are not–and have neverbeen–designed to let a user start a long-running operation, while keepingthat very same (browser) session responsive to other interactions. Instead,they unblock other sessions, so you can take a long-running operation thatwould normally bring the entire R process to a halt and limit the blockingto just the session that started the operation. (For more details, see thesection on"The Flush Cycle".)

ExtendedTask, on the other hand, invokes an asynchronous function (thatis, a function that quickly returns a promise) and allows even that verysession to immediately unblock and carry on with other user interactions.

OpenTelemetry Integration

When anExtendedTask is created, if OpenTelemetry tracing is enabled for"reactivity" (seewithOtelCollect()), theExtendedTask will recordspans for each invocation of the task. The tracing level atinvoke() timedoes not affect whether spans are recorded; only the tracing level whencallingExtendedTask$new() matters.

The OTel span will be named based on the label created from the variable theExtendedTask is assigned to. If no label can be determined, the span willbe named⁠<anonymous>⁠. Similar to other Shiny OpenTelemetry spans, the spanwill also include source reference attributes and session ID attributes.

withOtelCollect("all", {  my_task <- ExtendedTask$new(function(...) { ... })})# Span recorded for this invocation: ExtendedTask my_taskmy_task$invoke(...)

Methods

Public methods

• ExtendedTask$new()

• ExtendedTask$invoke()

• ExtendedTask$status()

• ExtendedTask$result()

Methodnew()

Creates a newExtendedTask object.ExtendedTask should generally becreated either at the top of a server function, or at the top of a moduleserver function.

Usage

ExtendedTask$new(func)

Arguments

Methodinvoke()

Starts executing the long-running operation. If thisExtendedTask isalready running (meaning, a previous call toinvoke() is not yetcomplete) then enqueues this invocation until after the currentinvocation, and any already-enqueued invocation, completes.

Usage

ExtendedTask$invoke(...)

Arguments

Methodstatus()

This is a reactive read that invalidates the caller when the task'sstatus changes.

Returns one of the following values:

• "initial": ThisExtendedTask has not yet been invoked

• "running": An invocation is currently running

• "success": An invocation completed successfully, and a value can beretrieved via theresult() method

• "error": An invocation completed with an error, which will bere-thrown if you call theresult() method

Usage

ExtendedTask$status()

Methodresult()

Attempts to read the results of the most recent invocation. This is areactive read that invalidates as the task's status changes.

The actual behavior differs greatly depending on the current status ofthe task:

• "initial": Throws a silent error (likereq(FALSE)). Ifthis happens during output rendering, the output will be blanked out.

• "running": Throws a special silent error that, if it happens duringoutput rendering, makes the output appear "in progress" until furthernotice.

• "success": Returns the return value of the most recent invocation.

• "error": Throws whatever error was thrown by the most recentinvocation.

This method is intended to be called fairly naively by any output orreactive expression that cares about the output–you just have to beaware that if the result isn't ready for whatever reason, processing willstop in much the same way asreq(FALSE) does, but when the result isready you'll get invalidated, and when you run again the result should bethere.

Note that theresult() method is generally not meant to be used withobserveEvent(),eventReactive(),bindEvent(), orisolate() as theinvalidation will be ignored.

Usage

ExtendedTask$result()

Examples

library(shiny)library(bslib)library(mirai)# Set background processes for running tasksdaemons(1)# Reset when the app is stoppedonStop(function() daemons(0))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() {    mirai(      {        # Slow operation goes here        Sys.sleep(2)        sample(1:100, 1)      }    )  })  # 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)

Mock Shiny Session

Description

An R6 class suitable for testing purposes. Simulates, to theextent possible, the behavior of theShinySession class. Thesessionparameter provided to Shiny server functions and modules is an instance ofaShinySession in normal operation.

Most kinds of module and server testing do not require this class beinstantiated manually. See insteadtestServer().

In order to support advanced usage, instances ofMockShinySession areunlocked so that public methods and fields of instances may bemodified. For example, in order to test authentication workflows, theuser orgroups fields may be overridden. Modified instances ofMockShinySession may then be passed explicitly as thesession argumentoftestServer().

Public fields

Active bindings

Methods

Public methods

• MockShinySession$new()

• MockShinySession$onFlush()

• MockShinySession$onFlushed()

• MockShinySession$onEnded()

• MockShinySession$isEnded()

• MockShinySession$isClosed()

• MockShinySession$close()

• MockShinySession$cycleStartAction()

• MockShinySession$fileUrl()

• MockShinySession$setInputs()

• MockShinySession$.scheduleTask()

• MockShinySession$elapse()

• MockShinySession$.now()

• MockShinySession$defineOutput()

• MockShinySession$getOutput()

• MockShinySession$ns()

• MockShinySession$flushReact()

• MockShinySession$makeScope()

• MockShinySession$setEnv()

• MockShinySession$setReturned()

• MockShinySession$getReturned()

• MockShinySession$genId()

• MockShinySession$rootScope()

• MockShinySession$onUnhandledError()

• MockShinySession$unhandledError()

• MockShinySession$freezeValue()

• MockShinySession$onSessionEnded()

• MockShinySession$registerDownload()

• MockShinySession$getCurrentOutputInfo()

• MockShinySession$clone()

Methodnew()

Create a new MockShinySession.

Usage

MockShinySession$new()

MethodonFlush()

Define a callback to be invoked before a reactive flush

Usage

MockShinySession$onFlush(fun, once = TRUE)

Arguments

MethodonFlushed()

Define a callback to be invoked after a reactive flush

Usage

MockShinySession$onFlushed(fun, once = TRUE)

Arguments

MethodonEnded()

Define a callback to be invoked when the session ends

Usage

MockShinySession$onEnded(sessionEndedCallback)

Arguments

MethodisEnded()

ReturnsFALSE if the session has not yet been closed

Usage

MockShinySession$isEnded()

MethodisClosed()

ReturnsFALSE if the session has not yet been closed

Usage

MockShinySession$isClosed()

Methodclose()

Closes the session

Usage

MockShinySession$close()

MethodcycleStartAction()

Unsophisticated mock implementation that merely invokes

Usage

MockShinySession$cycleStartAction(callback)

Arguments

MethodfileUrl()

Base64-encode the given file. Needed for image rendering.

Usage

MockShinySession$fileUrl(name, file, contentType = "application/octet-stream")

Arguments

MethodsetInputs()

Sets reactive values associated with thesession$inputsobject and flushes the reactives.

Usage

MockShinySession$setInputs(...)

Arguments

Examples

\dontrun{session$setInputs(x=1, y=2)}

Method.scheduleTask()

An internal method which shouldn't be used by others.Schedulescallback for execution after some number ofmillismilliseconds.

Usage

MockShinySession$.scheduleTask(millis, callback)

Arguments

Methodelapse()

Simulate the passing of time by the given number of milliseconds.

Usage

MockShinySession$elapse(millis)

Arguments

Method.now()

An internal method which shouldn't be used by others.

Usage

MockShinySession$.now()

Returns

Elapsed time in milliseconds.

MethoddefineOutput()

An internal method which shouldn't be used by others.Defines an output in a way that sets private$currentOutputNameappropriately.

Usage

MockShinySession$defineOutput(name, func, label)

Arguments

MethodgetOutput()

An internal method which shouldn't be used by others. Forcesevaluation of any reactive dependencies of the output function.

Usage

MockShinySession$getOutput(name)

Arguments

Returns

The return value of the function responsible for rendering theoutput.

Methodns()

Returns the given id prefixed by this namespace's id.

Usage

MockShinySession$ns(id)

Arguments

Returns

The id with a namespace prefix.

MethodflushReact()

Trigger a reactive flush right now.

Usage

MockShinySession$flushReact()

MethodmakeScope()

Create and return a namespace-specific session proxy.

Usage

MockShinySession$makeScope(namespace)

Arguments

Returns

A new session proxy.

MethodsetEnv()

Set the environment associated with a testServer() call, butonly if it has not previously been set. This ensures that only theenvironment of the outermost module under test is the one retained. Inother words, the first assignment wins.

Usage

MockShinySession$setEnv(env)

Arguments

Returns

The providedenv.

MethodsetReturned()

Set the value returned by the module call and proactivelyflush. Note that this method may be called multiple times if modulesare nested. The last assignment, corresponding to an invocation ofsetReturned() in the outermost module, wins.

Usage

MockShinySession$setReturned(value)

Arguments

Returns

The providedvalue.

MethodgetReturned()

Get the value returned by the module call.

Usage

MockShinySession$getReturned()

Returns

The value returned by the module call

MethodgenId()

Generate a distinct character identifier for use as a proxynamespace.

Usage

MockShinySession$genId()

Returns

A character identifier unique to the current session.

MethodrootScope()

Provides a way to access the rootMockShinySession fromany descendant proxy.

Usage

MockShinySession$rootScope()

Returns

The rootMockShinySession.

MethodonUnhandledError()

Add an unhandled error callback.

Usage

MockShinySession$onUnhandledError(callback)

Arguments

Returns

A deregistration function.

MethodunhandledError()

Called by observers when a reactive expression errors.

Usage

MockShinySession$unhandledError(e, close = TRUE)

Arguments

MethodfreezeValue()

Freeze a value until the flush cycle completes.

Usage

MockShinySession$freezeValue(x, name)

Arguments

MethodonSessionEnded()

Registers the given callback to be invoked when the sessionis closed (i.e. the connection to the client has been severed). Thereturn value is a function which unregisters the callback. If multiplecallbacks are registered, the order in which they are invoked is notguaranteed.

Usage

MockShinySession$onSessionEnded(sessionEndedCallback)

Arguments

MethodregisterDownload()

Associated a downloadable file with the session.

Usage

MockShinySession$registerDownload(name, filename, contentType, content)

Arguments

MethodgetCurrentOutputInfo()

Get information about the output that is currently beingexecuted.

Usage

MockShinySession$getCurrentOutputInfo()

Returns

A list with with thename of the output. If no output iscurrently being executed, this will returnNULL.output, orNULL if no output is currently executing.

Methodclone()

The objects of this class are cloneable with this method.

Usage

MockShinySession$clone(deep = FALSE)

Arguments

Examples

## ------------------------------------------------## Method `MockShinySession$setInputs`## ------------------------------------------------## Not run: session$setInputs(x=1, y=2)## End(Not run)

Namespaced IDs for inputs/outputs

Description

TheNS function creates namespaced IDs out of bare IDs, by joiningthem usingns.sep as the delimiter. It is intended for use in Shinymodules. Seehttps://shiny.rstudio.com/articles/modules.html.

Usage

NS(namespace, id = NULL)ns.sep

Arguments

Format

An object of classcharacter of length 1.

Details

Shiny applications use IDs to identify inputs and outputs. These IDs must beunique within an application, as accidentally using the same input/output IDmore than once will result in unexpected behavior. The traditional solutionfor preventing name collisions isnamespaces; a namespace is to an IDas a directory is to a file. Use theNS function to turn a bare IDinto a namespaced one, by combining them withns.sep in between.

Value

Ifid is missing, returns a function that expects an id stringas its only argument and returns that id with the namespace prepended.

See Also

https://shiny.rstudio.com/articles/modules.html

Reporting progress (object-oriented API)

Description

Reporting progress (object-oriented API)

Reporting progress (object-oriented API)

Details

Reports progress to the user during long-running operations.

This package exposes two distinct programming APIs for working withprogress.withProgress() andsetProgress()together provide a simple function-based interface, while theProgress reference class provides an object-oriented API.

Instantiating aProgress object causes a progress panel to becreated, and it will be displayed the first time thesetmethod is called. Callingclose will cause the progress panelto be removed.

As of version 0.14, the progress indicators use Shiny's new notification API.If you want to use the old styling (for example, you may have used customizedCSS), you can usestyle="old" each time you callProgress$new(). If you don't want to set the style each timeProgress$new is called, you can instead callshinyOptions(progress.style="old") just once, inside the serverfunction.

Methods

Public methods

• Progress$new()

• Progress$set()

• Progress$inc()

• Progress$getMin()

• Progress$getMax()

• Progress$getValue()

• Progress$close()

• Progress$clone()

Methodnew()

Creates a new progress panel (but does not display it).

Usage

Progress$new(  session = getDefaultReactiveDomain(),  min = 0,  max = 1,  style = getShinyOption("progress.style", default = "notification"))

Arguments

Methodset()

Updates the progress panel. When called the first time, theprogress panel is displayed.

Usage

Progress$set(value = NULL, message = NULL, detail = NULL)

Arguments

Methodinc()

Likeset, this updates the progress panel. The differenceis thatinc increases the progress bar byamount, instead ofsetting it to a specific value.

Usage

Progress$inc(amount = 0.1, message = NULL, detail = NULL)

Arguments

MethodgetMin()

Returns the minimum value.

Usage

Progress$getMin()

MethodgetMax()

Returns the maximum value.

Usage

Progress$getMax()

MethodgetValue()

Returns the current value.

Usage

Progress$getValue()

Methodclose()

Removes the progress panel. Future calls toset andclose will be ignored.

Usage

Progress$close()

Methodclone()

The objects of this class are cloneable with this method.

Usage

Progress$clone(deep = FALSE)

Arguments

See Also

withProgress()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  plotOutput("plot"))server <- function(input, output, session) {  output$plot <- renderPlot({    progress <- Progress$new(session, min=1, max=15)    on.exit(progress$close())    progress$set(message = 'Calculation in progress',                 detail = 'This may take a while...')    for (i in 1:15) {      progress$set(value = i)      Sys.sleep(0.5)    }    plot(cars)  })}shinyApp(ui, server)}

Panel with absolute positioning

Description

Creates a panel whose contents are absolutely positioned.

Usage

absolutePanel(  ...,  top = NULL,  left = NULL,  right = NULL,  bottom = NULL,  width = NULL,  height = NULL,  draggable = FALSE,  fixed = FALSE,  cursor = c("auto", "move", "default", "inherit"))fixedPanel(  ...,  top = NULL,  left = NULL,  right = NULL,  bottom = NULL,  width = NULL,  height = NULL,  draggable = FALSE,  cursor = c("auto", "move", "default", "inherit"))

Arguments

Details

TheabsolutePanel function creates a⁠<div>⁠ tag whose CSSposition is set toabsolute (or fixed iffixed = TRUE). The wayabsolute positioning works in HTML is that absolute coordinates are specifiedrelative to its nearest parent element whose position is not set tostatic (which is the default), and if no such parent is found, thenrelative to the page borders. If you're not sure what that means, just keepin mind that you may get strange results if you useabsolutePanel frominside of certain types of panels.

ThefixedPanel function is the same asabsolutePanel withfixed = TRUE.

The position (top,left,right,bottom) and size(width,height) parameters are all optional, but you shouldspecify exactly two oftop,bottom, andheight andexactly two ofleft,right, andwidth for predictableresults.

Like most other distance parameters in Shiny, the position and sizeparameters take a number (interpreted as pixels) or a valid CSS size string,such as"100px" (100 pixels) or"25%".

For arcane HTML reasons, to have the panel fill the page or parent you shouldspecify0 fortop,left,right, andbottomrather than the more obviouswidth = "100%" andheight = "100%".

Value

An HTML element or list of elements.

Action button/link

Description

Creates an action button or link whose value is initially zero, and increments by oneeach time it is pressed.

Usage

actionButton(inputId, label, icon = NULL, width = NULL, disabled = FALSE, ...)actionLink(inputId, label, icon = NULL, ...)

Arguments

Server value

An integer of class"shinyActionButtonValue". This class differs fromordinary integers in that a value of 0 is considered "falsy".This implies two things:

• Event handlers (e.g.,observeEvent(),eventReactive()) won't execute on initial load.

• Input validation (e.g.,req(),need()) will fail on initial load.

See Also

observeEvent() andeventReactive()

Other input elements:checkboxGroupInput(),checkboxInput(),dateInput(),dateRangeInput(),fileInput(),numericInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  sliderInput("obs", "Number of observations", 0, 1000, 500),  actionButton("goButton", "Go!", class = "btn-success"),  plotOutput("distPlot"))server <- function(input, output) {  output$distPlot <- renderPlot({    # Take a dependency on input$goButton. This will run once initially,    # because the value changes from NULL to 0.    input$goButton    # Use isolate() to avoid dependency on input$obs    dist <- isolate(rnorm(input$obs))    hist(dist)  })}shinyApp(ui, server)}## Example of adding extra class valuesactionButton("largeButton", "Large Primary Button", class = "btn-primary btn-lg")actionLink("infoLink", "Information Link", class = "btn-info")

Resource Publishing

Description

Add, remove, or list directory of static resources to Shiny's web server,with the given path prefix. Primarily intended for package authors to makesupporting JavaScript/CSS files available to their components.

Usage

addResourcePath(prefix, directoryPath)resourcePaths()removeResourcePath(prefix)

Arguments

Details

Shiny provides two ways of serving static files (i.e., resources):

1. Static files under the⁠www/⁠ directory are automatically made availableunder a request path that begins with/.

2. addResourcePath() makes static files in adirectoryPath availableunder a request path that begins withprefix.

The second approach is primarily intended for package authors to makesupporting JavaScript/CSS files available to their components.

Tools for managing static resources published by Shiny's web server:

• addResourcePath() adds a directory of static resources.

• resourcePaths() lists the currently active resource mappings.

• removeResourcePath() removes a directory of static resources.

See Also

singleton()

Examples

addResourcePath('datasets', system.file('data', package='datasets'))resourcePaths()removeResourcePath('datasets')resourcePaths()# make sure all resources are removedlapply(names(resourcePaths()), removeResourcePath)

Apply input handlers to raw input values

Description

The purpose of this function is to make it possible for external packages totest Shiny inputs. It takes a named list of raw input values, applies inputhandlers to those values, and then returns a named list of the processedvalues.

Usage

applyInputHandlers(inputs, shinysession = getDefaultReactiveDomain())

Arguments

Details

The raw input values should be in a named list. Some values may have nameslike"x:shiny.date". This function would apply the"shiny.date"input handler to the value, and then rename the result to"x", in theoutput.

See Also

registerInputHandler

Add caching with reactivity to an object

Description

bindCache() adds cachingreactive() expressions and⁠render*⁠ functions(likerenderText(),renderTable(), ...).

Ordinaryreactive() expressions automatically cache theirmost recentvalue, which helps to avoid redundant computation in downstream reactives.bindCache() will cache all previous values (as long as they fit in thecache) and they can be shared across user sessions. This allowsbindCache() to dramatically improve performance when used correctly.

Usage

bindCache(x, ..., cache = "app")

Arguments

Details

bindCache() requires one or more expressions that are used to generate acache key, which is used to determine if a computation has occurredbefore and hence can be retrieved from the cache. If you're familiar with theconcept of memoizing pure functions (e.g., thememoise package), youcan think of the cache key as the input(s) to a pure function. As such, oneshould take care to make sure the use ofbindCache() ispure in the samesense, namely:

1. For a given key, the return value is always the same.

2. Evaluation has no side-effects.

In the example here, thebindCache() key consists ofinput$x andinput$y combined, and the value isinput$x * input$y. In this simpleexample, for any given key, there is only one possible returned value.

r <- reactive({ input$x * input$y }) %>%  bindCache(input$x, input$y)

The largest performance improvements occur when the cache key is fast tocompute and the reactive expression is slow to compute. To see if the valueshould be computed, a cached reactive evaluates the key, and then serializesand hashes the result. If the resulting hashed key is in the cache, then thecached reactive simply retrieves the previously calculated value and returnsit; if not, then the value is computed and the result is stored in the cachebefore being returned.

To compute the cache key,bindCache() hashes the contents of..., so it'sbest to avoid including large objects in a cache key since that can result inslow hashing. It's also best to avoid reference objects like environments andR6 objects, since the serialization of these objects may not capture relevantchanges.

If you want to use a large object as part of a cache key, it may make senseto do some sort of reduction on the data that still captures informationabout whether a value can be retrieved from the cache. For example, if youhave a large data set with timestamps, it might make sense to extract themost recent timestamp and return that. Then, instead of hashing the entiredata object, the cached reactive only needs to hash the timestamp.

r <- reactive({ compute(bigdata()) } %>%  bindCache({ extract_most_recent_time(bigdata()) })

For computations that are very slow, it often makes sense to pairbindCache() withbindEvent() so that no computation is performed untilthe user explicitly requests it (for more, see the Details section ofbindEvent()).

Cache keys and reactivity

Because thevalue expression (from the originalreactive()) iscached, it is not necessarily re-executed when someone retrieves a value,and therefore it can't be used to decide what objects to take reactivedependencies on. Instead, thekey is used to figure out which objectsto take reactive dependencies on. In short, the key expression is reactive,and value expression is no longer reactive.

Here's an example of what not to do: if the key isinput$x and the valueexpression is fromreactive({input$x + input$y}), then the resultingcached reactive will only take a reactive dependency oninput$x – itwon't recompute{input$x + input$y} when justinput$y changes.Moreover, the cache won't useinput$y as part of the key, and so it couldreturn incorrect values in the future when it retrieves values from thecache. (See the examples below for an example of this.)

A better cache key would be something like⁠input$x, input$y⁠. This doestwo things: it ensures that a reactive dependency is taken on bothinput$x andinput$y, and it also makes sure that both values arerepresented in the cache key.

In general,key should use the same reactive inputs asvalue, but thecomputation should be simpler. If there are other (non-reactive) valuesthat are consumed, such as external data sources, they should be used inthekey as well. Note that if thekey is large, it can make sense to dosome sort of reduction on it so that the serialization and hashing of thecache key is not too expensive.

Remember that the key isreactive, so it is not re-executed every singletime that someone accesses the cached reactive. It is only re-executed ifit has been invalidated by one of the reactives it depends on. Forexample, suppose we have this cached reactive:

r <- reactive({ input$x * input$y }) %>% bindCache(input$x, input$y)

In this case, the key expression is essentiallyreactive(list(input$x, input$y)) (there's a bit more to it, but that's a good enoughapproximation). The first timer() is called, it executes the key, thenfails to find it in the cache, so it executes the value expression,{ input$x + input$y }. Ifr() is called again, then it does not need tore-execute the key expression, because it has not been invalidated via achange toinput$x orinput$y; it simply returns the previous value.However, ifinput$x orinput$y changes, then the reactive expression willbe invalidated, and the next time that someone callsr(), the keyexpression will need to be re-executed.

Note that if the cached reactive is passed tobindEvent(), then the keyexpression will no longer be reactive; instead, the event expression will bereactive.

Cache scope

By default, whenbindCache() is used, it is scoped to the runningapplication. That means that it shares a cache with all user sessionsconnected to the application (within the R process). This is done with thecache parameter's default value,"app".

With an app-level cache scope, one user can benefit from the work done foranother user's session. In most cases, this is the best way to getperformance improvements from caching. However, in some cases, this couldleak information between sessions. For example, if the cache key does notfully encompass the inputs used by the value, then data could leak betweenthe sessions. Or if a user sees that a cached reactive returns its valuevery quickly, they may be able to infer that someone else has already usedit with the same values.

It is also possible to scope the cache to the session, withcache="session". This removes the risk of information leaking betweensessions, but then one session cannot benefit from computations performed inanother session.

It is possible to pass in caching objects directly tobindCache(). This can be useful if, for example, you want to use aparticular type of cache with specific cached reactives, or if you want touse acachem::cache_disk() that is shared across multiple processes andpersists beyond the current R session.

To use different settings for an application-scoped cache, you can callshinyOptions() at the top of your app.R, server.R, orglobal.R. For example, this will create a cache with 500 MB of spaceinstead of the default 200 MB:

shinyOptions(cache = cachem::cache_mem(max_size = 500e6))

To use different settings for a session-scoped cache, you can setsession$cache at the top of your server function. By default, it willcreate a 200 MB memory cache for each session, but you can replace it withsomething different. To use the session-scoped cache, you must also callbindCache() withcache="session". This will create a 100 MB cache forthe session:

function(input, output, session) {  session$cache <- cachem::cache_mem(max_size = 100e6)  ...}

If you want to use a cache that is shared across multiple R processes, youcan use acachem::cache_disk(). You can create a application-level sharedcache 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")))

This will create a subdirectory in your system temp directory namedmyapp-cache (replacemyapp-cache with a unique name ofyour choosing). On most platforms, this directory will be removed whenyour system reboots. This cache will persist across multiple starts andstops of the R process, as long as you do not reboot.

To have the cache persist even across multiple reboots, you can create thecache in a location outside of the temp directory. For example, it couldbe a subdirectory of the application:

shinyOptions(cache = cachem::cache_disk("./myapp-cache"))

In this case, resetting the cache will have to be done manually, by deletingthe directory.

You can also scope a cache to just one item, or selected items. To do that,create acachem::cache_mem() orcachem::cache_disk(), and pass itas thecache argument ofbindCache().

Computing cache keys

The actual cache key that is used internally takes value from evaluatingthe key expression(s) (from the... arguments) and combines it with the(unevaluated) value expression.

This means that if there are two cached reactives which have the sameresult from evaluating the key, but different value expressions, then theywill not need to worry about collisions.

However, if two cached reactives have identical key and value expressionsexpressions, they will share the cached values. This is useful when usingcache="app": there may be multiple user sessions which create separatecached reactive objects (because they are created from the same code in theserver function, but the server function is executed once for each usersession), and those cached reactive objects across sessions can sharevalues in the cache.

Async with cached reactives

With a cached reactive expression, the key and/or value expression can beasynchronous. In other words, they can be promises — not regular Rpromises, but rather objects provided by thepromises package, whichare similar to promises in JavaScript. (Seepromises::promise() for moreinformation.) You can also usemirai::mirai() orfuture::future()objects to run code in a separate process or even on a remote machine.

If the value returns a promise, then anything that consumes the cachedreactive must expect it to return a promise.

Similarly, if the key is a promise (in other words, if it is asynchronous),then the entire cached reactive must be asynchronous, since the key must becomputed asynchronously before it knows whether to compute the value or thevalue is retrieved from the cache. Anything that consumes the cachedreactive must therefore expect it to return a promise.

Developing render functions for caching

If you've implemented your own⁠render*()⁠ function, it may just work withbindCache(), but it is possible that you will need to make somemodifications. These modifications involve helpingbindCache() avoidcache collisions, dealing with internal state that may be set by the,render function, and modifying the data as it goes in and comes out ofthe cache.

You may need to provide acacheHint tocreateRenderFunction() (orhtmlwidgets::shinyRenderWidget(), if you've authored an htmlwidget) inorder forbindCache() to correctly compute a cache key.

The potential problem is a cache collision. Consider the following:

output$x1 <- renderText({ input$x }) %>% bindCache(input$x)output$x2 <- renderText({ input$x * 2 }) %>% bindCache(input$x)

Bothoutput$x1 andoutput$x2 useinput$x as part of their cache key,but if it were the only thing used in the cache key, then the two outputswould have a cache collision, and they would have the same output. To avoidthis, acache hint is automatically added whenrenderText() callscreateRenderFunction(). The cache hint is used as part of the actualcache key, in addition to the one passed tobindCache() by the user. Thecache hint can be viewed by calling the internal Shiny functionextractCacheHint():

r <- renderText({ input$x })shiny:::extractCacheHint(r)

This returns a nested list containing an item,⁠$origUserFunc$body⁠, whichin this case is the expression which was passed torenderText():{ input$x }. This (quoted) expression is mixed into the actual cachekey, and it is howoutput$x1 does not have collisions withoutput$x2.

For most developers of render functions, nothing extra needs to be done;the automatic inference of the cache hint is sufficient. Again, you cancheck it by callingshiny:::extractCacheHint(), and by testing therender function for cache collisions in a real application.

In some cases, however, the automatic cache hint inference is notsufficient, and it is necessary to provide a cache hint. This is trueforrenderPrint(). UnlikerenderText(), it wraps the user-providedexpression in another function, before passing it tocreateRenderFunction()(instead ofcreateRenderFunction()). Because the user code is wrapped inanother function,createRenderFunction() is not able to automaticallyextract the user-provided code and use it in the cache key. Instead,renderPrint callscreateRenderFunction(), it explicitly passes along acacheHint, which includes a label and the original user expression.

In general, if you need to provide acacheHint, it is best practice toprovide alabel id, the user'sexpr, as well as any other argumentsthat may influence the final value.

Forhtmlwidgets, it will try to automatically infer a cache hint;again, you can inspect the cache hint withshiny:::extractCacheHint() andalso test it in an application. If you do need to explicitly provide acache hint, pass it toshinyRenderWidget. For example:

renderMyWidget <- function(expr) {  q <- rlang::enquo0(expr)  htmlwidgets::shinyRenderWidget(    q,    myWidgetOutput,    quoted = TRUE,    cacheHint = list(label = "myWidget", userQuo = q)  )}

If yourrender function sets any internal state, you may find it usefulin your call tocreateRenderFunction() to usethecacheWriteHook and/orcacheReadHook parameters. These hooks arefunctions that run just before the object is stored in the cache, and justafter the object is retrieved from the cache. They can modify the datathat is stored and retrieved; this can be useful if extra information needsto be stored in the cache. They can also be used to modify the state of theapplication; for example, it can callcreateWebDependency() to makeJS/CSS resources available if the cached object is loaded in a different Rprocess. (See the source ofhtmlwidgets::shinyRenderWidget for an exampleof this.)

Uncacheable objects

Some render functions cannot be cached, typically because they have sideeffects or modify some external state, and they must re-execute each timein order to work properly.

For developers of such code, they should callcreateRenderFunction() (ormarkRenderFunction()) withcacheHint = FALSE.

Caching withrenderPlot()

WhenbindCache() is used withrenderPlot(), theheight andwidthpassed to the originalrenderPlot() are ignored. They are superseded bysizePolicy argument passed to 'bindCache. The default is:

sizePolicy = sizeGrowthRatio(width = 400, height = 400, growthRate = 1.2)

sizePolicy must be a function that takes a two-element numeric vector asinput, representing the width and height of the⁠<img>⁠ element in thebrowser window, and it must return a two-element numeric vector, representingthe pixel dimensions of the plot to generate. The purpose is to round theactual pixel dimensions from the browser to some other dimensions, so thatthis will not generate and cache images of every possible pixel dimension.SeesizeGrowthRatio() for more information on the default sizing policy.

See Also

bindEvent(),renderCachedPlot() for caching plots.

Examples

## Not run: rc <- bindCache(  x = reactive({    Sys.sleep(2)   # Pretend this is expensive    input$x * 100  }),  input$x)# Can make it prettier with the %>% operatorlibrary(magrittr)rc <- reactive({  Sys.sleep(2)  input$x * 100}) %>%  bindCache(input$x)## End(Not run)## Only run app examples in interactive R sessionsif (interactive()) {# Basic exampleshinyApp(  ui = fluidPage(    sliderInput("x", "x", 1, 10, 5),    sliderInput("y", "y", 1, 10, 5),    div("x * y: "),    verbatimTextOutput("txt")  ),  server = function(input, output) {    r <- reactive({      # The value expression is an _expensive_ computation      message("Doing expensive computation...")      Sys.sleep(2)      input$x * input$y    }) %>%      bindCache(input$x, input$y)    output$txt <- renderText(r())  })# Caching renderTextshinyApp(  ui = fluidPage(    sliderInput("x", "x", 1, 10, 5),    sliderInput("y", "y", 1, 10, 5),    div("x * y: "),    verbatimTextOutput("txt")  ),  server = function(input, output) {    output$txt <- renderText({      message("Doing expensive computation...")      Sys.sleep(2)      input$x * input$y    }) %>%      bindCache(input$x, input$y)  })# Demo of using events and caching with an actionButtonshinyApp(  ui = fluidPage(    sliderInput("x", "x", 1, 10, 5),    sliderInput("y", "y", 1, 10, 5),    actionButton("go", "Go"),    div("x * y: "),    verbatimTextOutput("txt")  ),  server = function(input, output) {    r <- reactive({      message("Doing expensive computation...")      Sys.sleep(2)      input$x * input$y    }) %>%      bindCache(input$x, input$y) %>%      bindEvent(input$go)      # The cached, eventified reactive takes a reactive dependency on      # input$go, but doesn't use it for the cache key. It uses input$x and      # input$y for the cache key, but doesn't take a reactive dependency on      # them, because the reactive dependency is superseded by addEvent().    output$txt <- renderText(r())  })}

Make an object respond only to specified reactive events

Description

Modify an object to respond to "event-like" reactive inputs, values, andexpressions.bindEvent() can be used with reactive expressions, renderfunctions, and observers. The resulting object takes a reactive dependency onthe... arguments, and not on the original object's code. This can, forexample, be used to make an observer execute only when a button is pressed.

bindEvent() was added in Shiny 1.6.0. When it is used withreactive() andobserve(), it does the same thing aseventReactive() andobserveEvent(). However,bindEvent() is more flexible: it can be combinedwithbindCache(), and it can also be used withrender functions (likerenderText() andrenderPlot()).

Usage

bindEvent(  x,  ...,  ignoreNULL = TRUE,  ignoreInit = FALSE,  once = FALSE,  label = NULL)

Arguments

Details

Shiny's reactive programming framework is primarily designed for calculatedvalues (reactive expressions) and side-effect-causing actions (observers)that respond toany of their inputs changing. That's often what isdesired in Shiny apps, but not always: sometimes you want to wait for aspecific action to be taken from the user, like clicking anactionButton(), before calculating an expression or taking an action. Areactive value or expression that is used to trigger other calculations inthis way is called anevent.

These situations demand a more imperative, "event handling" style ofprogramming that is possible–but not particularly intuitive–using thereactive programming primitivesobserve() andisolate().bindEvent()provides a straightforward API for event handling that wrapsobserve andisolate.

The... arguments are captured as expressions and combined into anevent expression. When this event expression is invalidated (when itsupstream reactive inputs change), that is anevent, and it will causethe original object's code to execute.

UsebindEvent() withobserve() whenever you want toperform an actionin response to an event. (This does the same thing asobserveEvent(),which was available in Shiny prior to version 1.6.0.) Note that"recalculate a value" does not generally count as performing an action –usereactive() for that.

UsebindEvent() withreactive() to create acalculated value thatonly updates in response to an event. This is just like a normalreactive expression except it ignores all the usual invalidations thatcome from its reactive dependencies; it only invalidates in response to thegiven event. (This does the same thing aseventReactive(), which wasavailable in Shiny prior to version 1.6.0.)

bindEvent() is often used withbindCache().

ignoreNULL and ignoreInit

bindEvent() takes anignoreNULL parameter that affects behavior whenthe event expression evaluates toNULL (or in the special case of anactionButton(),0). In these cases, ifignoreNULL isTRUE, then itwill raise a silentvalidation error. This is useful behaviorif you don't want to do the action or calculation when your app firststarts, but wait for the user to initiate the action first (like a "Submit"button); whereasignoreNULL=FALSE is desirable if you want to initiallyperform the action/calculation and just let the user re-initiate it (like a"Recalculate" button).

bindEvent() also takes anignoreInit argument. By default, reactiveexpressions and observers will run on the first reactive flush after theyare created (except if, at that moment, the event expression evaluates toNULL andignoreNULL isTRUE). But when responding to a click of anaction button, it may often be useful to setignoreInit toTRUE. Forexample, if you're setting up an observer to respond to a dynamicallycreated button, thenignoreInit = TRUE will guarantee that the actionwill only be triggered when the button is actually clicked, instead of alsobeing triggered when it is created/initialized. Similarly, if you'resetting up a reactive that responds to a dynamically created button used torefresh some data (which is then returned by thatreactive), then youshould usereactive(...) %>% bindEvent(..., ignoreInit = TRUE) if youwant to let the user decide if/when they want to refresh the data (since,depending on the app, this may be a computationally expensive operation).

Even thoughignoreNULL andignoreInit can be used for similar purposesthey are independent from one another. Here's the result of combiningthese:

ignoreNULL = TRUE andignoreInit = FALSE

This is the default. This combination means that reactive/observer codewill run every time that event expression is notNULL. If, at the time of creation, the event expression happenstonot beNULL, then the code runs.

ignoreNULL = FALSE andignoreInit = FALSE

This combination means that reactive/observer code willrun every time no matter what.

ignoreNULL = FALSE andignoreInit = TRUE

This combination means that reactive/observer code willnot run at the time of creation (becauseignoreInit = TRUE),but it will run every other time.

ignoreNULL = TRUE andignoreInit = TRUE

This combination means that reactive/observer code willnot at the time of creation (becauseignoreInit = TRUE).After that, the reactive/observer code will run every time thatthe event expression is notNULL.

Types of objects

bindEvent() can be used with reactive expressions, observers, and shinyrender functions.

WhenbindEvent() is used withreactive(), it creates a new reactiveexpression object.

WhenbindEvent() is used withobserve(), it alters the observer inplace. It can only be used with observers which have not yet executed.

Combining events and caching

In many cases, it makes sense to usebindEvent() along withbindCache(), because they each can reduce the amount of work done on theserver. For example, you could havesliderInputsx andy and areactive() that performs a time-consuming operation with those values.UsingbindCache() can speed things up, especially if there are multipleusers. But it might make sense to also not do the computation until theuser sets bothx andy, and then clicks on anactionButton namedgo.

To use both caching and events, the object should first be passed tobindCache(), thenbindEvent(). For example:

r <- reactive({   Sys.sleep(2)  # Pretend this is an expensive computation   input$x * input$y }) %>% bindCache(input$x, input$y) %>% bindEvent(input$go)

Anything that consumesr() will take a reactive dependency on the eventexpression given tobindEvent(), and not the cache key expression given tobindCache(). In this case, it is justinput$go.

Create a button for bookmarking/sharing

Description

AbookmarkButton is aactionButton() with a default labelthat consists of a link icon and the text "Bookmark...". It is meant to beused for bookmarking state.

Usage

bookmarkButton(  label = "Bookmark...",  icon = shiny::icon("link", lib = "glyphicon"),  title = "Bookmark this application's state and get a URL for sharing.",  ...,  id = "._bookmark_")

Arguments

See Also

enableBookmarking() for more examples.

Examples

## Only run these examples in interactive sessionsif (interactive()) {# This example shows how to use multiple bookmark buttons. If you only need# a single bookmark button, see examples in ?enableBookmarking.ui <- function(request) {  fluidPage(    tabsetPanel(id = "tabs",      tabPanel("One",        checkboxInput("chk1", "Checkbox 1"),        bookmarkButton(id = "bookmark1")      ),      tabPanel("Two",        checkboxInput("chk2", "Checkbox 2"),        bookmarkButton(id = "bookmark2")      )    )  )}server <- function(input, output, session) {  # Need to exclude the buttons from themselves being bookmarked  setBookmarkExclude(c("bookmark1", "bookmark2"))  # Trigger bookmarking with either button  observeEvent(input$bookmark1, {    session$doBookmark()  })  observeEvent(input$bookmark2, {    session$doBookmark()  })}enableBookmarking(store = "url")shinyApp(ui, server)}

Bootstrap libraries

Description

This function defines a set of web dependencies necessary for using Bootstrapcomponents in a web page.

Usage

bootstrapLib(theme = NULL)

Arguments

Details

It isn't necessary to call this function if you usebootstrapPage() orothers which usebootstrapPage, suchfluidPage(),navbarPage(),fillPage(), etc, because they already include the Bootstrap web dependencies.

Create a Bootstrap page

Description

Create a Shiny UI page that loads the CSS and JavaScript forBootstrap, and has no content in the pagebody (other than what you provide).

Usage

bootstrapPage(..., title = NULL, theme = NULL, lang = NULL)basicPage(...)

Arguments

Details

This function is primarily intended for users who are proficient in HTML/CSS,and know how to lay out pages in Bootstrap. Most applications should usefluidPage() along with layout functions likefluidRow() andsidebarLayout().

Value

A UI definition that can be passed to theshinyUI function.

Note

ThebasicPage function is deprecated, you should use thefluidPage() function instead.

See Also

fluidPage(),fixedPage()

Create an object representing brushing options

Description

This generates an object representing brushing options, to be passed as thebrush argument ofimageOutput() orplotOutput().

Usage

brushOpts(  id,  fill = "#9cf",  stroke = "#036",  opacity = 0.25,  delay = 300,  delayType = c("debounce", "throttle"),  clip = TRUE,  direction = c("xy", "x", "y"),  resetOnNew = FALSE)

Arguments

See Also

clickOpts() for clicking events.

Find rows of data selected on an interactive plot.

Description

brushedPoints() returns rows from a data frame which are under a brush.nearPoints() returns rows from a data frame which are near a click, hover,or double-click. Alternatively, setallRows = TRUE to return all rows fromthe input data with an additional columnselected_ that indicates whichrows of the would be selected.

Usage

brushedPoints(  df,  brush,  xvar = NULL,  yvar = NULL,  panelvar1 = NULL,  panelvar2 = NULL,  allRows = FALSE)nearPoints(  df,  coordinfo,  xvar = NULL,  yvar = NULL,  panelvar1 = NULL,  panelvar2 = NULL,  threshold = 5,  maxpoints = NULL,  addDist = FALSE,  allRows = FALSE)

Arguments

Value

A data frame based ondf, containing the observations selected by thebrush or near the click event. FornearPoints(), the rows will be sortedby distance to the event.

IfallRows = TRUE, then all rows will returned, along with a newselected_ column that indicates whether or not the point was selected.The output fromnearPoints() will no longer be sorted, but you cansetaddDist = TRUE to get an additional column that gives the pixeldistance to the pointer.

ggplot2

For plots created with ggplot2, it is not necessary to specify thecolumn names toxvar,yvar,panelvar1, andpanelvar2 as thatinformation can be automatically derived from the plot specification.

Note, however, that this will not work if you use a computed column, like⁠aes(speed/2, dist))⁠. Instead, we recommend that you modify the datafirst, and then make the plot with "raw" columns in the modified data.

Brushing

If x or y column is a factor, then it will be coerced to an integer vector.If it is a character vector, then it will be coerced to a factor and theninteger vector. This means that the brush will be considered to cover agiven character/factor value when it covers the center value.

If the brush is operating in just the x or y directions (e.g., withbrushOpts(direction = "x"), then this function will filter out pointsusing just the x or y variable, whichever is appropriate.

See Also

plotOutput() for example usage.

Examples

## Not run: # Note that in practice, these examples would need to go in reactives# or observers.# This would select all points within 5 pixels of the clicknearPoints(mtcars, input$plot_click)# Select just the nearest point within 10 pixels of the clicknearPoints(mtcars, input$plot_click, threshold = 10, maxpoints = 1)## End(Not run)

Customize busy indicator options

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 busydoing something else (e.g., a download, side-effect, etc), a page-levelpulsing banner is shown.

This function allows you to customize the appearance of these busy indicatorsby including the result of this function inside the app's UI. Note that,unlessspinner_selector (orfade_selector) is specified, the spinner/fadecustomization applies to the parent element. If the customization shouldinstead apply to the entire page, setspinner_selector = 'html' andfade_selector = 'html'.

Usage

busyIndicatorOptions(  ...,  spinner_type = NULL,  spinner_color = NULL,  spinner_size = NULL,  spinner_delay = NULL,  spinner_selector = NULL,  fade_opacity = NULL,  fade_selector = NULL,  pulse_background = NULL,  pulse_height = NULL,  pulse_speed = NULL)

Arguments

See Also

useBusyIndicators() to disable/enable busy indicators.

Examples

library(bslib)card_ui <- function(id, spinner_type = id) {  card(    busyIndicatorOptions(spinner_type = spinner_type),    card_header(paste("Spinner:", spinner_type)),    plotOutput(shiny::NS(id, "plot"))  )}card_server <- function(id, simulate = reactive()) {  moduleServer(    id = id,    function(input, output, session) {      output$plot <- renderPlot({        Sys.sleep(1)        simulate()        plot(x = rnorm(100), y = rnorm(100))      })    }  )}ui <- page_fillable(  useBusyIndicators(),  input_task_button("simulate", "Simulate", icon = icon("refresh")),  layout_columns(    card_ui("ring"),    card_ui("bars"),    card_ui("dots"),    card_ui("pulse"),    col_widths = 6  ))server <- function(input, output, session) {  simulate <- reactive(input$simulate)  card_server("ring", simulate)  card_server("bars", simulate)  card_server("dots", simulate)  card_server("pulse", simulate)}shinyApp(ui, server)

Invoke a Shiny module

Description

Note: As of Shiny 1.5.0, we recommend usingmoduleServer() instead ofcallModule(), because the syntax is a little easierto understand, and modules created withmoduleServer can be tested withtestServer().

Usage

callModule(module, id, ..., session = getDefaultReactiveDomain())

Arguments

Value

The return value, if any, from executing the module server function

Checkbox Group Input Control

Description

Create a group of checkboxes that can be used to toggle multiple choicesindependently. The server will receive the input as a character vector of theselected values.

Usage

checkboxGroupInput(  inputId,  label,  choices = NULL,  selected = NULL,  inline = FALSE,  width = NULL,  choiceNames = NULL,  choiceValues = NULL)

Arguments

Value

A list of HTML elements that can be added to a UI definition.

Server value

Character vector of values corresponding to the boxes that are checked.

See Also

checkboxInput(),updateCheckboxGroupInput()

Other input elements:actionButton(),checkboxInput(),dateInput(),dateRangeInput(),fileInput(),numericInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  checkboxGroupInput("variable", "Variables to show:",                     c("Cylinders" = "cyl",                       "Transmission" = "am",                       "Gears" = "gear")),  tableOutput("data"))server <- function(input, output, session) {  output$data <- renderTable({    mtcars[, c("mpg", input$variable), drop = FALSE]  }, rownames = TRUE)}shinyApp(ui, server)ui <- fluidPage(  checkboxGroupInput("icons", "Choose icons:",    choiceNames =      list(icon("calendar"), icon("bed"),           icon("cog"), icon("bug")),    choiceValues =      list("calendar", "bed", "cog", "bug")  ),  textOutput("txt"))server <- function(input, output, session) {  output$txt <- renderText({    icons <- paste(input$icons, collapse = ", ")    paste("You chose", icons)  })}shinyApp(ui, server)}

Checkbox Input Control

Description

Create a checkbox that can be used to specify logical values.

Usage

checkboxInput(inputId, label, value = FALSE, width = NULL)

Arguments

Value

A checkbox control that can be added to a UI definition.

Server value

TRUE if checked,FALSE otherwise.

See Also

checkboxGroupInput(),updateCheckboxInput()

Other input elements:actionButton(),checkboxGroupInput(),dateInput(),dateRangeInput(),fileInput(),numericInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  checkboxInput("somevalue", "Some value", FALSE),  verbatimTextOutput("value"))server <- function(input, output) {  output$value <- renderText({ input$somevalue })}shinyApp(ui, server)}

Control interactive plot point events

Description

These functions give control over theclick,dblClick andhover events generated byimageOutput() andplotOutput().

Usage

clickOpts(id, clip = TRUE)dblclickOpts(id, clip = TRUE, delay = 400)hoverOpts(  id,  delay = 300,  delayType = c("debounce", "throttle"),  clip = TRUE,  nullOutside = TRUE)

Arguments

See Also

brushOpts() for brushing events.

Create a column within a UI definition

Description

Create a column for use within afluidRow() orfixedRow()

Usage

column(width, ..., offset = 0)

Arguments

Value

A column that can be included within afluidRow() orfixedRow().

See Also

fluidRow(),fixedRow().

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  fluidRow(    column(4,      sliderInput("obs", "Number of observations:",                  min = 1, max = 1000, value = 500)    ),    column(8,      plotOutput("distPlot")    )  ))server <- function(input, output) {  output$distPlot <- renderPlot({    hist(rnorm(input$obs))  })}shinyApp(ui, server)ui <- fluidPage(  fluidRow(    column(width = 4,      "4"    ),    column(width = 3, offset = 2,      "3 offset 2"    )  ))shinyApp(ui, server = function(input, output) { })}

Conditional Panel

Description

Creates a panel that is visible or not, depending on the value of aJavaScript expression. The JS expression is evaluated once at startup andwhenever Shiny detects a relevant change in input/output.

Usage

conditionalPanel(condition, ..., ns = NS(NULL))

Arguments

Details

In the JS expression, you can refer toinput andoutputJavaScript objects that contain the current values of input and output. Forexample, if you have an input with an id offoo, then you can useinput.foo to read its value. (Be sure not to modify the input/outputobjects, as this may cause unpredictable behavior.)

Note

You are not recommended to use special JavaScript characters such as aperiod. in the input id's, but if you do use them anyway, forexample,inputId = "foo.bar", you will have to useinput["foo.bar"] instead ofinput.foo.bar to read the inputvalue.

Examples

## Only run this example in interactive R sessionsif (interactive()) {  ui <- fluidPage(    sidebarPanel(      selectInput("plotType", "Plot Type",        c(Scatter = "scatter", Histogram = "hist")      ),      # Only show this panel if the plot type is a histogram      conditionalPanel(        condition = "input.plotType == 'hist'",        selectInput(          "breaks", "Breaks",          c("Sturges", "Scott", "Freedman-Diaconis", "[Custom]" = "custom")        ),        # Only show this panel if Custom is selected        conditionalPanel(          condition = "input.breaks == 'custom'",          sliderInput("breakCount", "Break Count", min = 1, max = 50, value = 10)        )      )    ),    mainPanel(      plotOutput("plot")    )  )  server <- function(input, output) {    x <- rnorm(100)    y <- rnorm(100)    output$plot <- renderPlot({      if (input$plotType == "scatter") {        plot(x, y)      } else {        breaks <- input$breaks        if (breaks == "custom") {          breaks <- input$breakCount        }        hist(x, breaks = breaks)      }    })  }  shinyApp(ui, server)}

Implement custom render functions

Description

Developer-facing utilities for implementing a customrenderXXX() function.Before using these utilities directly, consider using thehtmlwidgets package to implement customoutputs (i.e., customrenderXXX()/xxxOutput() functions). That said,these utilities can be used more directly if a full-blown htmlwidget isn'tneeded and/or the user-supplied reactive expression needs to be wrapped inadditional call(s).

Usage

createRenderFunction(  func,  transform = function(value, session, name, ...) value,  outputFunc = NULL,  outputArgs = NULL,  cacheHint = "auto",  cacheWriteHook = NULL,  cacheReadHook = NULL)quoToFunction(q, label = sys.call(-1)[[1]], ..stacktraceon = FALSE)installExprFunction(  expr,  name,  eval.env = parent.frame(2),  quoted = FALSE,  assign.env = parent.frame(1),  label = sys.call(-1)[[1]],  wrappedWithLabel = TRUE,  ..stacktraceon = FALSE)

Arguments

Details

To implement a customrenderXXX() function, essentially 2 things are needed:

1. Capture the user's reactive expression as a function.

   • NewrenderXXX() functions can usequoToFunction() for this, butalready existingrenderXXX() functions that containenv andquotedparameters may want to continue usinginstallExprFunction() for betterlegacy support (see examples).

2. Flag the resulting function (from 1) as a Shiny rendering function andalso provide a UI container for displaying the result of the renderingfunction.

   • createRenderFunction() is currently recommended (instead ofmarkRenderFunction()) for this step (see examples).

Value

An annotated render function, ready to be assigned to anoutput slot.

Functions

• quoToFunction(): convert a quosure to a function.

• installExprFunction(): converts a user's reactiveexpr into afunction that's assigned to aname in theassign.env.

Examples

# A custom render function that repeats the supplied value 3 timesrenderTriple <- function(expr) {  # Wrap user-supplied reactive expression into a function  func <- quoToFunction(rlang::enquo0(expr))  createRenderFunction(    func,    transform = function(value, session, name, ...) {      paste(rep(value, 3), collapse=", ")    },    outputFunc = textOutput  )}# For better legacy support, consider using installExprFunction() over quoToFunction()renderTripleLegacy <- function(expr, env = parent.frame(), quoted = FALSE) {  func <- installExprFunction(expr, "func", env, quoted)  createRenderFunction(    func,    transform = function(value, session, name, ...) {      paste(rep(value, 3), collapse=", ")    },    outputFunc = textOutput  )}# Test render function from the consolereactiveConsole(TRUE)v <- reactiveVal("basic")r <- renderTriple({ v() })r()#> [1] "basic, basic, basic"# User can supply quoted code via rlang::quo(). Note that evaluation of the# expression happens when r2() is invoked, not when r2 is created.q <- rlang::quo({ v() })r2 <- rlang::inject(renderTriple(!!q))v("rlang")r2()#> [1] "rlang, rlang, rlang"# Supplying quoted code without rlang::quo() requires installExprFunction()expr <- quote({ v() })r3 <- renderTripleLegacy(expr, quoted = TRUE)v("legacy")r3()#> [1] "legacy, legacy, legacy"# The legacy approach also supports with quosures (env is ignored in this case)q <- rlang::quo({ v() })r4 <- renderTripleLegacy(q, quoted = TRUE)v("legacy-rlang")r4()#> [1] "legacy-rlang, legacy-rlang, legacy-rlang"# Turn off reactivity in the consolereactiveConsole(FALSE)

Create a web dependency

Description

Ensure that a file-based HTML dependency (from the htmltools package) can beserved over Shiny's HTTP server. This function works by usingaddResourcePath() to map the HTML dependency's directory to aURL.

Usage

createWebDependency(dependency, scrubFile = TRUE)

Arguments

Value

A single HTML dependency object that has anhref-named elementin itssrc.

Table output with the JavaScript DataTables library

Description

This function is deprecated, useDT::renderDT() instead. Itprovides a superset of functionality, better performance, and better userexperience.

Usage

dataTableOutput(outputId)renderDataTable(  expr,  options = NULL,  searchDelay = 500,  callback = "function(oTable) {}",  escape = TRUE,  env = parent.frame(),  quoted = FALSE,  outputArgs = list())

Arguments

Examples

## Only run this example in interactive R sessionsif (interactive()) {  # pass a callback function to DataTables using I()  shinyApp(    ui = fluidPage(      fluidRow(        column(12,          dataTableOutput('table')        )      )    ),    server = function(input, output) {      output$table <- renderDataTable(iris,        options = list(          pageLength = 5,          initComplete = I("function(settings, json) {alert('Done.');}")        )      )    }  )}

Create date input

Description

Creates a text input which, when clicked on, brings up a calendar thatthe user can click on to select dates.

Usage

dateInput(  inputId,  label,  value = NULL,  min = NULL,  max = NULL,  format = "yyyy-mm-dd",  startview = "month",  weekstart = 0,  language = "en",  width = NULL,  autoclose = TRUE,  datesdisabled = NULL,  daysofweekdisabled = NULL)

Arguments

Details

The dateformat string specifies how the date will be displayed inthe browser. It allows the following values:

• yy Year without century (12)

• yyyy Year with century (2012)

• mm Month number, with leading zero (01-12)

• m Month number, without leading zero (1-12)

• M Abbreviated month name

• MM Full month name

• dd Day of month with leading zero

• d Day of month without leading zero

• D Abbreviated weekday name

• DD Full weekday name

Server value

ADate vector of length 1.

See Also

dateRangeInput(),updateDateInput()

Other input elements:actionButton(),checkboxGroupInput(),checkboxInput(),dateRangeInput(),fileInput(),numericInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  dateInput("date1", "Date:", value = "2012-02-29"),  # Default value is the date in client's time zone  dateInput("date2", "Date:"),  # value is always yyyy-mm-dd, even if the display format is different  dateInput("date3", "Date:", value = "2012-02-29", format = "mm/dd/yy"),  # Pass in a Date object  dateInput("date4", "Date:", value = Sys.Date()-10),  # Use different language and different first day of week  dateInput("date5", "Date:",          language = "ru",          weekstart = 1),  # Start with decade view instead of default month view  dateInput("date6", "Date:",            startview = "decade"),  # Disable Mondays and Tuesdays.  dateInput("date7", "Date:", daysofweekdisabled = c(1,2)),  # Disable specific dates.  dateInput("date8", "Date:", value = "2012-02-29",            datesdisabled = c("2012-03-01", "2012-03-02")))shinyApp(ui, server = function(input, output) { })}

Create date range input

Description

Creates a pair of text inputs which, when clicked on, bring up calendars thatthe user can click on to select dates.

Usage

dateRangeInput(  inputId,  label,  start = NULL,  end = NULL,  min = NULL,  max = NULL,  format = "yyyy-mm-dd",  startview = "month",  weekstart = 0,  language = "en",  separator = " to ",  width = NULL,  autoclose = TRUE)

Arguments

Details

The dateformat string specifies how the date will be displayed inthe browser. It allows the following values:

• yy Year without century (12)

• yyyy Year with century (2012)

• mm Month number, with leading zero (01-12)

• m Month number, without leading zero (1-12)

• M Abbreviated month name

• MM Full month name

• dd Day of month with leading zero

• d Day of month without leading zero

• D Abbreviated weekday name

• DD Full weekday name

Server value

ADate vector of length 2.

See Also

dateInput(),updateDateRangeInput()

Other input elements:actionButton(),checkboxGroupInput(),checkboxInput(),dateInput(),fileInput(),numericInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  dateRangeInput("daterange1", "Date range:",                 start = "2001-01-01",                 end   = "2010-12-31"),  # Default start and end is the current date in the client's time zone  dateRangeInput("daterange2", "Date range:"),  # start and end are always specified in yyyy-mm-dd, even if the display  # format is different  dateRangeInput("daterange3", "Date range:",                 start  = "2001-01-01",                 end    = "2010-12-31",                 min    = "2001-01-01",                 max    = "2012-12-21",                 format = "mm/dd/yy",                 separator = " - "),  # Pass in Date objects  dateRangeInput("daterange4", "Date range:",                 start = Sys.Date()-10,                 end = Sys.Date()+10),  # Use different language and different first day of week  dateRangeInput("daterange5", "Date range:",                 language = "de",                 weekstart = 1),  # Start with decade view instead of default month view  dateRangeInput("daterange6", "Date range:",                 startview = "decade"))shinyApp(ui, server = function(input, output) { })}

Slow down a reactive expression with debounce/throttle

Description

Transforms a reactive expression by preventing its invalidation signals frombeing sent unnecessarily often. This lets you ignore a very "chatty" reactiveexpression until it becomes idle, which is useful when the intermediatevalues don't matter as much as the final value, and the downstreamcalculations that depend on the reactive expression take a long time.debounce andthrottle use different algorithms for slowing downinvalidation signals; see Details.

Usage

debounce(r, millis, priority = 100, domain = getDefaultReactiveDomain())throttle(r, millis, priority = 100, domain = getDefaultReactiveDomain())

Arguments

Details

This is not a true debounce/throttle in that it will not preventrfrom being called many times (in fact it may be called more times thanusual), but rather, the reactive invalidation signal that is produced byr is debounced/throttled instead. Therefore, these functions should beused whenr is cheap but the things it will trigger (downstreamoutputs and reactives) are expensive.

Debouncing means that every invalidation fromr will be held for thespecified time window. Ifr invalidates again within that time window,then the timer starts over again. This means that as long as invalidationscontinually arrive fromr within the time window, the debouncedreactive will not invalidate at all. Only after the invalidations stop (orslow down sufficiently) will the downstream invalidation be sent.

⁠ooo-oo-oo---- => -----------o-⁠

(In this graphical depiction, each character represents a unit of time, andthe time window is 3 characters.)

Throttling, on the other hand, delays invalidation if thethrottledreactive recently (within the time window) invalidated. Newrinvalidations do not reset the time window. This means that if invalidationscontinually come fromr within the time window, the throttled reactivewill invalidate regularly, at a rate equal to or slower than the timewindow.

⁠ooo-oo-oo---- => o--o--o--o---⁠

Limitations

Because R is single threaded, we can't come close to guaranteeing that thetiming of debounce/throttle (or any other timing-related functions inShiny) will be consistent or accurate; at the time we want to emit aninvalidation signal, R may be performing a different task and we have noway to interrupt it (nor would we necessarily want to if we could).Therefore, it's best to think of the time windows you pass to thesefunctions as minimums.

You may also see undesirable behavior if the amount of time spent doingdownstream processing for each change approaches or exceeds the timewindow: in this case, debounce/throttle may not have any effect, as thetime each subsequent event is considered is already after the time windowhas expired.

Examples

## Only run examples in interactive R sessionsif (interactive()) {options(device.ask.default = FALSE)library(shiny)library(magrittr)ui <- fluidPage(  plotOutput("plot", click = clickOpts("hover")),  helpText("Quickly click on the plot above, while watching the result table below:"),  tableOutput("result"))server <- function(input, output, session) {  hover <- reactive({    if (is.null(input$hover))      list(x = NA, y = NA)    else      input$hover  })  hover_d <- hover %>% debounce(1000)  hover_t <- hover %>% throttle(1000)  output$plot <- renderPlot({    plot(cars)  })  output$result <- renderTable({    data.frame(      mode = c("raw", "throttle", "debounce"),      x = c(hover()$x, hover_t()$x, hover_d()$x),      y = c(hover()$y, hover_t()$y, hover_d()$y)    )  })}shinyApp(ui, server)}

Shiny Developer Mode

Description

Developer Mode enables a number ofoptions() to make a developer's lifeeasier, like enabling non-minified JS and printing messages aboutdeprecated functions and options.

Shiny Developer Mode can be enabled by callingdevmode(TRUE) and disabledby callingdevmode(FALSE).

Please see the function descriptions for more details.

Usage

devmode(  devmode = getOption("shiny.devmode", TRUE),  verbose = getOption("shiny.devmode.verbose", TRUE))in_devmode()with_devmode(devmode, code, verbose = getOption("shiny.devmode.verbose", TRUE))devmode_inform(  message,  .frequency = "regularly",  .frequency_id = message,  .file = stderr(),  ...)register_devmode_option(name, devmode_message = NULL, devmode_default = NULL)get_devmode_option(  name,  default = NULL,  devmode_default = missing_arg(),  devmode_message = missing_arg())

Arguments

Functions

• devmode(): Function to set two options to enable/disable ShinyDeveloper Mode and Developer messages

• in_devmode(): Determines if Shiny is in Developer Mode. If thegetOption("shiny.devmode") is set toTRUE and not in testing insidetestthat, then Shiny Developer Mode is enabled.

• with_devmode(): Temporarily set Shiny Developer Mode and Developermessage verbosity

• devmode_inform(): If Shiny Developer Mode and verbosity are enabled,displays a message once every 8 hrs (by default)

• register_devmode_option(): Registers a Shiny Developer Mode option with an updatedvalue and Developer message. This registration method allows packageauthors to write one message in a single location.

  For example, the following Shiny Developer Mode options are registered:

  # Reload the Shiny app when a sourced R file changesregister_devmode_option(  "shiny.autoreload",  "Turning on shiny autoreload. To disable, call `options(shiny.autoreload = FALSE)`",  devmode_default = TRUE)# Use the unminified Shiny JavaScript file, `shiny.js`register_devmode_option(  "shiny.minified",  "Using full shiny javascript file. To use the minified version, call `options(shiny.minified = TRUE)`",  devmode_default = FALSE)# Display the full stack trace when errors occur during Shiny app executionregister_devmode_option(  "shiny.fullstacktrace",  "Turning on full stack trace. To disable, call `options(shiny.fullstacktrace = FALSE)`",  devmode_default = TRUE)

  Other known, non-Shiny Developer Mode options:

  • Sass:

  # Display the full stack trace when errors occur during Shiny app executionregister_devmode_option(  "sass.cache",  "Turning off sass cache. To use default caching, call `options(sass.cache = TRUE)`",  devmode_default = FALSE)

• get_devmode_option(): Provides a consistent way to change the expectedgetOption() behavior when Developer Mode is enabled. This method is verysimilar togetOption() where the globally set option takes precedence.See section "Avoiding direct dependency on shiny" forget_devmode_option() implementation details.

  Package developers: Register your Dev Mode option usingregister_devmode_option() to avoid supplying the samedevmode_defaultanddevmode_message values throughout your package. (This requires ashiny dependency.)

Avoiding direct dependency on shiny

The methods explained in this help file act independently from the rest ofShiny but are included to provide blue prints for your own packages. Ifyour package already has (or is willing to take) a dependency on Shiny, werecommend using the exported Shiny methods for consistent behavior. Notethat if you use exported Shiny methods, it will cause the Shiny package toload. This may be undesirable if your code will be used in (for example) RMarkdown documents that do not have a Shiny runtime (runtime: shiny).

If your package cannot take a dependency on Shiny, we recommendingre-implementing these two functions:

1. in_devmode():

   This function should returnTRUE ifgetOption("shiny.devmode") is set.In addition, we strongly recommend that it also checks to make suretestthat is not testing.

   in_devmode <- function() {  isTRUE(getOption("shiny.devmode", FALSE)) &&    !identical(Sys.getenv("TESTTHAT"), "true")}

2. get_devmode_option(name, default, devmode_default, devmode_message):

   This function is similar togetOption(name, default), but when the optionis not set, the default value changes depending on the Dev Mode.get_devmode_option() should be implemented as follows:

   • If not in Dev Mode:

     • ReturngetOption(name, default).

   • If in Dev Mode:

     • Get the global optiongetOption(name) value.

     • If the global option value is set:

       • Return the value.

     • If the global option value is not set:

       • Notify the developer that the Dev Mode default value will be used.

       • Return the Dev Mode default value.

   When notifying the developer that the default value has changed, we stronglyrecommend displaying a message (devmode_message) tostderr() once every 8hours usingrlang::inform(). This will keep the author up to date as towhich Dev Mode options are being altered. To allow developers a chance todisable Dev Mode messages, the message should be skipped ifgetOption("shiny.devmode.verbose", TRUE) is notTRUE.

   get_devmode_option <- function(name, default = NULL, devmode_default, devmode_message) {  if (!in_devmode()) {    # Dev Mode disabled, act like `getOption()`    return(getOption(name, default = default))  }  # Dev Mode enabled, update the default value for `getOption()`  getOption(name, default = {    # Notify developer    if (      !missing(devmode_message) &&      !is.null(devmode_message) &&      getOption("shiny.devmode.verbose", TRUE)    ) {      rlang::inform(        message = devmode_message,        .frequency = "regularly",        .frequency_id = devmode_message,        .file = stderr()      )    }    # Return Dev Mode default value `devmode_default`    devmode_default  })}

The remaining functions in this file are used for author convenience and arenot recommended for all reimplementation situations.

Examples

# Enable Shiny Developer modedevmode()in_devmode() # TRUE/FALSE?# Execute code in a temporary shiny dev modewith_devmode(TRUE, in_devmode()) # TRUE# Ex: Within shiny, we register the option "shiny.minified"#   to default to `FALSE` when in Dev Mode## Not run: register_devmode_option(  "shiny.minified",  devmode_message = paste0(    "Using full shiny javascript file. ",    "To use the minified version, call `options(shiny.minified = TRUE)`"  ),  devmode_default = FALSE)## End(Not run)# Used within `shiny::runApp(launch.browser)`get_devmode_option("shiny.minified", TRUE) # TRUE if Dev mode is offis_minified <- with_devmode(TRUE, {  get_devmode_option("shiny.minified", TRUE)})is_minified # FALSE

Create disk cache (deprecated)

Description

Create disk cache (deprecated)

Usage

diskCache(  dir = NULL,  max_size = 500 * 1024^2,  max_age = Inf,  max_n = Inf,  evict = c("lru", "fifo"),  destroy_on_finalize = FALSE,  missing = key_missing(),  exec_missing = deprecated(),  logfile = NULL)

Arguments

Reactive domains

Description

Reactive domains are a mechanism for establishing ownership over reactiveprimitives (like reactive expressions and observers), even if the set ofreactive primitives is dynamically created. This is useful for lifetimemanagement (i.e. destroying observers when the Shiny session that createdthem ends) and error handling.

Usage

getDefaultReactiveDomain()withReactiveDomain(domain, expr)onReactiveDomainEnded(domain, callback, failIfNull = FALSE)

Arguments

Details

At any given time, there can be either a single "default" reactive domainobject, or none (i.e. the reactive domain object isNULL). You canaccess the current default reactive domain by callinggetDefaultReactiveDomain.

Unless you specify otherwise, newly created observers and reactiveexpressions will be assigned to the current default domain (if any). You canoverride this assignment by providing an explicitdomain argument toreactive() orobserve().

For advanced usage, it's possible to override the default domain usingwithReactiveDomain. Thedomain argument will be made thedefault domain whileexpr is evaluated.

Implementers of new reactive primitives can useonReactiveDomainEndedas a convenience function for registering callbacks. If the reactive domainisNULL andfailIfNull isFALSE, then the callback willnever be invoked.

Create a download button or link

Description

Use these functions to create a download button or link; when clicked, itwill initiate a browser download. The filename and contents are specified bythe correspondingdownloadHandler() defined in the serverfunction.

Usage

downloadButton(  outputId,  label = "Download",  class = NULL,  ...,  icon = shiny::icon("download"))downloadLink(outputId, label = "Download", class = NULL, ...)

Arguments

See Also

downloadHandler()

Examples

## Not run: ui <- fluidPage(  p("Choose a dataset to download."),  selectInput("dataset", "Dataset", choices = c("mtcars", "airquality")),  downloadButton("downloadData", "Download"))server <- function(input, output) {  # The requested dataset  data <- reactive({    get(input$dataset)  })  output$downloadData <- downloadHandler(    filename = function() {      # Use the selected dataset as the suggested file name      paste0(input$dataset, ".csv")    },    content = function(file) {      # Write the dataset to the `file` that will be downloaded      write.csv(data(), file)    }  )}shinyApp(ui, server)## End(Not run)

File Downloads

Description

Allows content from the Shiny application to be made available to the user asfile downloads (for example, downloading the currently visible data as a CSVfile). Both filename and contents can be calculated dynamically at the timethe user initiates the download. Assign the return value to a slot onoutput in your server function, and in the UI usedownloadButton() ordownloadLink() to make thedownload available.

Usage

downloadHandler(filename, content, contentType = NULL, outputArgs = list())

Arguments

See Also

• The download handler, like other outputs, is suspended (disabled) bydefault for download buttons and links that are hidden. UseoutputOptions() to control this behavior, e.g. to setsuspendWhenHidden = FALSE if the download is initiated byprogrammatically clicking on the download button using JavaScript.

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  downloadButton("downloadData", "Download"))server <- function(input, output) {  # Our dataset  data <- mtcars  output$downloadData <- downloadHandler(    filename = function() {      paste("data-", Sys.Date(), ".csv", sep="")    },    content = function(file) {      write.csv(data, file)    }  )}shinyApp(ui, server)}

Enable bookmarking for a Shiny application

Description

There are two types of bookmarking: saving an application's state to disk onthe server, and encoding the application's state in a URL. For state that hasbeen saved to disk, the state can be restored with the corresponding stateID. For URL-encoded state, the state of the application is encoded in theURL, and no server-side storage is needed.

URL-encoded bookmarking is appropriate for applications where there not manyinput values that need to be recorded. Some browsers have a length limit forURLs of about 2000 characters, and if there are many inputs, the length ofthe URL can exceed that limit.

Saved-on-server bookmarking is appropriate when there are many inputs, orwhen the bookmarked state requires storing files.

Usage

enableBookmarking(store = c("url", "server", "disable"))

Arguments

Details

For restoring state to work properly, the UI must be a function that takesone argument,request. In most Shiny applications, the UI is not afunction; it might have the formfluidPage(....). Converting it to afunction is as simple as wrapping it in a function, as infunction(request) { fluidPage(....) }.

By default, all input values will be bookmarked, except for the values ofpasswordInputs. fileInputs will be saved if the state is saved on a server,but not if the state is encoded in a URL.

When bookmarking state, arbitrary values can be stored, by passing a functionas theonBookmark argument. That function will be passed aShinySaveState object. Thevalues field of the object is a listwhich can be manipulated to save extra information. Additionally, if thestate is being saved on the server, and thedir field of that objectcan be used to save extra information to files in that directory.

For saved-to-server state, this is how the state directory is chosen:

• If running in a hosting environment such as Shiny Server orConnect, the hosting environment will choose the directory.

• If running an app in a directory withrunApp(), thesaved states will be saved in a subdirectory of the app calledshiny_bookmarks.

• If running a Shiny app object that is generated from code (not runfrom a directory), the saved states will be saved in a subdirectory ofthe current working directory called shiny_bookmarks.

When used withshinyApp(), this function must be called beforeshinyApp(), or in theshinyApp()'sonStart function. Analternative to calling theenableBookmarking() function is to use theenableBookmarkingargument forshinyApp(). See examplesbelow.

See Also

onBookmark(),onBookmarked(),onRestore(), andonRestored() for registeringcallback functions that are invoked when the state is bookmarked orrestored.

Also seeupdateQueryString().

Examples

## Only run these examples in interactive R sessionsif (interactive()) {# Basic example with state encoded in URLui <- function(request) {  fluidPage(    textInput("txt", "Text"),    checkboxInput("chk", "Checkbox"),    bookmarkButton()  )}server <- function(input, output, session) { }enableBookmarking("url")shinyApp(ui, server)# An alternative to calling enableBookmarking(): use shinyApp's# enableBookmarking argumentshinyApp(ui, server, enableBookmarking = "url")# Same basic example with state saved to diskenableBookmarking("server")shinyApp(ui, server)# Save/restore arbitrary valuesui <- function(req) {  fluidPage(    textInput("txt", "Text"),    checkboxInput("chk", "Checkbox"),    bookmarkButton(),    br(),    textOutput("lastSaved")  )}server <- function(input, output, session) {  vals <- reactiveValues(savedTime = NULL)  output$lastSaved <- renderText({    if (!is.null(vals$savedTime))      paste("Last saved at", vals$savedTime)    else      ""  })  onBookmark(function(state) {    vals$savedTime <- Sys.time()    # state is a mutable reference object, and we can add arbitrary values    # to it.    state$values$time <- vals$savedTime  })  onRestore(function(state) {    vals$savedTime <- state$values$time  })}enableBookmarking(store = "url")shinyApp(ui, server)# Usable with dynamic UI (set the slider, then change the text input,# click the bookmark button)ui <- function(request) {  fluidPage(    sliderInput("slider", "Slider", 1, 100, 50),    uiOutput("ui"),    bookmarkButton()  )}server <- function(input, output, session) {  output$ui <- renderUI({    textInput("txt", "Text", input$slider)  })}enableBookmarking("url")shinyApp(ui, server)# Exclude specific inputs (The only input that will be saved in this# example is chk)ui <- function(request) {  fluidPage(    passwordInput("pw", "Password"), # Passwords are never saved    sliderInput("slider", "Slider", 1, 100, 50), # Manually excluded below    checkboxInput("chk", "Checkbox"),    bookmarkButton()  )}server <- function(input, output, session) {  setBookmarkExclude("slider")}enableBookmarking("url")shinyApp(ui, server)# Update the browser's location bar every time an input changes. This should# not be used with enableBookmarking("server"), because that would create a# new saved state on disk every time the user changes an input.ui <- function(req) {  fluidPage(    textInput("txt", "Text"),    checkboxInput("chk", "Checkbox")  )}server <- function(input, output, session) {  observe({    # Trigger this observer every time an input changes    reactiveValuesToList(input)    session$doBookmark()  })  onBookmarked(function(url) {    updateQueryString(url)  })}enableBookmarking("url")shinyApp(ui, server)# Save/restore uploaded filesui <- function(request) {  fluidPage(    sidebarLayout(      sidebarPanel(        fileInput("file1", "Choose CSV File", multiple = TRUE,          accept = c(            "text/csv",            "text/comma-separated-values,text/plain",            ".csv"          )        ),        tags$hr(),        checkboxInput("header", "Header", TRUE),        bookmarkButton()      ),      mainPanel(        tableOutput("contents")      )    )  )}server <- function(input, output) {  output$contents <- renderTable({    inFile <- input$file1    if (is.null(inFile))      return(NULL)    if (nrow(inFile) == 1) {      read.csv(inFile$datapath, header = input$header)    } else {      data.frame(x = "multiple files")    }  })}enableBookmarking("server")shinyApp(ui, server)}

Register expressions for export in test mode

Description

This function registers expressions that will be evaluated when a test exportevent occurs. These events are triggered by accessing a snapshot URL.

Usage

exportTestValues(  ...,  quoted_ = FALSE,  env_ = parent.frame(),  session_ = getDefaultReactiveDomain())

Arguments

Details

This function only has an effect if the app is launched in test mode. This isdone by callingrunApp() withtest.mode=TRUE, or by setting theglobal optionshiny.testmode toTRUE.

Examples

## Only run this example in interactive R sessionsif (interactive()) {options(shiny.testmode = TRUE)# This application shows the test snapshot URL; clicking on it will# fetch the input, output, and exported values in JSON format.shinyApp(  ui = basicPage(    h4("Snapshot URL: "),    uiOutput("url"),    h4("Current values:"),    verbatimTextOutput("values"),    actionButton("inc", "Increment x")  ),  server = function(input, output, session) {    vals <- reactiveValues(x = 1)    y <- reactive({ vals$x + 1 })    observeEvent(input$inc, {      vals$x <<- vals$x + 1    })    exportTestValues(      x = vals$x,      y = y()    )    output$url <- renderUI({      url <- session$getTestSnapshotUrl(format="json")      a(href = url, url)    })    output$values <- renderText({      paste0("vals$x: ", vals$x, "\ny: ", y())    })  })}

Convert an expression to a function

Description

Please useinstallExprFunction() for a betterdebugging experience (Shiny 0.8.0). If theexpr andquoted parameters are not needed, please seequoToFunction() (Shiny 1.6.0).

Usage

exprToFunction(expr, env = parent.frame(), quoted = FALSE)

Arguments

Details

Similar toinstallExprFunction() but doesn't register debug hooks.

See Also

installExprFunction() for the modern approach to converting an expression to a function

File Upload Control

Description

Create a file upload control that can be used to upload one or more files.

Usage

fileInput(  inputId,  label,  multiple = FALSE,  accept = NULL,  width = NULL,  buttonLabel = "Browse...",  placeholder = "No file selected",  capture = NULL)

Arguments

Details

Whenever a file upload completes, the corresponding input variable is set toa dataframe. See the⁠Server value⁠ section.

Each time files are uploaded, they are written to a new random subdirectoryinside of R's process-level temporary directory. The Shiny user session keepstrack of all uploads in the session, and when the session ends, Shiny deletesall of the subdirectories where files where uploaded to.

Server value

Adata.frame that contains one row for each selected file, and followingcolumns:

name

The filename provided by the web browser. This isnot the path to read to get at the actual data that was uploaded(seedatapath column).

size

The size of the uploaded data, inbytes.

type

The MIME type reported by the browser (for example,text/plain), or empty string if the browser didn't know.

datapath

The path to a temp file that contains the data that wasuploaded. This file may be deleted if the user performs another uploadoperation.

See Also

Other input elements:actionButton(),checkboxGroupInput(),checkboxInput(),dateInput(),dateRangeInput(),numericInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  sidebarLayout(    sidebarPanel(      fileInput("file1", "Choose CSV File", accept = ".csv"),      checkboxInput("header", "Header", TRUE)    ),    mainPanel(      tableOutput("contents")    )  ))server <- function(input, output) {  output$contents <- renderTable({    file <- input$file1    ext <- tools::file_ext(file$datapath)    req(file)    validate(need(ext == "csv", "Please upload a csv file"))    read.csv(file$datapath, header = input$header)  })}shinyApp(ui, server)}

Create a page that fills the window

Description

fillPage creates a page whose height and width always fill theavailable area of the browser window.

Usage

fillPage(  ...,  padding = 0,  title = NULL,  bootstrap = TRUE,  theme = NULL,  lang = NULL)

Arguments

Details

ThefluidPage() andfixedPage() functions are usedfor creating web pages that are laid out from the top down, leavingwhitespace at the bottom if the page content's height is smaller than thebrowser window, and scrolling if the content is larger than the window.

fillPage is designed to latch the document body's size to the size ofthe window. This makes it possible to fill it with content that also scalesto the size of the window.

For example,fluidPage(plotOutput("plot", height = "100%")) will notwork as expected; the plot element's effective height will be0,because the plot's containing elements (⁠<div>⁠ and⁠<body>⁠) haveautomatic height; that is, they determine their own height based onthe height of their contained elements. However,fillPage(plotOutput("plot", height = "100%")) will work becausefillPage fixes the⁠<body>⁠ height at 100% of the window height.

Note thatfillPage(plotOutput("plot")) will not cause the plot to fillthe page. Like most Shiny output widgets,plotOutput's default heightis a fixed number of pixels. You must explicitly setheight = "100%"if you want a plot (or htmlwidget, say) to fill its container.

One must be careful what layouts/panels/elements come between thefillPage and the plots/widgets. Any container that has an automaticheight will cause children withheight = "100%" to misbehave. Stickto functions that are designed for fill layouts, such as the ones in thispackage.

See Also

Other layout functions:fixedPage(),flowLayout(),fluidPage(),navbarPage(),sidebarLayout(),splitLayout(),verticalLayout()

Examples

fillPage(  tags$style(type = "text/css",    ".half-fill { width: 50%; height: 100%; }",    "#one { float: left; background-color: #ddddff; }",    "#two { float: right; background-color: #ccffcc; }"  ),  div(id = "one", class = "half-fill",    "Left half"  ),  div(id = "two", class = "half-fill",    "Right half"  ),  padding = 10)fillPage(  fillRow(    div(style = "background-color: red; width: 100%; height: 100%;"),    div(style = "background-color: blue; width: 100%; height: 100%;")  ))

Flex Box-based row/column layouts

Description

Creates row and column layouts with proportionally-sized cells, using theFlex Box layout model of CSS3. These can be nested to create arbitraryproportional-grid layouts.Warning: Flex Box is not well supportedby Internet Explorer, so these functions should only be used where modernbrowsers can be assumed.

Usage

fillRow(..., flex = 1, width = "100%", height = "100%")fillCol(..., flex = 1, width = "100%", height = "100%")

Arguments

Details

If you try to usefillRow andfillCol inside of otherShiny containers, such assidebarLayout(),navbarPage(), or eventags$div, you will probably findthat they will not appear. This is due tofillRow andfillColdefaulting toheight="100%", which will only work inside ofcontainers that have determined their own size (rather than shrinking tothe size of their contents, as is usually the case in HTML).

To avoid this problem, you have two options:

• only usefillRow/fillCol inside offillPage,fillRow, orfillCol

• provide an explicitheight argument tofillRow/fillCol

Examples

# Only run this example in interactive R sessions.if (interactive()) {ui <- fillPage(fillRow(  plotOutput("plotLeft", height = "100%"),  fillCol(    plotOutput("plotTopRight", height = "100%"),    plotOutput("plotBottomRight", height = "100%")  )))server <- function(input, output, session) {  output$plotLeft <- renderPlot(plot(cars))  output$plotTopRight <- renderPlot(plot(pressure))  output$plotBottomRight <- renderPlot(plot(AirPassengers))}shinyApp(ui, server)}

Create a page with a fixed layout

Description

Functions for creating fixed page layouts. A fixed page layout consists ofrows which in turn include columns. Rows exist for the purpose of making suretheir elements appear on the same line (if the browser has adequate width).Columns exist for the purpose of defining how much horizontal space within a12-unit wide grid it's elements should occupy. Fixed pages limit their widthto 940 pixels on a typical display, and 724px or 1170px on smaller and largerdisplays respectively.

Usage

fixedPage(..., title = NULL, theme = NULL, lang = NULL)fixedRow(...)

Arguments

Details

To create a fixed page use thefixedPage function and includeinstances offixedRow andcolumn() within it. Note thatunlikefluidPage(), fixed pages cannot make use of higher-levellayout functions likesidebarLayout, rather, all layout must be donewithfixedRow andcolumn.

Value

A UI definition that can be passed to theshinyUI function.

Note

See the Shiny Application Layout Guide for additional details on laying out fixedpages.

See Also

column()

Other layout functions:fillPage(),flowLayout(),fluidPage(),navbarPage(),sidebarLayout(),splitLayout(),verticalLayout()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fixedPage(  title = "Hello, Shiny!",  fixedRow(    column(width = 4,      "4"    ),    column(width = 3, offset = 2,      "3 offset 2"    )  ))shinyApp(ui, server = function(input, output) { })}

Flow layout

Description

Lays out elements in a left-to-right, top-to-bottom arrangement. The elementson a given row will be top-aligned with each other. This layout will not workwell with elements that have a percentage-based width (e.g.plotOutput() at its default setting ofwidth = "100%").

Usage

flowLayout(..., cellArgs = list())

Arguments

See Also

Other layout functions:fillPage(),fixedPage(),fluidPage(),navbarPage(),sidebarLayout(),splitLayout(),verticalLayout()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- flowLayout(  numericInput("rows", "How many rows?", 5),  selectInput("letter", "Which letter?", LETTERS),  sliderInput("value", "What value?", 0, 100, 50))shinyApp(ui, server = function(input, output) { })}

Create a page with fluid layout

Description

Functions for creating fluid page layouts. A fluid page layout consists ofrows which in turn include columns. Rows exist for the purpose of making suretheir elements appear on the same line (if the browser has adequate width).Columns exist for the purpose of defining how much horizontal space within a12-unit wide grid it's elements should occupy. Fluid pages scale theircomponents in realtime to fill all available browser width.

Usage

fluidPage(..., title = NULL, theme = NULL, lang = NULL)fluidRow(...)

Arguments

Details

To create a fluid page use thefluidPage function and includeinstances offluidRow andcolumn() within it. As analternative to low-level row and column functions you can also usehigher-level layout functions likesidebarLayout().

Value

A UI definition that can be passed to theshinyUI function.

Note

See the Shiny-Application-Layout-Guide for additional details on laying out fluidpages.

See Also

column()

Other layout functions:fillPage(),fixedPage(),flowLayout(),navbarPage(),sidebarLayout(),splitLayout(),verticalLayout()

Examples

## Only run examples in interactive R sessionsif (interactive()) {# Example of UI with fluidPageui <- fluidPage(  # Application title  titlePanel("Hello Shiny!"),  sidebarLayout(    # Sidebar with a slider input    sidebarPanel(      sliderInput("obs",                  "Number of observations:",                  min = 0,                  max = 1000,                  value = 500)    ),    # Show a plot of the generated distribution    mainPanel(      plotOutput("distPlot")    )  ))# Server logicserver <- function(input, output) {  output$distPlot <- renderPlot({    hist(rnorm(input$obs))  })}# Complete app with UI and server componentsshinyApp(ui, server)# UI demonstrating column layoutsui <- fluidPage(  title = "Hello Shiny!",  fluidRow(    column(width = 4,      "4"    ),    column(width = 3, offset = 2,      "3 offset 2"    )  ))shinyApp(ui, server = function(input, output) { })}

Freeze a reactive value

Description

These functions freeze areactiveVal(), or an element of areactiveValues(). If the value is accessed while frozen, a"silent" exception is raised and the operation is stopped. This is the samething that happens ifreq(FALSE) is called. The value is thawed(un-frozen; accessing it will no longer raise an exception) when the currentreactive domain is flushed. In a Shiny application, this occurs after all ofthe observers are executed.NOTE: We are considering deprecatingfreezeReactiveVal, andfreezeReactiveValue except whenx isinput.If this affects your app, please let us know by leaving a comment onthis GitHub issue.

Usage

freezeReactiveVal(x)freezeReactiveValue(x, name)

Arguments

See Also

req()

Examples

## Only run this examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  selectInput("data", "Data Set", c("mtcars", "pressure")),  checkboxGroupInput("cols", "Columns (select 2)", character(0)),  plotOutput("plot"))server <- function(input, output, session) {  observe({    data <- get(input$data)    # Sets a flag on input$cols to essentially do req(FALSE) if input$cols    # is accessed. Without this, an error will momentarily show whenever a    # new data set is selected.    freezeReactiveValue(input, "cols")    updateCheckboxGroupInput(session, "cols", choices = names(data))  })  output$plot <- renderPlot({    # When a new data set is selected, input$cols will have been invalidated    # above, and this will essentially do the same as req(FALSE), causing    # this observer to stop and raise a silent exception.    cols <- input$cols    data <- get(input$data)    if (length(cols) == 2) {      plot(data[[ cols[1] ]], data[[ cols[2] ]])    }  })}shinyApp(ui, server)}

Get output information

Description

Returns information about the currently executing output, including itsname (i.e.,outputId);and in some cases, relevant sizing and styling information.

Usage

getCurrentOutputInfo(session = getDefaultReactiveDomain())

Arguments

Value

NULL if called outside of an output context; otherwise,a list which includes:

• Thename of the output (reported for any output).

• If the output is aplotOutput() orimageOutput(), then:

  • height: a reactive expression which returns the height in pixels.

  • width: a reactive expression which returns the width in pixels.

• If the output is aplotOutput(),imageOutput(), or contains ashiny-report-theme class, then:

  • bg: a reactive expression which returns the background color.

  • fg: a reactive expression which returns the foreground color.

  • accent: a reactive expression which returns the hyperlink color.

  • font: a reactive expression which returns a list of font information, including:

    • families: a character vector containing the CSSfont-family property.

    • size: a character string containing the CSSfont-size property

Examples

if (interactive()) {  shinyApp(    fluidPage(      tags$style(HTML("body {background-color: black; color: white; }")),      tags$style(HTML("body a {color: purple}")),      tags$style(HTML("#info {background-color: teal; color: orange; }")),      plotOutput("p"),      "Computed CSS styles for the output named info:",      tagAppendAttributes(        textOutput("info"),        class = "shiny-report-theme"      )    ),    function(input, output) {      output$p <- renderPlot({        info <- getCurrentOutputInfo()        par(bg = info$bg(), fg = info$fg(), col.axis = info$fg(), col.main = info$fg())        plot(1:10, col = info$accent(), pch = 19)        title("A simple R plot that uses its CSS styling")      })      output$info <- renderText({        info <- getCurrentOutputInfo()        jsonlite::toJSON(          list(            bg = info$bg(),            fg = info$fg(),            accent = info$accent(),            font = info$font()          ),          auto_unbox = TRUE        )      })    }  )}

Obtain Shiny's Bootstrap Sass theme

Description

Intended for use by Shiny developers to create Shiny bindings with intelligentstyling based on thebootstrapLib()'stheme value.

Usage

getCurrentTheme()

Value

If called at render-time (i.e., inside ahtmltools::tagFunction()),andbootstrapLib()'stheme has been set to abslib::bs_theme()object, then this returns thetheme. Otherwise, this returnsNULL.

See Also

getCurrentOutputInfo(),bootstrapLib(),htmltools::tagFunction()

Get the query string / hash component from the URL

Description

Two user friendly wrappers for getting the query string and the hashcomponent from the app's URL.

Usage

getQueryString(session = getDefaultReactiveDomain())getUrlHash(session = getDefaultReactiveDomain())

Arguments

Details

These can be particularly useful if you want to display different contentdepending on the values in the query string / hash (e.g. instead of basingthe conditional on an input or a calculated reactive, you can base it on thequery string). However, note that, if you're changing the query string / hashprogrammatically from within the server code, you must use⁠updateQueryString(_yourNewQueryString_, mode = "push")⁠. The defaultmode forupdateQueryString is"replace", which doesn'traise any events, so any observers or reactives that depend on it willnot get triggered. However, if you're changing the query string / hashdirectly by typing directly in the browser and hitting enter, you don't haveto worry about this.

Value

ForgetQueryString, a named list. For example, the querystring?param1=value1&param2=value2 becomeslist(param1 = value1, param2 = value2). ForgetUrlHash, a character vector withthe hash (including the leading⁠#⁠ symbol).

See Also

updateQueryString()

Examples

## Only run this example in interactive R sessionsif (interactive()) {  ## App 1: getQueryString  ## Printing the value of the query string  ## (Use the back and forward buttons to see how the browser  ## keeps a record of each state)  shinyApp(    ui = fluidPage(      textInput("txt", "Enter new query string"),      helpText("Format: ?param1=val1&param2=val2"),      actionButton("go", "Update"),      hr(),      verbatimTextOutput("query")    ),    server = function(input, output, session) {      observeEvent(input$go, {        updateQueryString(input$txt, mode = "push")      })      output$query <- renderText({        query <- getQueryString()        queryText <- paste(names(query), query,                       sep = "=", collapse=", ")        paste("Your query string is:\n", queryText)      })    }  )  ## App 2: getUrlHash  ## Printing the value of the URL hash  ## (Use the back and forward buttons to see how the browser  ## keeps a record of each state)  shinyApp(    ui = fluidPage(      textInput("txt", "Enter new hash"),      helpText("Format: #hash"),      actionButton("go", "Update"),      hr(),      verbatimTextOutput("hash")    ),    server = function(input, output, session) {      observeEvent(input$go, {        updateQueryString(input$txt, mode = "push")      })      output$hash <- renderText({        hash <- getUrlHash()        paste("Your hash is:\n", hash)      })    }  )}

Get or set Shiny options

Description

There are two mechanisms for working with options for Shiny. One is theoptions() function, which is part of base R, and the other is theshinyOptions() function, which is in the Shiny package. The reason forthese two mechanisms is has to do with legacy code and scoping.

Theoptions() function sets options globally, for the duration of the Rprocess. ThegetOption() function retrieves the value of an option. Allshiny related options of this type are prefixed with"shiny.".

TheshinyOptions() function sets the value of a shiny option, but unlikeoptions(), it is not always global in scope; the options may be scopedglobally, to an application, or to a user session in an application,depending on the context. ThegetShinyOption() function retrieves a valueof a shiny option. Currently, the options set viashinyOptions are forinternal use only.

Usage

getShinyOption(name, default = NULL)shinyOptions(...)

Arguments

Options withoptions()

shiny.autoreload (defaults toFALSE)

IfTRUE when a Shiny app is launched, theapp directory will be continually monitored for changes to files thathave the extensions: r, htm, html, js, css, png, jpg, jpeg, gif. If anychanges are detected, all connected Shiny sessions are reloaded. Thisallows for fast feedback loops when tweaking Shiny UI.

Monitoring for changes is no longer expensive, thanks to thewatcherpackage, but this feature is still intended only for development.

You can customize the file patterns Shiny will monitor by setting theshiny.autoreload.pattern option. For example, to monitor onlyui.R:options(shiny.autoreload.pattern = glob2rx("ui.R")).

As mentioned above, Shiny no longer polls watched files for changes.Instead, usingwatcher, Shiny is notified of file changes as theyoccur. These changes are batched together within a customizable latencyperiod. You can adjust this period by settingoptions(shiny.autoreload.interval = 2000) (in milliseconds). This valueconverted to seconds and passed to thelatency argument ofwatcher::watcher(). The default latency is 250ms.

shiny.deprecation.messages (defaults toTRUE)

This controls whether messages fordeprecated functions in Shiny will be printed. SeeshinyDeprecated() for more information.

shiny.error (defaults toNULL)

This can be a function which is called when an erroroccurs. For example,options(shiny.error=recover) will result athe debugger prompt when an error occurs.

shiny.fullstacktrace (defaults toFALSE)

Controls whether "pretty" (FALSE) or fullstack traces (TRUE) are dumped to the console when errors occur during Shiny app execution.Pretty stack traces attempt to only show user-supplied code, but this pruning can't alwaysbe done 100% correctly.

shiny.host (defaults to"127.0.0.1")

The IP address that Shiny should listen on. SeerunApp() for more information.

shiny.jquery.version (defaults to3)

The major version of jQuery to use.Currently only values of3 or1 are supported. If1, then jQuery 1.12.4 is used. If3,then jQuery 3.7.1 is used.

shiny.json.digits (defaults toI(16))

Max number of digits to use when convertingnumbers to JSON format to send to the client web browser. UseI() to specify significant digits.UseNA for max precision.

shiny.launch.browser (defaults tointeractive())

A boolean which controls the default behaviorwhen an app is run. SeerunApp() for more information.

shiny.mathjax.url (defaults to"https://mathjax.rstudio.com/latest/MathJax.js")

The URL that should be used to load MathJax, viawithMathJax().

shiny.mathjax.config (defaults to"config=TeX-AMS-MML_HTMLorMML")

The querystringused to load MathJax, viawithMathJax().

shiny.maxRequestSize (defaults to 5MB)

This is a number which specifies the maximumweb request size, which serves as a size limit for file uploads.

shiny.minified (defaults toTRUE)

By defaultWhether or not to include Shiny's JavaScript as a minified (shiny.min.js)or un-minified (shiny.js) file. The un-minified version is larger,but can be helpful for development and debugging.

shiny.port (defaults to a random open port)

A port number that Shiny will listen on. SeerunApp() for more information.

shiny.reactlog (defaults toFALSE)

IfTRUE, enable logging of reactive events,which can be viewed later with thereactlogShow() function.This incurs a substantial performance penalty and should not be used inproduction.

shiny.sanitize.errors (defaults toFALSE)

IfTRUE, then normal errors (i.e.errors not wrapped insafeError) won't show up in the app; a simplegeneric error message is printed instead (the error and stack trace printedto the console remain unchanged). If you want to sanitize errors in general, but you DO want aparticular errore to get displayed to the user, then set this optiontoTRUE and usestop(safeError(e)) for errors you want theuser to see.

shiny.stacktraceoffset (defaults toTRUE)

IfTRUE, then Shiny's printed stacktraces will display srcrefs one line above their usual location. This isan arguably more intuitive arrangement for casual R users, as the nameof a function appears next to the srcref where it is defined, rather thanwhere it is currently being called from.

shiny.suppressMissingContextError (defaults toFALSE)

Normally, invoking a reactiveoutside of a reactive context (orisolate()) results inan error. If this isTRUE, don't error in these cases. Thisshould only be used for debugging or demonstrations of reactivity at theconsole.

shiny.testmode (defaults toFALSE)

IfTRUE, then various features for testing Shinyapplications are enabled.

shiny.snapshotsortc (defaults toFALSE)

IfTRUE, test snapshot keysforshinytest will be sorted consistently using the C locale. Snapshotsretrieved byshinytest2 will always sort using the C locale.

shiny.trace (defaults toFALSE)

Print messages sent between the R server and the webbrowser client to the R console. This is useful for debugging. Possiblevalues are"send" (only print messages sent to the client),"recv" (only print messages received by the server),TRUE(print all messages), orFALSE (default; don't print any of thesemessages).

shiny.autoload.r (defaults toTRUE)

IfTRUE, then the R/of a shiny app will automatically be sourced.

shiny.useragg (defaults toTRUE)

Set toFALSE to prevent PNG rendering via theragg package. SeeplotPNG() for more information.

shiny.usecairo (defaults toTRUE)

Set toFALSE to prevent PNG rendering via theCairo package. SeeplotPNG() for more information.

shiny.devmode (defaults toNULL)

Option to enable Shiny Developer Mode. When set,different defaultgetOption(key) values will be returned. Seedevmode() for more details.

shiny.otel.collect (defaults toSys.getenv("SHINY_OTEL_COLLECT", "all"))

Determines how Shiny will interact with OpenTelemetry.

Supported values:

• "none" - No Shiny OpenTelemetry tracing.

• "session" - Adds session start/end spans.

• "reactive_update" - Spans for any synchronous/asynchronous reactiveupdate. (Includes"session" features).

• "reactivity" - Spans for all reactive expressions and logs for settingreactive vals and values. (Includes"reactive_update" features). Thisoption must be set when creating any reactive objects that should recordOpenTelemetry spans / logs. SeewithOtelCollect() andlocalOtelCollect() for ways to set this option locally when creatingyour reactive expressions.

• "all" - All Shiny OpenTelemetry tracing. Currently equivalent to"reactivity".

This option is useful for debugging and profiling while in production. Thisoption will only be useful if theotelsdk package is installed andotel::is_tracing_enabled() returnsTRUE. Please have any OpenTelemetryenvironment variables set before loading any relevant R packages.

To set this option locally within a specific part of your Shinyapplication, seewithOtelCollect() andlocalOtelCollect().

shiny.otel.sanitize.errors (defaults toTRUE)

IfTRUE, fatal and unhandled errors will be sanitized before being sent to the OpenTelemetry backend. The default value ofTRUE is set to avoid potentially sending sensitive information to the OpenTelemetry backend. If you want the full error message and stack trace to be sent to the OpenTelemetry backend, set this option toFALSE or usesafeError(e).

Scoping forshinyOptions()

There are three levels of scoping forshinyOptions(): global,application, and session.

The global option set is available by default. Any calls toshinyOptions() andgetShinyOption() outside of an app will access theglobal option set.

When a Shiny application is run withrunApp(), the global option set isduplicated and the new option set is available at the application level. Ifoptions are set fromglobal.R,app.R,ui.R, orserver.R (butoutside of the server function), then the application-level options will bemodified.

Each time a user session is started, the application-level option set isduplicated, for that session. If the options are set from inside the serverfunction, then they will be scoped to the session.

Options withshinyOptions()

There are a number of global options that affect Shiny's behavior. Thesecan be set globally withoptions() or locally (for a single app) withshinyOptions().

cache

A caching object that will be used byrenderCachedPlot(). If not specified, acachem::cache_mem() will beused.

Create a header panel

Description

DEPRECATED: usetitlePanel() instead.

Usage

headerPanel(title, windowTitle = title)

Arguments

Value

A headerPanel that can be passed topageWithSidebar

Create a help text element

Description

Create help text which can be added to an input form to provide additionalexplanation or context.

Usage

helpText(...)

Arguments

Value

A help text element that can be added to a UI definition.

Examples

helpText("Note: while the data view will show only",         "the specified number of observations, the",         "summary will be based on the full dataset.")

Create an HTML output element

Description

Render a reactive output variable as HTML within an application page. Thetext will be included within an HTMLdiv tag, and is presumed to containHTML content which should not be escaped.

Usage

htmlOutput(  outputId,  inline = FALSE,  container = if (inline) span else div,  fill = FALSE,  ...)uiOutput(  outputId,  inline = FALSE,  container = if (inline) span else div,  fill = FALSE,  ...)

Arguments

Details

uiOutput is intended to be used withrenderUI on the server side. It iscurrently just an alias forhtmlOutput.

Value

An HTML output element that can be included in a panel

Examples

htmlOutput("summary")# Using a custom container and classtags$ul(  htmlOutput("summary", container = tags$li, class = "custom-li-output"))

Create an HTTP response object

Description

Create an HTTP response object

Usage

httpResponse(  status = 200L,  content_type = "text/html; charset=UTF-8",  content = "",  headers = list())

Arguments

Examples

httpResponse(status = 405L,  content_type = "text/plain",  content = "The requested method was not allowed")

Create an icon

Description

Create an icon for use within a page. Icons can appear on their own, insideof a button, and/or used withtabPanel() andnavbarMenu().

Usage

icon(name, class = NULL, lib = "font-awesome", ...)

Arguments

Value

An⁠<i>⁠ (icon) HTML tag.

See Also

For lists of available icons, seehttps://fontawesome.com/iconsandhttps://getbootstrap.com/docs/3.3/components/#glyphicons

Examples

# add an icon to a submit buttonsubmitButton("Update View", icon = icon("redo"))navbarPage("App Title",  tabPanel("Plot", icon = icon("bar-chart-o")),  tabPanel("Summary", icon = icon("list-alt")),  tabPanel("Table", icon = icon("table")))

Input panel

Description

AflowLayout() with a grey border and light grey background,suitable for wrapping inputs.

Usage

inputPanel(...)

Arguments

Dynamically insert/remove a tabPanel

Description

Dynamically insert or remove atabPanel() (or anavbarMenu()) from an existingtabsetPanel(),navlistPanel() ornavbarPage().

Usage

insertTab(  inputId,  tab,  target = NULL,  position = c("after", "before"),  select = FALSE,  session = getDefaultReactiveDomain())prependTab(  inputId,  tab,  select = FALSE,  menuName = NULL,  session = getDefaultReactiveDomain())appendTab(  inputId,  tab,  select = FALSE,  menuName = NULL,  session = getDefaultReactiveDomain())removeTab(inputId, target, session = getDefaultReactiveDomain())

Arguments

Details

When you want to insert a new tab before or after an existing tab, youshould useinsertTab. When you want to prepend a tab (i.e. add atab to the beginning of thetabsetPanel), useprependTab.When you want to append a tab (i.e. add a tab to the end of thetabsetPanel), useappendTab.

FornavbarPage, you can insert/remove conventionaltabPanels (whether at the top level or nested inside anavbarMenu), as well as an entirenavbarMenu().For the latter case,target should be themenuName thatyou gave yournavbarMenu when you first created it (by default,this is equal to the value of thetitle argument).

See Also

showTab()

Examples

## Only run this example in interactive R sessionsif (interactive()) {# example app for inserting/removing a tabui <- fluidPage(  sidebarLayout(    sidebarPanel(      actionButton("add", "Add 'Dynamic' tab"),      actionButton("remove", "Remove 'Foo' tab")    ),    mainPanel(      tabsetPanel(id = "tabs",        tabPanel("Hello", "This is the hello tab"),        tabPanel("Foo", "This is the foo tab"),        tabPanel("Bar", "This is the bar tab")      )    )  ))server <- function(input, output, session) {  observeEvent(input$add, {    insertTab(inputId = "tabs",      tabPanel("Dynamic", "This a dynamically-added tab"),      target = "Bar"    )  })  observeEvent(input$remove, {    removeTab(inputId = "tabs", target = "Foo")  })}shinyApp(ui, server)# example app for prepending/appending a navbarMenuui <- navbarPage("Navbar page", id = "tabs",  tabPanel("Home",    actionButton("prepend", "Prepend a navbarMenu"),    actionButton("append", "Append a navbarMenu")  ))server <- function(input, output, session) {  observeEvent(input$prepend, {    id <- paste0("Dropdown", input$prepend, "p")    prependTab(inputId = "tabs",      navbarMenu(id,        tabPanel("Drop1", paste("Drop1 page from", id)),        tabPanel("Drop2", paste("Drop2 page from", id)),        "------",        "Header",        tabPanel("Drop3", paste("Drop3 page from", id))      )    )  })  observeEvent(input$append, {    id <- paste0("Dropdown", input$append, "a")    appendTab(inputId = "tabs",      navbarMenu(id,        tabPanel("Drop1", paste("Drop1 page from", id)),        tabPanel("Drop2", paste("Drop2 page from", id)),        "------",        "Header",        tabPanel("Drop3", paste("Drop3 page from", id))      )    )  })}shinyApp(ui, server)}

Insert and remove UI objects

Description

These functions allow you to dynamically add and remove arbitrary UIinto your app, whenever you want, as many times as you want.UnlikerenderUI(), the UI generated withinsertUI() is persistent:once it's created, it stays there until removed byremoveUI(). Eachnew call toinsertUI() creates more UI objects, in addition tothe ones already there (all independent from one another). Toupdate a part of the UI (ex: an input object), you must use theappropriaterender function or a customizedreactivefunction.

Usage

insertUI(  selector,  where = c("beforeBegin", "afterBegin", "beforeEnd", "afterEnd"),  ui,  multiple = FALSE,  immediate = FALSE,  session = getDefaultReactiveDomain())removeUI(  selector,  multiple = FALSE,  immediate = FALSE,  session = getDefaultReactiveDomain())

Arguments

Details

It's particularly useful to pairremoveUI withinsertUI(), but there isno restriction on what you can use it on. Any element that can be selectedthrough a jQuery selector can be removed through this function.

Examples

## Only run this example in interactive R sessionsif (interactive()) {# Define UIui <- fluidPage(  actionButton("add", "Add UI"))# Server logicserver <- function(input, output, session) {  observeEvent(input$add, {    insertUI(      selector = "#add",      where = "afterEnd",      ui = textInput(paste0("txt", input$add),                     "Insert some text")    )  })}# Complete app with UI and server componentsshinyApp(ui, server)}if (interactive()) {# Define UIui <- fluidPage(  actionButton("rmv", "Remove UI"),  textInput("txt", "This is no longer useful"))# Server logicserver <- function(input, output, session) {  observeEvent(input$rmv, {    removeUI(      selector = "div:has(> #txt)"    )  })}# Complete app with UI and server componentsshinyApp(ui, server)}

Scheduled Invalidation

Description

Schedules the current reactive context to be invalidated in the given numberof milliseconds.

Usage

invalidateLater(millis, session = getDefaultReactiveDomain())

Arguments

Details

If this is placed within an observer or reactive expression, that object willbe invalidated (and re-execute) after the interval has passed. There-execution will reset the invalidation flag, so in a typical use case, theobject will keep re-executing and waiting for the specified interval. It'spossible to stop this cycle by adding conditional logic that prevents theinvalidateLater from being run.

See Also

reactiveTimer() is a slightly less safe alternative.

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  sliderInput("n", "Number of observations", 2, 1000, 500),  plotOutput("plot"))server <- function(input, output, session) {  observe({    # Re-execute this reactive expression after 1000 milliseconds    invalidateLater(1000, session)    # Do something each time this is invalidated.    # The isolate() makes this observer _not_ get invalidated and re-executed    # when input$n changes.    print(paste("The value of input$n is", isolate(input$n)))  })  # Generate a new histogram at timed intervals, but not when  # input$n changes.  output$plot <- renderPlot({    # Re-execute this reactive expression after 2000 milliseconds    invalidateLater(2000)    hist(rnorm(isolate(input$n)))  })}shinyApp(ui, server)}

Checks whether an object is a reactivevalues object

Description

Checks whether its argument is a reactivevalues object.

Usage

is.reactivevalues(x)

Arguments

See Also

reactiveValues().

Check whether a Shiny application is running

Description

This function tests whether a Shiny application is currently running.

Usage

isRunning()

Value

TRUE if a Shiny application is currently running. Otherwise,FALSE.

Truthy and falsy values

Description

The terms "truthy" and "falsy" generally indicate whether a value, whencoerced to abase::logical(), isTRUE orFALSE. We usethe term a little loosely here; our usage tries to match the intuitivenotions of "Is this value missing or available?", or "Has the user providedan answer?", or in the case of action buttons, "Has the button beenclicked?".

Usage

isTruthy(x)

Arguments

Details

For example, atextInput that has not been filled out by the user hasa value of"", so that is considered a falsy value.

To be precise, a value is truthyunless it is one of:

• FALSE

• NULL

• ""

• An empty atomic vector

• An atomic vector that contains only missing values

• A logical vector that contains allFALSE or missing values

• An object of class"try-error"

• A value that represents an unclickedactionButton()

Note in particular that the value0 is considered truthy, even thoughas.logical(0) isFALSE.

Create a non-reactive scope for an expression

Description

Executes the given expression in a scope where reactive values or expressioncan be read, but they cannot cause the reactive scope of the caller to bere-evaluated when they change.

Usage

isolate(expr)

Arguments

Details

Ordinarily, the simple act of reading a reactive value causes a relationshipto be established between the caller and the reactive value, where a changeto the reactive value will cause the caller to re-execute. (The same appliesfor the act of getting a reactive expression's value.) Theisolatefunction lets you read a reactive value or expression without establishing thisrelationship.

The expression given toisolate() is evaluated in the callingenvironment. This means that if you assign a variable inside theisolate(), its value will be visible outside of theisolate().If you want to avoid this, you can usebase::local() inside theisolate().

This function can also be useful for calling reactive expression at theconsole, which can be useful for debugging. To do so, simply wrap thecalls to the reactive expression withisolate().

Examples

## Not run: observe({  input$saveButton  # Do take a dependency on input$saveButton  # isolate a simple expression  data <- get(isolate(input$dataset))  # No dependency on input$dataset  writeToDatabase(data)})observe({  input$saveButton  # Do take a dependency on input$saveButton  # isolate a whole block  data <- isolate({    a <- input$valueA   # No dependency on input$valueA or input$valueB    b <- input$valueB    c(a=a, b=b)  })  writeToDatabase(data)})observe({  x <- 1  # x outside of isolate() is affected  isolate(x <- 2)  print(x) # 2  y <- 1  # Use local() to avoid affecting calling environment  isolate(local(y <- 2))  print(y) # 1})## End(Not run)# Can also use isolate to call reactive expressions from the R consolevalues <- reactiveValues(A=1)fun <- reactive({ as.character(values$A) })isolate(fun())# "1"# isolate also works if the reactive expression accesses values from the# input object, like input$x

Knitr S3 methods

Description

These S3 methods are necessary to help Shiny applications and UI chunks embedthemselves in knitr/rmarkdown documents.

Usage

knit_print.shiny.appobj(x, ...)knit_print.shiny.render.function(x, ..., inline = FALSE)knit_print.reactive(x, ..., inline = FALSE)

Arguments

Load an app's supporting R files

Description

Loads all of the supporting R files of a Shiny application. Specifically,this function loads any top-level supporting.R files in the⁠R/⁠ directoryadjacent to theapp.R/server.R/ui.R files.

Usage

loadSupport(  appDir = NULL,  renv = new.env(parent = globalenv()),  globalrenv = globalenv())

Arguments

Details

Since Shiny 1.5.0, this function is called by default when running anapplication. If it causes problems, there are two ways to opt out. You caneither place a file named⁠_disable_autoload.R⁠ in your R/ directory, orsetoptions(shiny.autoload.r=FALSE). If you set this option, it willaffect any application that runs later in the same R session, potentiallybreaking it, so after running your application, you should unset option withoptions(shiny.autoload.r=NULL)

The files are sourced in alphabetical order (as determined bylist.files).global.R is evaluated before the supporting R files in the⁠R/⁠ directory.

Make a reactive variable

Description

Turns a normal variable into a reactive variable, that is, one that hasreactive semantics when assigned or read in the usual ways. The variable mayalready exist; if so, its value will be used as the initial value of thereactive variable (orNULL if the variable did not exist).

Usage

makeReactiveBinding(symbol, env = parent.frame())

Arguments

Value

None.

Examples

reactiveConsole(TRUE)a <- 10makeReactiveBinding("a")b <- reactive(a * -1)observe(print(b()))a <- 20a <- 30reactiveConsole(FALSE)

Mark a render function with attributes that will be used by the output

Description

Mark a render function with attributes that will be used by the output

Usage

markOutputAttrs(renderFunc, snapshotExclude = NULL, snapshotPreprocess = NULL)

Arguments

Mark a function as a render function

Description

Please usecreateRenderFunction() tosupport async execution. (Shiny 1.1.0)

Usage

markRenderFunction(  uiFunc,  renderFunc,  outputArgs = list(),  cacheHint = "auto",  cacheWriteHook = NULL,  cacheReadHook = NULL)

Arguments

Details

Should be called by implementers ofrenderXXX functions in order to marktheir return values as Shiny render functions, and to provide a hint to Shinyregarding what UI function is most commonly used with this type of renderfunction. This can be used in R Markdown documents to create complete outputwidgets out of just the render function.

Note that it is generally preferable to usecreateRenderFunction() insteadofmarkRenderFunction(). It essentially wraps up the user-providedexpression in thetransform function passed to it, then passes the resultingfunction tomarkRenderFunction(). It also provides a simpler callinginterface. There may be cases wheremarkRenderFunction() must be used instead ofcreateRenderFunction() – for example, when thetransform parameter ofcreateRenderFunction() is not flexible enough for your needs.

Value

TherenderFunc function, with annotations.

See Also

createRenderFunction()

Insert inline Markdown

Description

This function acceptsMarkdown-syntax text and returnsHTML that may be included in Shiny UIs.

Usage

markdown(mds, extensions = TRUE, .noWS = NULL, ...)

Arguments

Details

Leading whitespace is trimmed from Markdown text withglue::trim().Whitespace trimming ensures Markdown is processed correctly even when thecall tomarkdown() is indented within surrounding R code.

By default,Github extensions are enabled, but thiscan be disabled by passingextensions = FALSE.

Markdown rendering is performed bycommonmark::markdown_html(). Additionalarguments tomarkdown() are passed as arguments tomarkdown_html()

Value

a character vector marked as HTML.

Examples

ui <- fluidPage(  markdown("    # Markdown Example    This is a markdown paragraph, and will be contained within a `<p>` tag    in the UI.    The following is an unordered list, which will be represented in the UI as    a `<ul>` with `<li>` children:    * a bullet    * another    [Links](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a) work;    so does *emphasis*.    To see more of what's possible, check out [commonmark.org/help](https://commonmark.org/help).    "))

Evaluate an expression without a reactive context

Description

Temporarily blocks the current reactive context and evaluates the givenexpression. Any attempt to directly access reactive values or expressions inexpr will give the same results as doing it at the top-level (bydefault, an error).

Usage

maskReactiveContext(expr)

Arguments

Value

The value ofexpr.

See Also

isolate()

Create memory cache (deprecated)

Description

Create memory cache (deprecated)

Usage

memoryCache(  max_size = 200 * 1024^2,  max_age = Inf,  max_n = Inf,  evict = c("lru", "fifo"),  missing = key_missing(),  exec_missing = deprecated(),  logfile = NULL)

Arguments

Create a modal dialog UI

Description

modalDialog() creates the UI for a modal dialog, using Bootstrap's modalclass. Modals are typically used for showing important messages, or forpresenting UI that requires input from the user, such as a user name andpassword input.

modalButton() creates a button that will dismiss the dialog when clicked,typically used when customising thefooter.

Usage

modalDialog(  ...,  title = NULL,  footer = modalButton("Dismiss"),  size = c("m", "s", "l", "xl"),  easyClose = FALSE,  fade = TRUE)modalButton(label, icon = NULL)

Arguments

Examples

if (interactive()) {# Display an important message that can be dismissed only by clicking the# dismiss button.shinyApp(  ui = basicPage(    actionButton("show", "Show modal dialog")  ),  server = function(input, output) {    observeEvent(input$show, {      showModal(modalDialog(        title = "Important message",        "This is an important message!"      ))    })  })# Display a message that can be dismissed by clicking outside the modal dialog,# or by pressing Esc.shinyApp(  ui = basicPage(    actionButton("show", "Show modal dialog")  ),  server = function(input, output) {    observeEvent(input$show, {      showModal(modalDialog(        title = "Somewhat important message",        "This is a somewhat important message.",        easyClose = TRUE,        footer = NULL      ))    })  })# Display a modal that requires valid input before continuing.shinyApp(  ui = basicPage(    actionButton("show", "Show modal dialog"),    verbatimTextOutput("dataInfo")  ),  server = function(input, output) {    # reactiveValues object for storing current data set.    vals <- reactiveValues(data = NULL)    # Return the UI for a modal dialog with data selection input. If 'failed' is    # TRUE, then display a message that the previous value was invalid.    dataModal <- function(failed = FALSE) {      modalDialog(        textInput("dataset", "Choose data set",          placeholder = 'Try "mtcars" or "abc"'        ),        span('(Try the name of a valid data object like "mtcars", ',             'then a name of a non-existent object like "abc")'),        if (failed)          div(tags$b("Invalid name of data object", style = "color: red;")),        footer = tagList(          modalButton("Cancel"),          actionButton("ok", "OK")        )      )    }    # Show modal when button is clicked.    observeEvent(input$show, {      showModal(dataModal())    })    # When OK button is pressed, attempt to load the data set. If successful,    # remove the modal. If not show another modal, but this time with a failure    # message.    observeEvent(input$ok, {      # Check that data object exists and is data frame.      if (!is.null(input$dataset) && nzchar(input$dataset) &&          exists(input$dataset) && is.data.frame(get(input$dataset))) {        vals$data <- get(input$dataset)        removeModal()      } else {        showModal(dataModal(failed = TRUE))      }    })    # Display information about selected data    output$dataInfo <- renderPrint({      if (is.null(vals$data))        "No data selected"      else        summary(vals$data)    })  })}

Shiny modules

Description

Shiny's module feature lets you break complicated UI and server logic intosmaller, self-contained pieces. Compared to large monolithic Shiny apps,modules are easier to reuse and easier to reason about. See the article athttps://shiny.rstudio.com/articles/modules.html to learn more.

Usage

moduleServer(id, module, session = getDefaultReactiveDomain())

Arguments

Details

Starting in Shiny 1.5.0, we recommend usingmoduleServer instead ofcallModule(), because the syntax is a little easierto understand, and modules created withmoduleServer can be tested withtestServer().

Value

The return value, if any, from executing the module server function

See Also

https://shiny.rstudio.com/articles/modules.html

Examples

# Define the UI for a modulecounterUI <- function(id, label = "Counter") {  ns <- NS(id)  tagList(    actionButton(ns("button"), label = label),    verbatimTextOutput(ns("out"))  )}# Define the server logic for a modulecounterServer <- function(id) {  moduleServer(    id,    function(input, output, session) {      count <- reactiveVal(0)      observeEvent(input$button, {        count(count() + 1)      })      output$out <- renderText({        count()      })      count    }  )}# Use the module in an appui <- fluidPage(  counterUI("counter1", "Counter #1"),  counterUI("counter2", "Counter #2"))server <- function(input, output, session) {  counterServer("counter1")  counterServer("counter2")}if (interactive()) {  shinyApp(ui, server)}# If you want to pass extra parameters to the module's server logic, you can# add them to your function. In this case `prefix` is text that will be# printed before the count.counterServer2 <- function(id, prefix = NULL) {  moduleServer(    id,    function(input, output, session) {      count <- reactiveVal(0)      observeEvent(input$button, {        count(count() + 1)      })      output$out <- renderText({        paste0(prefix, count())      })      count    }  )}ui <- fluidPage(  counterUI("counter", "Counter"),)server <- function(input, output, session) {  counterServer2("counter", "The current count is: ")}if (interactive()) {  shinyApp(ui, server)}

Create a page with a top level navigation bar

Description

Create a page that contains a top level navigation bar that can be used totoggle a set oftabPanel() elements.

Usage

navbarPage(  title,  ...,  id = NULL,  selected = NULL,  position = c("static-top", "fixed-top", "fixed-bottom"),  header = NULL,  footer = NULL,  inverse = FALSE,  collapsible = FALSE,  fluid = TRUE,  theme = NULL,  windowTitle = NA,  lang = NULL)navbarMenu(title, ..., menuName = title, icon = NULL)

Arguments

Details

ThenavbarMenu function can be used to create an embeddedmenu within the navbar that in turns includes additional tabPanels (seeexample below).

Value

A UI definition that can be passed to theshinyUI function.

See Also

tabPanel(),tabsetPanel(),updateNavbarPage(),insertTab(),showTab()

Other layout functions:fillPage(),fixedPage(),flowLayout(),fluidPage(),sidebarLayout(),splitLayout(),verticalLayout()

Examples

navbarPage("App Title",  tabPanel("Plot"),  tabPanel("Summary"),  tabPanel("Table"))navbarPage("App Title",  tabPanel("Plot"),  navbarMenu("More",    tabPanel("Summary"),    "----",    "Section header",    tabPanel("Table")  ))

Create a navigation list panel

Description

Create a navigation list panel that provides a list of links on the leftwhich navigate to a set of tabPanels displayed to the right.

Usage

navlistPanel(  ...,  id = NULL,  selected = NULL,  header = NULL,  footer = NULL,  well = TRUE,  fluid = TRUE,  widths = c(4, 8))

Arguments

Details

You can include headers within thenavlistPanel by includingplain text elements in the list. Versions of Shiny before 0.11 supportedseparators with "——", but as of 0.11, separators were no longersupported. This is because version 0.11 switched to Bootstrap 3, whichdoesn't support separators.

See Also

tabPanel(),updateNavlistPanel(),insertTab(),showTab()

Examples

fluidPage(  titlePanel("Application Title"),  navlistPanel(    "Header",    tabPanel("First"),    tabPanel("Second"),    tabPanel("Third")  ))

Create a numeric input control

Description

Create an input control for entry of numeric values

Usage

numericInput(  inputId,  label,  value,  min = NA,  max = NA,  step = NA,  width = NULL,  ...,  updateOn = c("change", "blur"))

Arguments

Value

A numeric input control that can be added to a UI definition.

Server value

A numeric vector of length 1.

See Also

updateNumericInput()

Other input elements:actionButton(),checkboxGroupInput(),checkboxInput(),dateInput(),dateRangeInput(),fileInput(),passwordInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  numericInput("obs", "Observations:", 10, min = 1, max = 100),  verbatimTextOutput("value"))server <- function(input, output) {  output$value <- renderText({ input$obs })}shinyApp(ui, server)}

Create a reactive observer

Description

Creates an observer from the given expression.

Usage

observe(  x,  env = parent.frame(),  quoted = FALSE,  ...,  label = NULL,  suspended = FALSE,  priority = 0,  domain = getDefaultReactiveDomain(),  autoDestroy = TRUE,  ..stacktraceon = TRUE)

Arguments

Details

An observer is like a reactive expression in that it can read reactive valuesand call reactive expressions, and will automatically re-execute when thosedependencies change. But unlike reactive expressions, it doesn't yield aresult and can't be used as an input to other reactive expressions. Thus,observers are only useful for their side effects (for example, performingI/O).

Another contrast between reactive expressions and observers is theirexecution strategy. Reactive expressions use lazy evaluation; that is, whentheir dependencies change, they don't re-execute right away but rather waituntil they are called by someone else. Indeed, if they are not called thenthey will never re-execute. In contrast, observers use eager evaluation; assoon as their dependencies change, they schedule themselves to re-execute.

Starting with Shiny 0.10.0, observers are automatically destroyed by defaultwhen thedomain that owns them ends (e.g. when a Shinysession ends).

Value

An observer reference class object. This object has the followingmethods:

suspend()

Causes this observer to stop scheduling flushes (re-executions) inresponse to invalidations. If the observer was invalidated prior tothis call but it has not re-executed yet then that re-execution willstill occur, because the flush is already scheduled.

resume()

Causes this observer to start re-executing in response toinvalidations. If the observer was invalidated while suspended, then itwill schedule itself for re-execution.

destroy()

Stops the observer from executing ever again, even if it is currentlyscheduled for re-execution.

setPriority(priority = 0)

Change this observer's priority. Note that if the observer is currentlyinvalidated, then the change in priority will not take effect until thenext invalidation–unless the observer is also currently suspended, inwhich case the priority change will be effective upon resume.

setAutoDestroy(autoDestroy)

Sets whether this observer should be automatically destroyed when itsdomain (if any) ends. If autoDestroy is TRUE and the domain alreadyended, then destroy() is called immediately."

onInvalidate(callback)

Register a callback function to run when this observer is invalidated.No arguments will be provided to the callback function when it isinvoked.

Examples

values <- reactiveValues(A=1)obsB <- observe({  print(values$A + 1)})# To store expressions for later conversion to observe, use rlang::quo()myquo <- rlang::quo({ print(values$A + 3) })obsC <- rlang::inject(observe(!!myquo))# (Legacy) Can use quoted expressionsobsD <- observe(quote({ print(values$A + 2) }), quoted = TRUE)# In a normal Shiny app, the web client will trigger flush events. If you# are at the console, you can force a flush with flushReact()shiny:::flushReact()

Event handler

Description

Respond to "event-like" reactive inputs, values, and expressions. As of Shiny1.6.0, we recommend usingbindEvent() instead ofeventReactive() andobserveEvent(). This is becausebindEvent() can be composed withbindCache(), and because it can also be used withrender functions (likerenderText() andrenderPlot()).

Usage

observeEvent(  eventExpr,  handlerExpr,  event.env = parent.frame(),  event.quoted = FALSE,  handler.env = parent.frame(),  handler.quoted = FALSE,  ...,  label = NULL,  suspended = FALSE,  priority = 0,  domain = getDefaultReactiveDomain(),  autoDestroy = TRUE,  ignoreNULL = TRUE,  ignoreInit = FALSE,  once = FALSE)eventReactive(  eventExpr,  valueExpr,  event.env = parent.frame(),  event.quoted = FALSE,  value.env = parent.frame(),  value.quoted = FALSE,  ...,  label = NULL,  domain = getDefaultReactiveDomain(),  ignoreNULL = TRUE,  ignoreInit = FALSE)

Arguments

Details

Shiny's reactive programming framework is primarily designed for calculatedvalues (reactive expressions) and side-effect-causing actions (observers)that respond toany of their inputs changing. That's often what isdesired in Shiny apps, but not always: sometimes you want to wait for aspecific action to be taken from the user, like clicking anactionButton(), before calculating an expression or taking anaction. A reactive value or expression that is used to trigger othercalculations in this way is called anevent.

These situations demand a more imperative, "event handling" style ofprogramming that is possible–but not particularly intuitive–using thereactive programming primitivesobserve() andisolate().observeEvent andeventReactive providestraightforward APIs for event handling that wrapobserve andisolate.

UseobserveEvent whenever you want toperform an action inresponse to an event. (Note that "recalculate a value" does not generallycount as performing an action–seeeventReactive for that.) The firstargument is the event you want to respond to, and the second argument is afunction that should be called whenever the event occurs. Note thatobserveEvent() is equivalent to usingobserve() %>% bindEvent() and as ofShiny 1.6.0, we recommend the latter.

UseeventReactive to create acalculated value that onlyupdates in response to an event. This is just like a normalreactive expression except it ignores all the usualinvalidations that come from its reactive dependencies; it only invalidatesin response to the given event. Note thateventReactive() is equivalent to usingreactive() %>% bindEvent() and as ofShiny 1.6.0, we recommend the latter.

Value

observeEvent returns an observer reference class object (seeobserve()).eventReactive returns a reactive expressionobject (seereactive()).

ignoreNULL and ignoreInit

BothobserveEvent andeventReactive take anignoreNULLparameter that affects behavior when theeventExpr evaluates toNULL (or in the special case of anactionButton(),0). In these cases, ifignoreNULL isTRUE, then anobserveEvent will not execute and aneventReactive will raise asilentvalidation error. This is useful behavior if youdon't want to do the action or calculation when your app first starts, butwait for the user to initiate the action first (like a "Submit" button);whereasignoreNULL=FALSE is desirable if you want to initially performthe action/calculation and just let the user re-initiate it (like a"Recalculate" button).

Likewise, bothobserveEvent andeventReactive also take in anignoreInit argument. By default, both of these will run right when theyare created (except if, at that moment,eventExpr evaluates toNULLandignoreNULL isTRUE). But when responding to a click of an actionbutton, it may often be useful to setignoreInit toTRUE. Forexample, if you're setting up anobserveEvent for a dynamically createdbutton, thenignoreInit = TRUE will guarantee that the action (inhandlerExpr) will only be triggered when the button is actually clicked,instead of also being triggered when it is created/initialized. Similarly,if you're setting up aneventReactive that responds to a dynamicallycreated button used to refresh some data (then returned by thateventReactive),then you should use⁠eventReactive([...], ignoreInit = TRUE)⁠ if you wantto let the user decide if/when they want to refresh the data (since, dependingon the app, this may be a computationally expensive operation).

Even thoughignoreNULL andignoreInit can be used for similarpurposes they are independent from one another. Here's the result of combiningthese:

ignoreNULL = TRUE andignoreInit = FALSE

This is the default. This combination means thathandlerExpr/valueExpr will run every time thateventExpr is notNULL. If, at the time of the creation of theobserveEvent/eventReactive,eventExpr happenstonot beNULL, then the code runs.

ignoreNULL = FALSE andignoreInit = FALSE

This combination means thathandlerExpr/valueExpr willrun every time no matter what.

ignoreNULL = FALSE andignoreInit = TRUE

This combination means thathandlerExpr/valueExpr willnot run when theobserveEvent/eventReactive iscreated (becauseignoreInit = TRUE), but it will run everyother time.

ignoreNULL = TRUE andignoreInit = TRUE

This combination means thathandlerExpr/valueExpr willnot run when theobserveEvent/eventReactive iscreated (becauseignoreInit = TRUE). After that,handlerExpr/valueExpr will run every time thateventExpr is notNULL.

See Also

actionButton()

Examples

## Only run examples in interactive R sessionsif (interactive()) {  ## App 1: Sample usage  shinyApp(    ui = fluidPage(      column(4,        numericInput("x", "Value", 5),        br(),        actionButton("button", "Show")      ),      column(8, tableOutput("table"))    ),    server = function(input, output) {      # Take an action every time button is pressed;      # here, we just print a message to the console      observeEvent(input$button, {        cat("Showing", input$x, "rows\n")      })      # The observeEvent() above is equivalent to:      # observe({      #    cat("Showing", input$x, "rows\n")      #   }) %>%      #   bindEvent(input$button)      # Take a reactive dependency on input$button, but      # not on any of the stuff inside the function      df <- eventReactive(input$button, {        head(cars, input$x)      })      output$table <- renderTable({        df()      })    }  )  ## App 2: Using `once`  shinyApp(    ui = basicPage( actionButton("go", "Go")),    server = function(input, output, session) {      observeEvent(input$go, {        print(paste("This will only be printed once; all",              "subsequent button clicks won't do anything"))      }, once = TRUE)      # The observeEvent() above is equivalent to:      # observe({      #   print(paste("This will only be printed once; all",      #         "subsequent button clicks won't do anything"))      #   }) %>%      #   bindEvent(input$go, once = TRUE)    }  )  ## App 3: Using `ignoreInit` and `once`  shinyApp(    ui = basicPage(actionButton("go", "Go")),    server = function(input, output, session) {      observeEvent(input$go, {        insertUI("#go", "afterEnd",                 actionButton("dynamic", "click to remove"))        # set up an observer that depends on the dynamic        # input, so that it doesn't run when the input is        # created, and only runs once after that (since        # the side effect is remove the input from the DOM)        observeEvent(input$dynamic, {          removeUI("#dynamic")        }, ignoreInit = TRUE, once = TRUE)      })    }  )}

Add callbacks for Shiny session bookmarking events

Description

These functions are for registering callbacks on Shiny session events. Theyshould be called within an application's server function.

• onBookmark registers a function that will be called justbefore Shiny bookmarks state.

• onBookmarked registers a function that will be called justafter Shiny bookmarks state.

• onRestore registers a function that will be called when asession is restored, after the server function executes, but before allother reactives, observers and render functions are run.

• onRestored registers a function that will be called after asession is restored. This is similar toonRestore, but it will becalled after all reactives, observers, and render functions run, andafter results are sent to the client browser.onRestoredcallbacks can be useful for sending update messages to the clientbrowser.

Usage

onBookmark(fun, session = getDefaultReactiveDomain())onBookmarked(fun, session = getDefaultReactiveDomain())onRestore(fun, session = getDefaultReactiveDomain())onRestored(fun, session = getDefaultReactiveDomain())

Arguments

Details

All of these functions return a function which can be called with noarguments to cancel the registration.

The callback function that is passed to these functions should take oneargument, typically named "state" (foronBookmark,onRestore,andonRestored) or "url" (foronBookmarked).

ForonBookmark, the state object has three relevant fields. Thevalues field is an environment which can be used to save arbitraryvalues (see examples). If the state is being saved to disk (as opposed tobeing encoded in a URL), thedir field contains the name of adirectory which can be used to store extra files. Finally, the state objecthas aninput field, which is simply the application'sinputobject. It can be read, but not modified.

ForonRestore andonRestored, the state object is a list. Thislist containsinput, which is a named list of input values to restore,values, which is an environment containing arbitrary values that weresaved inonBookmark, anddir, the name of the directory thatthe state is being restored from, and which could have been used to saveextra files.

ForonBookmarked, the callback function receives a string with thebookmark URL. This callback function should be used to display UI in theclient browser with the bookmark URL. If no callback function is registered,then Shiny will by default display a modal dialog with the bookmark URL.

Modules

These callbacks may also be used in Shiny modules. When used this way, theinputs and values will automatically be namespaced for the module, and thecallback functions registered for the module will only be able to see themodule's inputs and values.

See Also

enableBookmarking for general information on bookmarking.

Examples

## Only run these examples in interactive sessionsif (interactive()) {# Basic use of onBookmark and onRestore: This app saves the time in its# arbitrary values, and restores that time when the app is restored.ui <- function(req) {  fluidPage(    textInput("txt", "Input text"),    bookmarkButton()  )}server <- function(input, output) {  onBookmark(function(state) {    savedTime <- as.character(Sys.time())    cat("Last saved at", savedTime, "\n")    # state is a mutable reference object, and we can add arbitrary values to    # it.    state$values$time <- savedTime  })  onRestore(function(state) {    cat("Restoring from state bookmarked at", state$values$time, "\n")  })}enableBookmarking("url")shinyApp(ui, server)ui <- function(req) {  fluidPage(    textInput("txt", "Input text"),    bookmarkButton()  )}server <- function(input, output, session) {  lastUpdateTime <- NULL  observeEvent(input$txt, {    updateTextInput(session, "txt",      label = paste0("Input text (Changed ", as.character(Sys.time()), ")")    )  })  onBookmark(function(state) {    # Save content to a file    messageFile <- file.path(state$dir, "message.txt")    cat(as.character(Sys.time()), file = messageFile)  })  onRestored(function(state) {    # Read the file    messageFile <- file.path(state$dir, "message.txt")    timeText <- readChar(messageFile, 1000)    # updateTextInput must be called in onRestored, as opposed to onRestore,    # because onRestored happens after the client browser is ready.    updateTextInput(session, "txt",      label = paste0("Input text (Changed ", timeText, ")")    )  })}# "server" bookmarking is needed for writing to disk.enableBookmarking("server")shinyApp(ui, server)# This app has a module, and both the module and the main app code have# onBookmark and onRestore functions which write and read state$values$hash. The# module's version of state$values$hash does not conflict with the app's version# of state$values$hash.## A basic module that captializes text.capitalizerUI <- function(id) {  ns <- NS(id)  wellPanel(    h4("Text captializer module"),    textInput(ns("text"), "Enter text:"),    verbatimTextOutput(ns("out"))  )}capitalizerServer <- function(input, output, session) {  output$out <- renderText({    toupper(input$text)  })  onBookmark(function(state) {    state$values$hash <- rlang::hash(input$text)  })  onRestore(function(state) {    if (identical(rlang::hash(input$text), state$values$hash)) {      message("Module's input text matches hash ", state$values$hash)    } else {      message("Module's input text does not match hash ", state$values$hash)    }  })}# Main app codeui <- function(request) {  fluidPage(    sidebarLayout(      sidebarPanel(        capitalizerUI("tc"),        textInput("text", "Enter text (not in module):"),        bookmarkButton()      ),      mainPanel()    )  )}server <- function(input, output, session) {  callModule(capitalizerServer, "tc")  onBookmark(function(state) {    state$values$hash <- rlang::hash(input$text)  })  onRestore(function(state) {    if (identical(rlang::hash(input$text), state$values$hash)) {      message("App's input text matches hash ", state$values$hash)    } else {      message("App's input text does not match hash ", state$values$hash)    }  })}enableBookmarking(store = "url")shinyApp(ui, server)}

Add callbacks for Shiny session events

Description

These functions are for registering callbacks on Shiny session events.onFlush registers a function that will be called before Shiny flushes thereactive system.onFlushed registers a function that will be called afterShiny flushes the reactive system.onUnhandledError registers a function tobe called when an unhandled error occurs before the session is closed.onSessionEnded registers a function to be called after the client hasdisconnected.

These functions should be called within the application's server function.

All of these functions return a function which can be called with noarguments to cancel the registration.

Usage

onFlush(fun, once = TRUE, session = getDefaultReactiveDomain())onFlushed(fun, once = TRUE, session = getDefaultReactiveDomain())onSessionEnded(fun, session = getDefaultReactiveDomain())onUnhandledError(fun, session = getDefaultReactiveDomain())

Arguments

Unhandled Errors

Unhandled errors are errors that aren't otherwise handled by Shiny or by theapplication logic. In other words, they are errors that will either cause theapplication to crash or will result in "Error" output in the UI.

You can useonUnhandledError() to register a function that will be calledwhen an unhandled error occurs. This function will be called with the errorobject as its first argument. If the error is fatal and will result in thesession closing, the error condition will have theshiny.error.fatal class.

Note that theonUnhandledError() callbacks cannot be used to prevent theapp from closing or to modify the error condition. Instead, they are intendedto give you an opportunity to log the error or perform other cleanupoperations.

See Also

onStop() for registering callbacks that will beinvoked when the application exits, or when a session ends.

Examples

library(shiny)ui <- fixedPage(  markdown(c(    "Set the number to 8 or higher to cause an error",    "in the `renderText()` output."  )),  sliderInput("number", "Number", 0, 10, 4),  textOutput("text"),  hr(),  markdown(c(    "Click the button below to crash the app with an unhandled error",    "in an `observe()` block."  )),  actionButton("crash", "Crash the app!"))log_event <- function(level, ...) {  ts <- strftime(Sys.time(), " [%F %T] ")  message(level, ts, ...)}server <- function(input, output, session) {  log_event("INFO", "Session started")  onUnhandledError(function(err) {    # log the unhandled error    level <- if (inherits(err, "shiny.error.fatal")) "FATAL" else "ERROR"    log_event(level, conditionMessage(err))  })  onStop(function() {    log_event("INFO", "Session ended")  })  observeEvent(input$crash, stop("Oops, an unhandled error happened!"))  output$text <- renderText({    if (input$number > 7) {      stop("that's too high!")    }    sprintf("You picked number %d.", input$number)  })}shinyApp(ui, server)

Run code after an application or session ends

Description

This function registers callback functions that are invoked when theapplication exits (whenrunApp() exits), or after each usersession ends (when a client disconnects).

Usage

onStop(fun, session = getDefaultReactiveDomain())

Arguments

Value

A function which, if invoked, will cancel the callback.

See Also

onSessionEnded() for the same functionality, but atthe session level only.

Examples

## Only run this example in interactive R sessionsif (interactive()) {  # Open this application in multiple browsers, then close the browsers.  shinyApp(    ui = basicPage("onStop demo"),    server = function(input, output, session) {      onStop(function() cat("Session stopped\n"))    },    onStart = function() {      cat("Doing application setup\n")      onStop(function() {        cat("Doing application cleanup\n")      })    }  )}# In the example above, onStop() is called inside of onStart(). This is# the pattern that should be used when creating a shinyApp() object from# a function, or at the console. If instead you are writing an app.R which# will be invoked with runApp(), you can do it that way, or put the onStop()# before the shinyApp() call, as shown below.## Not run: # ==== app.R ====cat("Doing application setup\n")onStop(function() {  cat("Doing application cleanup\n")})shinyApp(  ui = basicPage("onStop demo"),  server = function(input, output, session) {    onStop(function() cat("Session stopped\n"))  })# ==== end app.R ====# Similarly, if you have a global.R, you can call onStop() from there.# ==== global.R ====cat("Doing application setup\n")onStop(function() {  cat("Doing application cleanup\n")})# ==== end global.R ====## End(Not run)

Set options for an output object.

Description

These are the available options for an output object:

• suspendWhenHidden. WhenTRUE (the default), the output objectwill be suspended (not execute) when it is hidden on the web page. WhenFALSE, the output object will not suspend when hidden, and if itwas already hidden and suspended, then it will resume immediately.

• priority. The priority level of the output object. Queued outputswith higher priority values will execute before those with lower values.

Usage

outputOptions(x, name, ...)

Arguments

Examples

## Not run: # Get the list of options for all observers within outputoutputOptions(output)# Disable suspend for output$myplotoutputOptions(output, "myplot", suspendWhenHidden = FALSE)# Change priority for output$myplotoutputOptions(output, "myplot", priority = 10)# Get the list of options for output$myplotoutputOptions(output, "myplot")## End(Not run)

Create a page with a sidebar

Description

DEPRECATED: usefluidPage() andsidebarLayout() instead.

Usage

pageWithSidebar(headerPanel, sidebarPanel, mainPanel)

Arguments

Value

A UI definition that can be passed to theshinyUI function

Parse a GET query string from a URL

Description

Returns a named list of key-value pairs.

Usage

parseQueryString(str, nested = FALSE)

Arguments

Examples

parseQueryString("?foo=1&bar=b%20a%20r")## Not run: # Example of usage within a Shiny appfunction(input, output, session) {  output$queryText <- renderText({    query <- parseQueryString(session$clientData$url_search)    # Ways of accessing the values    if (as.numeric(query$foo) == 1) {      # Do something    }    if (query[["bar"]] == "targetstring") {      # Do something else    }    # Return a string with key-value pairs    paste(names(query), query, sep = "=", collapse=", ")  })}## End(Not run)

Create a password input control

Description

Create an password control for entry of passwords.

Usage

passwordInput(  inputId,  label,  value = "",  width = NULL,  placeholder = NULL,  ...,  updateOn = c("change", "blur"))

Arguments

Value

A text input control that can be added to a UI definition.

Server value

A character string of the password input. The default value is""unlessvalue is provided.

See Also

updateTextInput()

Other input elements:actionButton(),checkboxGroupInput(),checkboxInput(),dateInput(),dateRangeInput(),fileInput(),numericInput(),radioButtons(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  passwordInput("password", "Password:"),  actionButton("go", "Go"),  verbatimTextOutput("value"))server <- function(input, output) {  output$value <- renderText({    req(input$go)    isolate(input$password)  })}shinyApp(ui, server)}

Create an plot or image output element

Description

Render arenderPlot() orrenderImage() within anapplication page.

Usage

imageOutput(  outputId,  width = "100%",  height = "400px",  click = NULL,  dblclick = NULL,  hover = NULL,  brush = NULL,  inline = FALSE,  fill = FALSE)plotOutput(  outputId,  width = "100%",  height = "400px",  click = NULL,  dblclick = NULL,  hover = NULL,  brush = NULL,  inline = FALSE,  fill = !inline)

Arguments

Value

A plot or image output element that can be included in a panel.

Interactive plots

Plots and images in Shiny support mouse-based interaction, via clicking,double-clicking, hovering, and brushing. When these interaction eventsoccur, the mouse coordinates will be sent to the server as⁠input$⁠variables, as specified byclick,dblclick,hover, orbrush.

ForplotOutput, the coordinates will be sent scaled to the dataspace, if possible. (At the moment, plots generated by base graphics andggplot2 support this scaling, although plots generated by lattice andothers do not.) If scaling is not possible, the raw pixel coordinates willbe sent. ForimageOutput, the coordinates will be sent in raw pixelcoordinates.

With ggplot2 graphics, the code inrenderPlot should return a ggplotobject; if instead the code prints the ggplot2 object with something likeprint(p), then the coordinates for interactive graphics will not beproperly scaled to the data space.

Note

The argumentsclickId andhoverId only work for R base graphics(see thegraphics package). They donot work forgrid-based graphics, such asggplot2,lattice, and so on.

See Also

For the corresponding server-side functions, seerenderPlot() andrenderImage().

Examples

# Only run these examples in interactive R sessionsif (interactive()) {# A basic shiny app with a plotOutputshinyApp(  ui = fluidPage(    sidebarLayout(      sidebarPanel(        actionButton("newplot", "New plot")      ),      mainPanel(        plotOutput("plot")      )    )  ),  server = function(input, output) {    output$plot <- renderPlot({      input$newplot      # Add a little noise to the cars data      cars2 <- cars + rnorm(nrow(cars))      plot(cars2)    })  })# A demonstration of clicking, hovering, and brushingshinyApp(  ui = basicPage(    fluidRow(      column(width = 4,        plotOutput("plot", height=300,          click = "plot_click",  # Equiv, to click=clickOpts(id="plot_click")          hover = hoverOpts(id = "plot_hover", delayType = "throttle"),          brush = brushOpts(id = "plot_brush")        ),        h4("Clicked points"),        tableOutput("plot_clickedpoints"),        h4("Brushed points"),        tableOutput("plot_brushedpoints")      ),      column(width = 4,        verbatimTextOutput("plot_clickinfo"),        verbatimTextOutput("plot_hoverinfo")      ),      column(width = 4,        wellPanel(actionButton("newplot", "New plot")),        verbatimTextOutput("plot_brushinfo")      )    )  ),  server = function(input, output, session) {    data <- reactive({      input$newplot      # Add a little noise to the cars data so the points move      cars + rnorm(nrow(cars))    })    output$plot <- renderPlot({      d <- data()      plot(d$speed, d$dist)    })    output$plot_clickinfo <- renderPrint({      cat("Click:\n")      str(input$plot_click)    })    output$plot_hoverinfo <- renderPrint({      cat("Hover (throttled):\n")      str(input$plot_hover)    })    output$plot_brushinfo <- renderPrint({      cat("Brush (debounced):\n")      str(input$plot_brush)    })    output$plot_clickedpoints <- renderTable({      # For base graphics, we need to specify columns, though for ggplot2,      # it's usually not necessary.      res <- nearPoints(data(), input$plot_click, "speed", "dist")      if (nrow(res) == 0)        return()      res    })    output$plot_brushedpoints <- renderTable({      res <- brushedPoints(data(), input$plot_brush, "speed", "dist")      if (nrow(res) == 0)        return()      res    })  })# Demo of clicking, hovering, brushing with imageOutput# Note that coordinates are in pixelsshinyApp(  ui = basicPage(    fluidRow(      column(width = 4,        imageOutput("image", height=300,          click = "image_click",          hover = hoverOpts(            id = "image_hover",            delay = 500,            delayType = "throttle"          ),          brush = brushOpts(id = "image_brush")        )      ),      column(width = 4,        verbatimTextOutput("image_clickinfo"),        verbatimTextOutput("image_hoverinfo")      ),      column(width = 4,        wellPanel(actionButton("newimage", "New image")),        verbatimTextOutput("image_brushinfo")      )    )  ),  server = function(input, output, session) {    output$image <- renderImage({      input$newimage      # Get width and height of image output      width  <- session$clientData$output_image_width      height <- session$clientData$output_image_height      # Write to a temporary PNG file      outfile <- tempfile(fileext = ".png")      png(outfile, width=width, height=height)      plot(rnorm(200), rnorm(200))      dev.off()      # Return a list containing information about the image      list(        src = outfile,        contentType = "image/png",        width = width,        height = height,        alt = "This is alternate text"      )    })    output$image_clickinfo <- renderPrint({      cat("Click:\n")      str(input$image_click)    })    output$image_hoverinfo <- renderPrint({      cat("Hover (throttled):\n")      str(input$image_hover)    })    output$image_brushinfo <- renderPrint({      cat("Brush (debounced):\n")      str(input$image_brush)    })  })}

Capture a plot as a PNG file.

Description

The PNG graphics device used is determined in the following order:

• If the ragg package is installed (and theshiny.useragg is notset toFALSE), then useragg::agg_png().

• If a quartz device is available (i.e.,capabilities("aqua") isTRUE), then usepng(type = "quartz").

• If the Cairo package is installed (and theshiny.usecairo optionis not set toFALSE), then useCairo::CairoPNG().

• Otherwise, usegrDevices::png(). In this case, Linux and Windowsmay not antialias some point shapes, resulting in poor quality output.

Usage

plotPNG(  func,  filename = tempfile(fileext = ".png"),  width = 400,  height = 400,  res = 72,  ...)

Arguments

Details

ANULL value provided towidth orheight is ignored (i.e., thedefaultwidth orheight of the graphics device is used).

Value

A path to the newly generated PNG file.

Create radio buttons

Description

Create a set of radio buttons used to select an item from a list.

Usage

radioButtons(  inputId,  label,  choices = NULL,  selected = NULL,  inline = FALSE,  width = NULL,  choiceNames = NULL,  choiceValues = NULL)

Arguments

Details

If you need to represent a "None selected" state, it's possible to defaultthe radio buttons to have no options selected by usingselected = character(0). However, this is not recommended, as it gives the user no wayto return to that state once they've made a selection. Instead, considerhaving the first of your choices bec("None selected" = "").

Value

A set of radio buttons that can be added to a UI definition.

Server value

A character string containing the value of the selected button.

See Also

updateRadioButtons()

Other input elements:actionButton(),checkboxGroupInput(),checkboxInput(),dateInput(),dateRangeInput(),fileInput(),numericInput(),passwordInput(),selectInput(),sliderInput(),submitButton(),textAreaInput(),textInput(),varSelectInput()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  radioButtons("dist", "Distribution type:",               c("Normal" = "norm",                 "Uniform" = "unif",                 "Log-normal" = "lnorm",                 "Exponential" = "exp")),  plotOutput("distPlot"))server <- function(input, output) {  output$distPlot <- renderPlot({    dist <- switch(input$dist,                   norm = rnorm,                   unif = runif,                   lnorm = rlnorm,                   exp = rexp,                   rnorm)    hist(dist(500))  })}shinyApp(ui, server)ui <- fluidPage(  radioButtons("rb", "Choose one:",               choiceNames = list(                 icon("calendar"),                 HTML("<p style='color:red;'>Red Text</p>"),                 "Normal text"               ),               choiceValues = list(                 "icon", "html", "text"               )),  textOutput("txt"))server <- function(input, output) {  output$txt <- renderText({    paste("You chose", input$rb)  })}shinyApp(ui, server)}

Create a reactive expression

Description

Wraps a normal expression to create a reactive expression. Conceptually, areactive expression is a expression whose result will change over time.

Usage

reactive(  x,  env = parent.frame(),  quoted = FALSE,  ...,  label = NULL,  domain = getDefaultReactiveDomain(),  ..stacktraceon = TRUE)is.reactive(x)

Arguments

Details

Reactive expressions are expressions that can read reactive values and callother reactive expressions. Whenever a reactive value changes, any reactiveexpressions that depended on it are marked as "invalidated" and willautomatically re-execute if necessary. If a reactive expression is marked asinvalidated, any other reactive expressions that recently called it are alsomarked as invalidated. In this way, invalidations ripple through theexpressions that depend on each other.

See theShiny tutorial formore information about reactive expressions.

Value

a function, wrapped in a S3 class "reactive"

Examples

library(rlang)values <- reactiveValues(A=1)reactiveB <- reactive({  values$A + 1})# View the values from the R console with isolate()isolate(reactiveB())# 2# To store expressions for later conversion to reactive, use quote()myquo <- rlang::quo(values$A + 2)# Unexpected value! Sending a quosure directly will not work as expected.reactiveC <- reactive(myquo)# We'd hope for `3`, but instead we get the quosure that was supplied.isolate(reactiveC())# Instead, the quosure should be `rlang::inject()`edreactiveD <- rlang::inject(reactive(!!myquo))isolate(reactiveD())# 3# (Legacy) Can use quoted expressionsexpr <- quote({ values$A + 3 })reactiveE <- reactive(expr, quoted = TRUE)isolate(reactiveE())# 4

Activate reactivity in the console

Description

This is an experimental feature that allows you to enable reactivityat the console, for the purposes of experimentation and learning.

Usage

reactiveConsole(enabled)

Arguments

Examples

reactiveConsole(TRUE)x <- reactiveVal(10)y <- observe({  message("The value of x is ", x())})x(20)x(30)reactiveConsole(FALSE)

Reactive file reader

Description

Given a file path and read function, returns a reactive data source for thecontents of the file.

Usage

reactiveFileReader(intervalMillis, session, filePath, readFunc, ...)

Arguments

Details

reactiveFileReader works by periodically checking the file's lastmodified time; if it has changed, then the file is re-read and any reactivedependents are invalidated.

TheintervalMillis,filePath, andreadFunc functionswill each be executed in a reactive context; therefore, they may readreactive values and reactive expressions.

Value

A reactive expression that returns the contents of the file, andautomatically invalidates when the file changes on disk (as determined bylast modified time).

See Also

reactivePoll()

Examples

## Not run: # Per-session reactive file readerfunction(input, output, session) {  fileData <- reactiveFileReader(1000, session, 'data.csv', read.csv)  output$data <- renderTable({    fileData()  })}# Cross-session reactive file reader. In this example, all sessions share# the same reader, so read.csv only gets executed once no matter how many# user sessions are connected.fileData <- reactiveFileReader(1000, NULL, 'data.csv', read.csv)function(input, output, session) {  output$data <- renderTable({    fileData()  })}## End(Not run)

Reactive polling

Description

Used to create a reactive data source, which works by periodically polling anon-reactive data source.

Usage

reactivePoll(intervalMillis, session, checkFunc, valueFunc)

Arguments

Details

reactivePoll works by pairing a relatively cheap "check" function witha more expensive value retrieval function. The check function will beexecuted periodically and should always return a consistent value until thedata changes. When the check function returns a different value, then thevalue retrieval function will be used to re-populate the data.

Note that the check function doesn't returnTRUE orFALSE toindicate whether the underlying data has changed. Rather, the check functionindicates change by returning a different value from the previous time it wascalled.

For example,reactivePoll is used to implementreactiveFileReader by pairing a check function that simply returns thelast modified timestamp of a file, and a value retrieval function thatactually reads the contents of the file.

As another example, one might read a relational database table reactively byusing a check function that does⁠SELECT MAX(timestamp) FROM table⁠ anda value retrieval function that does⁠SELECT * FROM table⁠.

TheintervalMillis,checkFunc, andvalueFunc functionswill be executed in a reactive context; therefore, they may read reactivevalues and reactive expressions.

Value

A reactive expression that returns the result ofvalueFunc,and invalidates whencheckFunc changes.

See Also

reactiveFileReader()

Examples

function(input, output, session) {  data <- reactivePoll(1000, session,    # This function returns the time that log_file was last modified    checkFunc = function() {      if (file.exists(log_file))        file.info(log_file)$mtime[1]      else        ""    },    # This function returns the content of log_file    valueFunc = function() {      read.csv(log_file)    }  )  output$dataTable <- renderTable({    data()  })}

Timer

Description

Creates a reactive timer with the given interval. A reactive timer is like areactive value, except reactive values are triggered when they are set, whilereactive timers are triggered simply by the passage of time.

Usage

reactiveTimer(intervalMs = 1000, session = getDefaultReactiveDomain())

Arguments

Details

Reactive expressions and observers that want to beinvalidated by the timer need to call the timer function thatreactiveTimer returns, even if the current time value is not actuallyneeded.

SeeinvalidateLater() as a safer and simpler alternative.

Value

A no-parameter function that can be called from a reactive context,in order to cause that context to be invalidated the next time the timerinterval elapses. Calling the returned function also happens to yield thecurrent time (as inbase::Sys.time()).

See Also

invalidateLater()

Examples

## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  sliderInput("n", "Number of observations", 2, 1000, 500),  plotOutput("plot"))server <- function(input, output) {  # Anything that calls autoInvalidate will automatically invalidate  # every 2 seconds.  autoInvalidate <- reactiveTimer(2000)  observe({    # Invalidate and re-execute this reactive expression every time the    # timer fires.    autoInvalidate()    # Do something each time this is invalidated.    # The isolate() makes this observer _not_ get invalidated and re-executed    # when input$n changes.    print(paste("The value of input$n is", isolate(input$n)))  })  # Generate a new histogram each time the timer fires, but not when  # input$n changes.  output$plot <- renderPlot({    autoInvalidate()    hist(rnorm(isolate(input$n)))  })}shinyApp(ui, server)}

Create a (single) reactive value

Description

ThereactiveVal function is used to construct a "reactive value"object. This is an object used for reading and writing a value, like avariable, but with special capabilities for reactive programming. When youread the value out of a reactiveVal object, the calling reactive expressiontakes a dependency, and when you change the value, it notifies any reactivesthat previously depended on that value.

Usage

reactiveVal(value = NULL, label = NULL)

Arguments

Details

reactiveVal is very similar toreactiveValues(), exceptthat the former is for a single reactive value (like a variable), whereas thelatter lets you conveniently use multiple reactive values by name (like anamed list of variables). For a one-off reactive value, it's more natural tousereactiveVal. See the Examples section for an illustration.

Value

A function. Call the function with no arguments to (reactively) readthe value; call the function with a single argument to set the value.

Examples

## Not run: # Create the object by calling reactiveValr <- reactiveVal()# Set the value by calling with an argumentr(10)# Read the value by calling without argumentsr()## End(Not run)## Only run examples in interactive R sessionsif (interactive()) {ui <- fluidPage(  actionButton("minus", "-1"),  actionButton("plus", "+1"),  br(),  textOutput("value"))# The comments below show the equivalent logic using reactiveValues()server <- function(input, output, session) {  value <- reactiveVal(0)       # rv <- reactiveValues(value = 0)  observeEvent(input$minus, {    newValue <- value() - 1     # newValue <- rv$value - 1    value(newValue)             # rv$value <- newValue  })  observeEvent(input$plus, {    newValue <- value() + 1     # newValue <- rv$value + 1    value(newValue)             # rv$value <- newValue  })  output$value <- renderText({    value()                     # rv$value  })}shinyApp(ui, server)}

Create an object for storing reactive values

Description

This function returns an object for storing reactive values. It is similar toa list, but with special capabilities for reactive programming. When you reada value from it, the calling reactive expression takes a reactive dependencyon that value, and when you write to it, it notifies any reactive functionsthat depend on that value. Note that values taken from the reactiveValuesobject are reactive, but the reactiveValues object itself is not.

Usage

reactiveValues(...)

Arguments

See Also

isolate() andis.reactivevalues().

Examples

# Create the object with no valuesvalues <- reactiveValues()# Assign values to 'a' and 'b'values$a <- 3values[['b']] <- 4## Not run: # From within a reactive context, you can access values with:values$avalues[['a']]## End(Not run)# If not in a reactive context (e.g., at the console), you can use isolate()# to retrieve the value:isolate(values$a)isolate(values[['a']])# Set values upon creationvalues <- reactiveValues(a = 1, b = 2)isolate(values$a)

Convert a reactivevalues object to a list

Description

This function does something similar to what you might want or expectbase::as.list() to do. The difference is that the calling context will takedependencies on every object in thereactivevalues object. To avoid takingdependencies on all the objects, you can wrap the call withisolate().

Usage

reactiveValuesToList(x, all.names = FALSE)

Arguments

Examples

values <- reactiveValues(a = 1)## Not run: reactiveValuesToList(values)## End(Not run)# To get the objects without taking dependencies on them, use isolate().# isolate() can also be used when calling from outside a reactive context (e.g.# at the console)isolate(reactiveValuesToList(values))

Reactive Log Visualizer

Description

Provides an interactive browser-based tool for visualizing reactivedependencies and execution in your application.

Usage

reactlog()reactlogShow(time = TRUE)reactlogReset()reactlogAddMark(session = getDefaultReactiveDomain())