route$add_handler("get", dash_reload_hash, function(request, response, keys, ...) {

modified_files <- private$modified_since_reload

hard <- TRUE

if (is.null(modified_files)) {

# dash-renderer requires that this element not be NULL

modified_files <- list()

}

resp <- list(files = modified_files,

hard = hard,

unique(

vapply(

USE.NAMES = FALSE)

)

),

private$modified_since_reload <- list()

TRUE

})

router$add_route(route, "dashR-endpoints")

server$attach(router)

server$on("start", function(server, ...) {

private$generateReloadHash()

private$index()

use_viewer <- !(is.null(getOption("viewer"))) && (dynGet("use_viewer") == TRUE)

host <- dynGet("host")

port <- dynGet("port")

app_url <- paste0("http://", host, ":", port)

rstudioapi::viewer(app_url)

else if (use_viewer) {

warning("\U{26A0} RStudio viewer not supported; ensure that host is 'localhost' or '127.0.0.1' and that you are using RStudio to run your app. Opening default browser...")

# ------------------------------------------------------------------------

# convenient fiery wrappers

# ------------------------------------------------------------------------

use_viewer = FALSE,

dev_tools_ui = Sys.getenv('DASH_UI'),

dev_tools_props_check = Sys.getenv('DASH_PROPS_CHECK'),

dev_tools_hot_reload = Sys.getenv('DASH_HOT_RELOAD'),

# fiery is attempting to launch a server within a server, abort gracefully

return(NULL)

}

getServerParam <- function(value, type, default) {

if (value != "" && length(value) != 0 && mode(value) == type && !is.na(value)) {

return(value)

} else {

return(default)

}

}

self$server$host <- getServerParam(host, "character", "127.0.0.1")

self$server$port <- getServerParam(as.integer(port), "numeric", 8050)

dev_tools_ui <- getServerParam(dev_tools_ui, "logical", NULL)

dev_tools_props_check <- getServerParam(dev_tools_props_check, "logical", NULL)

if(getAppPath() != FALSE) {

source_dir <- dirname(getAppPath())

private$app_root_modtime <- modtimeFromPath(source_dir, recursive = TRUE, asset_path = private$assets_folder)

} else {

source_dir <- NULL

}

# set the modtime to track state of the Dash app directory

# this calls getAppPath, which will try three approaches to

# identifying the local app path (depending on whether the app

} else {

self$config$ui <- FALSE

}

if (is.null(dev_tools_hot_reload) && debug || isTRUE(dev_tools_hot_reload)) {

hot_reload <- TRUE

hot_reload_interval <- getServerParam(dev_tools_hot_reload_interval, "numeric", 3)

} else {

hot_reload <- FALSE

}

if (is.null(dev_tools_silence_routes_logging) && debug || isTRUE(dev_tools_silence_routes_logging)) {

self$config$silence_routes_logging <- TRUE

} else {

private$prune_errors <- getServerParam(dev_tools_prune_errors, "logical", TRUE)

private$debug <- debug

if (hot_reload == TRUE & !(is.null(source_dir))) {

self$server$on('cycle-end', function(server, ...) {

# handle case where assets are not present, since we can still hot reload the app itself

} else {

permit_reload <- FALSE

}

if (permit_reload) {

if (dir.exists(private$assets_folder)) {

# by specifying asset_path, we can exclude assets from the root_modtime when recursive=TRUE

updated_assets <- FALSE

private$app_root_modtime <- current_root_modtime

}

if (!is.null(current_asset_modtime) && updated_assets) {

# refreshAssetMap silently returns a list of updated objects in the map

# we can use this to retrieve the modified files, and also determine if

# any are scripts or other non-CSS data

has_assets <- file.exists(file.path(source_dir, private$assets_folder))

if (length(has_assets) != 0 && has_assets) {

updated_files <- private$refreshAssetMap()

file_extensions <- tools::file_ext(updated_files$modified)

# if the vector of file_extensions is logical(0), this ensures

# we return FALSE instead of logical(0)

checkIfCSS <- function(extension) {

else

return(extension == "css")

}

all_updated <- c(updated_files$added, updated_files$modified)

function(current_file) {

list(is_css = checkIfCSS(tools::file_ext(current_file)),

modified = modtimeFromPath(current_file),

url = paste(private$assets_url_path, basename(current_file), sep="/"))

})

private$asset_modtime <- current_asset_modtime

# update the hash passed back to the renderer, and bump the timestamp

# to match the current reloading event

other_deleted <- any(tools::file_ext(updated_files$deleted) != "css")

}

}

if (updated_assets || updated_root) {

self$config$reload_hash <- private$generateReloadHash()

flush.console()

# if any filetypes other than CSS are encountered in those which

# are modified or deleted, restart the server

hard_reload <- updated_root || (has_assets && (other_changed || other_added || other_deleted))

if (!hard_reload) {

# refresh the index but don't restart the server

private$index()

}

}

}

# reset the timestamp so we're able to determine when the last cycle end occurred

private$last_cycle <- as.integer(Sys.time())

})

} else if (hot_reload == TRUE & is.null(source_dir)) {

message("\U{26A0} No source directory information available; hot reloading has been disabled.\nPlease ensure that you are loading your Dash for R application using source().\n")

self$server$ignite(block = block, showcase = showcase, ...)

}

),

css = NULL,

scripts = NULL,

other = NULL,

# initialize flags for debug mode and stack pruning

debug = NULL,

prune_errors = NULL,

stack_message = NULL,

# callback context

# fields for setting modification times and paths to track state

asset_modtime = NULL,

app_launchtime = NULL,

last_refresh = NULL,

last_cycle = NULL,

modified_since_reload = NULL,

# fields for tracking HTML dependencies

dependencies = list(),

dependencies_user = list(),

dependencies_internal = list(),

# layout stuff

layout_ = NULL,

layout_ids = NULL,

} else {

private$asset_modtime <- modtimeFromPath(private$assets_folder, recursive = TRUE)

}

# before refreshing the asset map, temporarily store it for the

previous_map <- private$asset_map

# refresh the asset map

current_map <- private$walk_assets_directory(private$assets_folder)

# assets; this returns a list whose subelements correspond to each

# class, and three vectors of updated objects for each (deleted,

# changed, and new files)

SIMPLIFY=FALSE)

# these lines collapse the modified assets into vectors, and scrub

# duplicated NULL return values

deleted <- unlist(lapply(list_of_diffs, `[`, "deleted"))

changed <- unlist(lapply(list_of_diffs, `[`, "changed"))

new <- unlist(lapply(list_of_diffs, `[`, "new"))

# update the asset map

private$asset_map <- current_map

# when the asset map is refreshed, this function will invisibly

# return the vectors of updated assets, grouped by deleted,

# modified, and added files

private$last_refresh <- as.integer(Sys.time())

return(invisible(list(deleted=deleted,

modified=changed,

added=new)))

return(NULL)

}

},

walk_assets_directory = function(assets_dir = private$assets_folder) {

# obtain the full canonical path

asset_path <- normalizePath(file.path(assets_dir))

# set attributes for the return object to include the file

# modification times for each entry in the asset_map

other = setModtimeAsAttr(other_files_map)

)

)

# akin to https://github.com/plotly/dash/blob/d2ebc837/dash/dash.py#L338

# note discussion here https://github.com/plotly/dash/blob/d2ebc837/dash/dash.py#L279-L284

.index = NULL,

generateReloadHash = function() {

last_update_time <- max(as.integer(private$app_root_modtime),

as.integer(private$asset_modtime),

as.integer(private$app_launchtime),

na.rm=TRUE)

# update the timestamp to reflect the current reloading event

private$last_reload <- as.integer(Sys.time())

digest::digest(as.character(last_update_time),

"md5",

serialize = FALSE)

},

collect_resources = function() {

# Dash's own dependencies

# serve the dev version of dash-renderer when in debug mode

local = FALSE)

# collect JS assets from dependencies

if (!(is.null(private$asset_map$scripts))) {

scripts_assets <- generate_js_dist_html(href = paste0(private$assets_url_path, names(private$asset_map$scripts)),

local = TRUE,