teal.reporter coverage - 78.93%

Files
Source

File	Lines	Relevant	Covered	Missed	Hits / Line	Coverage
R/zzz.R	22	11	1	10	0	9.09%
R/utils.R	216	100	36	64	2	36.00%
R/DownloadModule.R	332	183	128	55	3	69.95%
R/Renderer.R	288	104	73	31	5	70.19%
R/Previewer.R	481	277	198	79	6	71.48%
R/LoadReporterModule.R	139	79	63	16	2	79.75%
R/ContentBlock.R	80	15	13	2	83	86.67%
R/PictureBlock.R	129	27	25	2	17	92.59%
R/Reporter.R	357	100	96	4	12	96.00%
R/ReportCard.R	290	79	76	3	21	96.20%
R/yaml_utils.R	315	78	76	2	12	97.44%
R/AddCardModule.R	217	107	105	2	8	98.13%
R/ResetModule.R	86	40	40	0	5	100.00%
R/SimpleReporter.R	90	25	25	0	2	100.00%
R/RcodeBlock.R	120	18	18	0	49	100.00%
R/TextBlock.R	119	15	15	0	58	100.00%
R/FileBlock.R	64	13	13	0	19	100.00%
R/HTMLBlock.R	62	9	9	0	5	100.00%
R/TableBlock.R	52	9	9	0	14	100.00%
R/NewpageBlock.R	27	2	2	0	14	100.00%

#' Download report button module
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Provides a button that triggers downloading a report.
#'
#' For more information, refer to the vignette: `vignette("simpleReporter", "teal.reporter")`.
#'
#' @details `r global_knitr_details()`
#'
#' @name download_report_button
#'
#' @param id (`character(1)`) this `shiny` module's id.
#' @param reporter (`Reporter`) instance.
#' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
#'  for customizing the rendering process.
#' @inheritParams reporter_download_inputs
#'
#' @return `NULL`.
NULL

#' @rdname download_report_button
#' @export
download_report_button_ui <- function(id) {
  ns <- shiny::NS(id)
  shiny::tagList(
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
    ),
    shiny::actionButton(
      ns("download_button"),
      class = "teal-reporter simple_report_button btn-primary",
      title = "Download",
      `data-val` = shiny::restoreInput(id = ns("download_button"), default = NULL),
      shiny::tags$span(
        shiny::icon("download")
      )
    )
  )
}

#' @rdname download_report_button
#' @export
download_report_button_srv <- function(id,
                                       reporter,
                                       global_knitr = getOption("teal.reporter.global_knitr"),
                                       rmd_output = c(
                                         "html" = "html_document", "pdf" = "pdf_document",
                                         "powerpoint" = "powerpoint_presentation", "word" = "word_document"
                                       ),
                                       rmd_yaml_args = list(
                                         author = "NEST", title = "Report",
                                         date = as.character(Sys.Date()), output = "html_document",
                                         toc = FALSE
                                       )) {
  checkmate::assert_class(reporter, "Reporter")
  checkmate::assert_subset(names(global_knitr), names(knitr::opts_chunk$get()))
  checkmate::assert_subset(
    rmd_output,
    c(
      "html_document", "pdf_document",
      "powerpoint_presentation", "word_document"
    ),
    empty.ok = FALSE
  )
  checkmate::assert_list(rmd_yaml_args, names = "named")
  checkmate::assert_names(
    names(rmd_yaml_args),
    subset.of = c("author", "title", "date", "output", "toc"),
    must.include = "output"
  )
  checkmate::assert_true(rmd_yaml_args[["output"]] %in% rmd_output)

  shiny::moduleServer(id, function(input, output, session) {
    shiny::setBookmarkExclude(c("download_button"))

    ns <- session$ns

    download_modal <- function() {
      nr_cards <- length(reporter$get_cards())
      downb <- shiny::tags$a(
        id = ns("download_data"),
        class = paste("btn btn-primary shiny-download-link", if (nr_cards) NULL else "disabled"),
        style = if (nr_cards) NULL else "pointer-events: none;",
        href = "",
        target = "_blank",
        download = NA,
        shiny::icon("download"),
        "Download"
      )
      shiny::tags$div(
        class = "teal-widgets reporter-modal",
        shiny::modalDialog(
          easyClose = TRUE,
          shiny::tags$h3("Download the Report"),
          shiny::tags$hr(),
          if (length(reporter$get_cards()) == 0) {
            shiny::tags$div(
              class = "mb-4",
              shiny::tags$p(
                class = "text-danger",
                shiny::tags$strong("No Cards Added")
              )
            )
          } else {
            shiny::tags$div(
              class = "mb-4",
              shiny::tags$p(
                class = "text-success",
                shiny::tags$strong(paste("Number of cards: ", nr_cards))
              ),
            )
          },
          reporter_download_inputs(
            rmd_yaml_args = rmd_yaml_args,
            rmd_output = rmd_output,
            showrcode = any_rcode_block(reporter),
            session = session
          ),
          footer = shiny::tagList(
            shiny::tags$button(
              type = "button",
              class = "btn btn-secondary",
              `data-dismiss` = "modal",
              `data-bs-dismiss` = "modal",
              NULL,
              "Cancel"
            ),
            downb
          )
        )
      )
    }

    shiny::observeEvent(input$download_button, {
      shiny::showModal(download_modal())
    })

    output$download_data <- shiny::downloadHandler(
      filename = function() {
        paste0(
          "report_",
          if (reporter$get_id() == "") NULL else paste0(reporter$get_id(), "_"),
          format(Sys.time(), "%y%m%d%H%M%S"),
          ".zip"
        )
      },
      content = function(file) {
        shiny::showNotification("Rendering and Downloading the document.")
        shinybusy::block(id = ns("download_data"), text = "", type = "dots")
        input_list <- lapply(names(rmd_yaml_args), function(x) input[[x]])
        names(input_list) <- names(rmd_yaml_args)
        if (is.logical(input$showrcode)) global_knitr[["echo"]] <- input$showrcode
        report_render_and_compress(reporter, input_list, global_knitr, file)
        shinybusy::unblock(id = ns("download_data"))
      },
      contentType = "application/zip"
    )
  })
}

#' Render the report
#'
#' Render the report and zip the created directory.
#'
#' @param reporter (`Reporter`) instance.
#' @param input_list (`list`) like `shiny` input converted to a regular named list.
#' @param global_knitr (`list`) a global `knitr` parameters, like echo.
#' But if local parameter is set it will have priority.
#' @param file (`character(1)`) where to copy the returned directory.
#'
#' @return `file` argument, invisibly.
#'
#' @keywords internal
report_render_and_compress <- function(reporter, input_list, global_knitr, file = tempdir()) {
  checkmate::assert_class(reporter, "Reporter")
  checkmate::assert_list(input_list, names = "named")
  checkmate::assert_string(file)

  if (
    identical("pdf_document", input_list$output) &&
      inherits(try(system2("pdflatex", "--version", stdout = TRUE), silent = TRUE), "try-error")
  ) {
    shiny::showNotification(
      ui = "pdflatex is not available so the pdf_document could not be rendered. Please use other output type.",
      action = "Please contact app developer",
      type = "error"
    )
    stop("pdflatex is not available so the pdf_document could not be rendered.")
  }

  yaml_header <- as_yaml_auto(input_list)
  renderer <- Renderer$new()

  tryCatch(
    renderer$render(reporter$get_blocks(), yaml_header, global_knitr),
    warning = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Render document warning!",
        action = "Please contact app developer",
        type = "warning"
      )
    },
    error = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Render document error!",
        action = "Please contact app developer",
        type = "error"
      )
    }
  )

  output_dir <- renderer$get_output_dir()

  tryCatch(
    archiver_dir <- reporter$to_jsondir(output_dir),
    warning = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Archive document warning!",
        action = "Please contact app developer",
        type = "warning"
      )
    },
    error = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Archive document error!",
        action = "Please contact app developer",
        type = "error"
      )
    }
  )

  temp_zip_file <- tempfile(fileext = ".zip")
  tryCatch(
    expr = zip::zipr(temp_zip_file, output_dir),
    warning = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Zipping folder warning!",
        action = "Please contact app developer",
        type = "warning"
      )
    },
    error = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Zipping folder error!",
        action = "Please contact app developer",
        type = "error"
      )
    }
  )

  tryCatch(
    expr = file.copy(temp_zip_file, file),
    warning = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Copying file warning!",
        action = "Please contact app developer",
        type = "warning"
      )
    },
    error = function(cond) {
      print(cond)
      shiny::showNotification(
        ui = "Copying file error!",
        action = "Please contact app developer",
        type = "error"
      )
    }
  )

  rm(renderer)
  invisible(file)
}

#' Get the custom list of UI inputs
#'
#' @param rmd_output (`character`) vector with `rmarkdown` output types,
#' by default all possible `pdf_document`, `html_document`, `powerpoint_presentation`, and `word_document`.
#' If vector is named then those names will appear in the `UI`.
#' @param rmd_yaml_args (`named list`) with `Rmd` `yaml` header fields and their default values.
#' This `list` will result in the custom subset of UI inputs for the download reporter functionality.
#' Default `list(author = "NEST", title = "Report", date = Sys.Date(), output = "html_document", toc = FALSE)`.
#' The `list` must include at least `"output"` field.
#' The default value for `"output"` has to be in the `rmd_output` argument.
#'
#' @keywords internal
reporter_download_inputs <- function(rmd_yaml_args, rmd_output, showrcode, session) {
  shiny::tagList(
    lapply(names(rmd_yaml_args), function(e) {
      switch(e,
        author = shiny::textInput(session$ns("author"), label = "Author:", value = rmd_yaml_args$author),
        title = shiny::textInput(session$ns("title"), label = "Title:", value = rmd_yaml_args$title),
        date = shiny::dateInput(session$ns("date"), "Date:", value = rmd_yaml_args$date),
        output = shiny::tags$div(
          shinyWidgets::pickerInput(
            inputId = session$ns("output"),
            label = "Choose a document type: ",
            choices = rmd_output,
            selected = rmd_yaml_args$output
          )
        ),
        toc = shiny::checkboxInput(session$ns("toc"), label = "Include Table of Contents", value = rmd_yaml_args$toc)
      )
    }),
    if (showrcode) {
      shiny::checkboxInput(
        session$ns("showrcode"),
        label = "Include R Code",
        value = FALSE
      )
    }
  )
}

#' @noRd
#' @keywords internal
any_rcode_block <- function(reporter) {
  any(
    vapply(
      reporter$get_blocks(),
      function(e) inherits(e, "RcodeBlock"),
      logical(1)
    )
  )
}

#' @title `Renderer`
#' @docType class
#' @description
#' A class for rendering reports from `ContentBlock` into various formats using `rmarkdown`.
#' It supports `TextBlock`, `PictureBlock`, `RcodeBlock`, `NewpageBlock`, and `TableBlock`.
#'
#' @keywords internal
Renderer <- R6::R6Class( # nolint: object_name_linter.
  classname = "Renderer",
  public = list(
    #' @description Initialize a `Renderer` object.
    #'
    #' @details Creates a new instance of `Renderer`
    #' with a temporary directory for storing report files.
    #'
    #' @return Object of class `Renderer`, invisibly.
    #' @examples
    #' Renderer <- getFromNamespace("Renderer", "teal.reporter")
    #' Renderer$new()
    #'
    initialize = function() {
      tmp_dir <- tempdir()
      output_dir <- file.path(tmp_dir, sprintf("report_%s", gsub("[.]", "", format(Sys.time(), "%Y%m%d%H%M%OS4"))))
      dir.create(path = output_dir)
      private$output_dir <- output_dir
      invisible(self)
    },
    #' @description Finalizes a `Renderer` object.
    finalize = function() {
      unlink(private$output_dir, recursive = TRUE)
    },
    #' @description Getting the `Rmd` text which could be easily rendered later.
    #'
    #' @param blocks (`list`) of `TextBlock`, `PictureBlock` and `NewpageBlock` objects.
    #' @param yaml_header (`character`) an `rmarkdown` `yaml` header.
    #' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
    #'  for customizing the rendering process.
    #' @details `r global_knitr_details()`
    #'
    #' @return Character vector constituting `rmarkdown` text (`yaml` header + body), ready to be rendered.
    #' @examplesIf require("ggplot2")
    #' library(yaml)
    #' library(rtables)
    #' library(ggplot2)
    #'
    #' ReportCard <- getFromNamespace("ReportCard", "teal.reporter")
    #' Reporter <- getFromNamespace("Reporter", "teal.reporter")
    #' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
    #' md_header <- getFromNamespace("md_header", "teal.reporter")
    #' Renderer <- getFromNamespace("Renderer", "teal.reporter")
    #'
    #' card1 <- ReportCard$new()
    #' card1$append_text("Header 2 text", "header2")
    #' card1$append_text("A paragraph of default text")
    #' card1$append_plot(
    #'  ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )
    #'
    #' card2 <- ReportCard$new()
    #' card2$append_text("Header 2 text", "header2")
    #' card2$append_text("A paragraph of default text")
    #' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
    #' table_res2 <- build_table(lyt, airquality)
    #' card2$append_table(table_res2)
    #' card2$append_rcode("2+2", echo = FALSE)
    #'
    #' reporter <- Reporter$new()
    #' reporter$append_cards(list(card1, card2))
    #'
    #' yaml_l <- list(
    #'   author = yaml_quoted("NEST"),
    #'   title = yaml_quoted("Report"),
    #'   date = yaml_quoted("07/04/2019"),
    #'   output = list(html_document = list(toc = FALSE))
    #' )
    #'
    #' yaml_header <- md_header(as.yaml(yaml_l))
    #'
    #' result_path <- Renderer$new()$renderRmd(reporter$get_blocks(), yaml_header)
    #'
    renderRmd = function(blocks, yaml_header, global_knitr = getOption("teal.reporter.global_knitr")) {
      checkmate::assert_list(
        blocks,
        c("TextBlock", "PictureBlock", "NewpageBlock", "TableBlock", "RcodeBlock", "HTMLBlock")
      )
      checkmate::assert_subset(names(global_knitr), names(knitr::opts_chunk$get()))
      if (missing(yaml_header)) {
        yaml_header <- md_header(yaml::as.yaml(list(title = "Report")))
      }

      private$report_type <- get_yaml_field(yaml_header, "output")

      parsed_global_knitr <- sprintf(
        "\n```{r setup, include=FALSE}\nknitr::opts_chunk$set(%s)\n%s\n```\n",
        capture.output(dput(global_knitr)),
        if (identical(private$report_type, "powerpoint_presentation")) {
          format_code_block_function <- quote(
            code_block <- function(code_text) {
              df <- data.frame(code_text)
              ft <- flextable::flextable(df)
              ft <- flextable::delete_part(ft, part = "header")
              ft <- flextable::autofit(ft, add_h = 0)
              ft <- flextable::fontsize(ft, size = 7, part = "body")
              ft <- flextable::bg(x = ft, bg = "lightgrey")
              ft <- flextable::border_outer(ft)
              if (flextable::flextable_dim(ft)$widths > 8) {
                ft <- flextable::width(ft, width = 8)
              }
              ft
            }
          )
          paste(deparse(format_code_block_function), collapse = "\n")
        } else {
          ""
        }
      )

      parsed_blocks <- paste(
        unlist(
          lapply(blocks, function(b) private$block2md(b))
        ),
        collapse = "\n\n"
      )

      rmd_text <- paste0(yaml_header, "\n", parsed_global_knitr, "\n", parsed_blocks, "\n")
      tmp <- tempfile(fileext = ".Rmd")
      input_path <- file.path(
        private$output_dir,
        sprintf("input_%s.Rmd", gsub("[.]", "", format(Sys.time(), "%Y%m%d%H%M%OS3")))
      )
      cat(rmd_text, file = input_path)
      input_path
    },
    #' @description Renders the `Report` to the desired output format by compiling the `rmarkdown` file.
    #'
    #' @param blocks (`list`) of `TextBlock`, `PictureBlock` or `NewpageBlock` objects.
    #' @param yaml_header (`character`) an `rmarkdown` `yaml` header.
    #' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
    #'  for customizing the rendering process.
    #' @param ... `rmarkdown::render` arguments, `input` and `output_dir` should not be updated.
    #' @details `r global_knitr_details()`
    #'
    #' @return `character` path to the output.
    #' @examplesIf require("ggplot2")
    #' library(yaml)
    #' library(ggplot2)
    #'
    #' ReportCard <- getFromNamespace("ReportCard", "teal.reporter")
    #' Reporter <- getFromNamespace("Reporter", "teal.reporter")
    #' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
    #' md_header <- getFromNamespace("md_header", "teal.reporter")
    #' Renderer <- getFromNamespace("Renderer", "teal.reporter")
    #'
    #' card1 <- ReportCard$new()
    #' card1$append_text("Header 2 text", "header2")
    #' card1$append_text("A paragraph of default text")
    #' card1$append_plot(
    #'  ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )
    #'
    #' card2 <- ReportCard$new()
    #' card2$append_text("Header 2 text", "header2")
    #' card2$append_text("A paragraph of default text")
    #' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
    #' table_res2 <- build_table(lyt, airquality)
    #' card2$append_table(table_res2)
    #' card2$append_rcode("2+2", echo = FALSE)
    #'
    #' reporter <- Reporter$new()
    #' reporter$append_cards(list(card1, card2))
    #'
    #' yaml_l <- list(
    #'   author = yaml_quoted("NEST"),
    #'   title = yaml_quoted("Report"),
    #'   date = yaml_quoted("07/04/2019"),
    #'   output = list(html_document = list(toc = FALSE))
    #' )
    #'
    #' yaml_header <- md_header(as.yaml(yaml_l))
    #' result_path <- Renderer$new()$render(reporter$get_blocks(), yaml_header)
    #'
    render = function(blocks, yaml_header, global_knitr = getOption("teal.reporter.global_knitr"), ...) {
      args <- list(...)
      input_path <- self$renderRmd(blocks, yaml_header, global_knitr)
      args <- append(args, list(
        input = input_path,
        output_dir = private$output_dir,
        output_format = "all",
        quiet = TRUE
      ))
      args_nams <- unique(names(args))
      args <- lapply(args_nams, function(x) args[[x]])
      names(args) <- args_nams
      do.call(rmarkdown::render, args)
    },
    #' @description Get `output_dir` field.
    #'
    #' @return `character` a `output_dir` field path.
    #' @examples
    #' Renderer <- getFromNamespace("Renderer", "teal.reporter")$new()
    #' Renderer$get_output_dir()
    #'
    get_output_dir = function() {
      private$output_dir
    }
  ),
  private = list(
    output_dir = character(0),
    report_type = NULL,
    # factory method
    block2md = function(block) {
      if (inherits(block, "TextBlock")) {
        private$textBlock2md(block)
      } else if (inherits(block, "RcodeBlock")) {
        private$rcodeBlock2md(block)
      } else if (inherits(block, "PictureBlock")) {
        private$pictureBlock2md(block)
      } else if (inherits(block, "TableBlock")) {
        private$tableBlock2md(block)
      } else if (inherits(block, "NewpageBlock")) {
        block$get_content()
      } else if (inherits(block, "HTMLBlock")) {
        private$htmlBlock2md(block)
      } else {
        stop("Unknown block class")
      }
    },
    # card specific methods
    textBlock2md = function(block) {
      text_style <- block$get_style()
      block_content <- block$get_content()
      switch(text_style,
        "default" = block_content,
        "verbatim" = sprintf("\n```\n%s\n```\n", block_content),
        "header2" = paste0("## ", block_content),
        "header3" = paste0("### ", block_content),
        block_content
      )
    },
    rcodeBlock2md = function(block) {
      params <- block$get_params()
      params <- lapply(params, function(l) if (is.character(l)) shQuote(l) else l)
      if (identical(private$report_type, "powerpoint_presentation")) {
        block_content_list <- split_text_block(block$get_content(), 30)
        paste(
          sprintf(
            "\\newpage\n\n---\n\n```{r, echo=FALSE}\ncode_block(\n%s)\n```\n",
            shQuote(block_content_list, type = "cmd")
          ),
          collapse = "\n\n"
        )
      } else {
        sprintf(
          "\\newpage\n\n--- \n\n```{r, %s}\n%s\n```\n",
          paste(names(params), params, sep = "=", collapse = ", "),
          block$get_content()
        )
      }
    },
    pictureBlock2md = function(block) {
      basename_pic <- basename(block$get_content())
      file.copy(block$get_content(), file.path(private$output_dir, basename_pic))
      params <- c(
        `out.width` = "'100%'",
        `out.height` = "'100%'"
      )
      title <- block$get_title()
      if (length(title)) params["fig.cap"] <- shQuote(title)
      sprintf(
        "\n```{r, echo = FALSE, %s}\nknitr::include_graphics(path = '%s')\n```\n",
        paste(names(params), params, sep = "=", collapse = ", "),
        basename_pic
      )
    },
    tableBlock2md = function(block) {
      basename_table <- basename(block$get_content())
      file.copy(block$get_content(), file.path(private$output_dir, basename_table))
      sprintf("```{r echo = FALSE}\nreadRDS('%s')\n```", basename_table)
    },
    htmlBlock2md = function(block) {
      basename <- basename(tempfile(fileext = ".rds"))
      suppressWarnings(saveRDS(block$get_content(), file = file.path(private$output_dir, basename)))
      sprintf("```{r echo = FALSE}\nreadRDS('%s')\n```", basename)
    }
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' @title `ContentBlock`: A building block for report content
#' @docType class
#' @description This class represents a basic content unit in a report,
#' such as text, images, or other multimedia elements.
#' It serves as a foundation for constructing complex report structures.
#'
#' @keywords internal
ContentBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "ContentBlock",
  public = list(
    #' @description Sets content of this `ContentBlock`.
    #'
    #' @param content (`any`) R object
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' ContentBlock <- getFromNamespace("ContentBlock", "teal.reporter")
    #' block <- ContentBlock$new()
    #' block$set_content("Base64 encoded picture")
    #'
    set_content = function(content) {
      private$content <- content
      invisible(self)
    },
    #' @description Retrieves the content assigned to this block.
    #'
    #' @return object stored in a `private$content` field
    #' @examples
    #' ContentBlock <- getFromNamespace("ContentBlock", "teal.reporter")
    #' block <- ContentBlock$new()
    #' block$get_content()
    #'
    get_content = function() {
      private$content
    },
    #' @description Create the `ContentBlock` from a list.
    #'
    #' @param x (`named list`) with two fields `text` and `style`.
    #' Use the `get_available_styles` method to get all possible styles.
    #'
    #' @return `self`, invisibly.
    from_list = function(x) {
      invisible(self)
    },
    #' @description Convert the `ContentBlock` to a list.
    #'
    #' @return `named list` with a text and style.
    to_list = function() {
      list()
    }
  ),
  private = list(
    content = NULL, # this can be any R object
    # @description The copy constructor.
    #
    # @param name (`character(1)`) the name of the field
    # @param value the value assigned to the field
    #
    # @return the value of the copied field
    deep_clone = function(name, value) {
      if (name == "content" && checkmate::test_file_exists(value)) {
        extension <- ""
        split <- strsplit(basename(value), split = "\\.")
        # The below ensures no extension is found for files such as this: .gitignore but is found for files like
        # .gitignore.txt
        if (length(split[[1]]) > 1 && split[[1]][length(split[[1]]) - 1] != "") {
          extension <- split[[1]][length(split[[1]])]
          extension <- paste0(".", extension)
        }
        copied_file <- tempfile(fileext = extension)
        file.copy(value, copied_file, copy.date = TRUE, copy.mode = TRUE)
        copied_file
      } else {
        value
      }
    }
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' Report previewer module
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Module offers functionalities to visualize, manipulate,
#' and interact with report cards that have been added to a report.
#' It includes a previewer interface to see the cards and options to modify the report before downloading.
#'
#' Cards are saved by the `shiny` bookmarking mechanism.
#'
#' For more details see the vignette: `vignette("previewerReporter", "teal.reporter")`.
#'
#' @details `r global_knitr_details()`
#'
#' @name reporter_previewer
#'
#' @param id (`character(1)`) `shiny` module instance id.
#' @param reporter (`Reporter`) instance.
#' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
#'  for customizing the rendering process.
#' @param previewer_buttons (`character`) set of modules to include with `c("download", "load", "reset")` possible
#' values and `"download"` is required.
#' Default `c("download", "load", "reset")`
#' @inheritParams reporter_download_inputs
#'
#' @return `NULL`.
NULL

#' @rdname reporter_previewer
#' @export
reporter_previewer_ui <- function(id) {
  ns <- shiny::NS(id)

  shiny::fluidRow(
    add_previewer_js(ns),
    add_previewer_css(),
    shiny::tagList(
      shiny::tags$div(
        class = "col-md-3",
        shiny::tags$div(class = "well", shiny::uiOutput(ns("encoding")))
      ),
      shiny::tags$div(
        class = "col-md-9",
        shiny::tags$div(
          id = "reporter_previewer",
          shiny::uiOutput(ns("pcards"))
        )
      )
    )
  )
}

#' @rdname reporter_previewer
#' @export
reporter_previewer_srv <- function(id,
                                   reporter,
                                   global_knitr = getOption("teal.reporter.global_knitr"),
                                   rmd_output = c(
                                     "html" = "html_document", "pdf" = "pdf_document",
                                     "powerpoint" = "powerpoint_presentation",
                                     "word" = "word_document"
                                   ),
                                   rmd_yaml_args = list(
                                     author = "NEST", title = "Report",
                                     date = as.character(Sys.Date()), output = "html_document",
                                     toc = FALSE
                                   ),
                                   previewer_buttons = c("download", "load", "reset")) {
  checkmate::assert_subset(previewer_buttons, c("download", "load", "reset"), empty.ok = FALSE)
  checkmate::assert_true("download" %in% previewer_buttons)
  checkmate::assert_class(reporter, "Reporter")
  checkmate::assert_subset(names(global_knitr), names(knitr::opts_chunk$get()))
  checkmate::assert_subset(
    rmd_output,
    c(
      "html_document", "pdf_document",
      "powerpoint_presentation", "word_document"
    ),
    empty.ok = FALSE
  )
  checkmate::assert_list(rmd_yaml_args, names = "named")
  checkmate::assert_names(
    names(rmd_yaml_args),
    subset.of = c("author", "title", "date", "output", "toc"),
    must.include = "output"
  )
  checkmate::assert_true(rmd_yaml_args[["output"]] %in% rmd_output)

  shiny::moduleServer(id, function(input, output, session) {
    shiny::setBookmarkExclude(c(
      "card_remove_id", "card_down_id", "card_up_id", "remove_card_ok", "showrcode", "download_data_prev",
      "load_reporter_previewer", "load_reporter"
    ))

    session$onBookmark(function(state) {
      reporterdir <- file.path(state$dir, "reporter")
      dir.create(reporterdir)
      reporter$to_jsondir(reporterdir)
    })
    session$onRestored(function(state) {
      reporterdir <- file.path(state$dir, "reporter")
      reporter$from_jsondir(reporterdir)
    })

    ns <- session$ns

    reset_report_button_srv("resetButtonPreviewer", reporter)

    output$encoding <- shiny::renderUI({
      reporter$get_reactive_add_card()
      nr_cards <- length(reporter$get_cards())

      previewer_buttons_list <- list(
        download = htmltools::tagAppendAttributes(
          shiny::actionButton(
            ns("download_data_prev"),
            class = "teal-reporter simple_report_button",
            shiny::tags$span("Download Report", shiny::icon("download"))
          ),
          class = if (nr_cards) "" else "disabled"
        ),
        load = shiny::actionButton(
          ns("load_reporter_previewer"),
          class = "teal-reporter simple_report_button",
          `data-val` = shiny::restoreInput(id = ns("load_reporter_previewer"), default = NULL),
          shiny::tags$span(
            "Load Report", shiny::icon("upload")
          )
        ),
        reset = reset_report_button_ui(ns("resetButtonPreviewer"), label = "Reset Report")
      )

      shiny::tags$div(
        id = "previewer_reporter_encoding",
        shiny::tags$h3("Download the Report"),
        shiny::tags$hr(),
        reporter_download_inputs(
          rmd_yaml_args = rmd_yaml_args,
          rmd_output = rmd_output,
          showrcode = any_rcode_block(reporter),
          session = session
        ),
        shiny::tags$div(
          id = "previewer_reporter_buttons",
          class = "previewer_buttons_line",
          lapply(previewer_buttons_list[previewer_buttons], shiny::tags$div)
        )
      )
    })

    output$pcards <- shiny::renderUI({
      reporter$get_reactive_add_card()
      input$card_remove_id
      input$card_down_id
      input$card_up_id

      cards <- reporter$get_cards()

      if (length(cards)) {
        shiny::tags$div(
          class = "panel-group accordion",
          id = "reporter_previewer_panel",
          lapply(seq_along(cards), function(ic) {
            previewer_collapse_item(ic, cards[[ic]]$get_name(), cards[[ic]]$get_content())
          })
        )
      } else {
        shiny::tags$div(
          id = "reporter_previewer_panel_no_cards",
          shiny::tags$p(
            class = "text-danger mt-4",
            shiny::tags$strong("No Cards added")
          )
        )
      }
    })

    shiny::observeEvent(input$load_reporter_previewer, {
      nr_cards <- length(reporter$get_cards())
      shiny::showModal(
        shiny::modalDialog(
          easyClose = TRUE,
          shiny::tags$h3("Load the Reporter"),
          shiny::tags$hr(),
          shiny::fileInput(ns("archiver_zip"), "Choose Reporter File to Load (a zip file)",
            multiple = FALSE,
            accept = c(".zip")
          ),
          footer = shiny::div(
            shiny::tags$button(
              type = "button",
              class = "btn btn-danger",
              `data-dismiss` = "modal",
              `data-bs-dismiss` = "modal",
              NULL,
              "Cancel"
            ),
            shiny::tags$button(
              id = ns("load_reporter"),
              type = "button",
              class = "btn btn-primary action-button",
              `data-val` = shiny::restoreInput(id = ns("load_reporter"), default = NULL),
              NULL,
              "Load"
            )
          )
        )
      )
    })

    shiny::observeEvent(input$load_reporter, {
      switch("JSON",
        JSON = load_json_report(reporter, input$archiver_zip[["datapath"]], input$archiver_zip[["name"]]),
        stop("The provided Reporter file format is not supported")
      )

      shiny::removeModal()
    })

    shiny::observeEvent(input$card_remove_id, {
      shiny::showModal(
        shiny::modalDialog(
          title = "Remove the Report Card",
          shiny::tags$p(
            shiny::HTML(
              sprintf(
                "Do you really want to remove <strong>the card %s</strong> from the Report?",
                input$card_remove_id
              )
            )
          ),
          footer = shiny::tagList(
            shiny::tags$button(
              type = "button",
              class = "btn btn-secondary",
              `data-dismiss` = "modal",
              `data-bs-dismiss` = "modal",
              NULL,
              "Cancel"
            ),
            shiny::actionButton(ns("remove_card_ok"), "OK", class = "btn-danger")
          )
        )
      )
    })

    shiny::observeEvent(input$remove_card_ok, {
      reporter$remove_cards(input$card_remove_id)
      shiny::removeModal()
    })

    shiny::observeEvent(input$card_up_id, {
      if (input$card_up_id > 1) {
        reporter$swap_cards(
          as.integer(input$card_up_id),
          as.integer(input$card_up_id - 1)
        )
      }
    })

    shiny::observeEvent(input$card_down_id, {
      if (input$card_down_id < length(reporter$get_cards())) {
        reporter$swap_cards(
          as.integer(input$card_down_id),
          as.integer(input$card_down_id + 1)
        )
      }
    })

    output$download_data_prev <- shiny::downloadHandler(
      filename = function() {
        paste0(
          "report_",
          if (reporter$get_id() == "") NULL else paste0(reporter$get_id(), "_"),
          format(Sys.time(), "%y%m%d%H%M%S"),
          ".zip"
        )
      },
      content = function(file) {
        shiny::showNotification("Rendering and Downloading the document.")
        shinybusy::block(id = ns("download_data_prev"), text = "", type = "dots")
        input_list <- lapply(names(rmd_yaml_args), function(x) input[[x]])
        names(input_list) <- names(rmd_yaml_args)
        if (is.logical(input$showrcode)) global_knitr[["echo"]] <- input$showrcode
        report_render_and_compress(reporter, input_list, global_knitr, file)
        shinybusy::unblock(id = ns("download_data_prev"))
      },
      contentType = "application/zip"
    )
  })
}

#' @noRd
#' @keywords internal
block_to_html <- function(b) {
  b_content <- b$get_content()
  if (inherits(b, "TextBlock")) {
    switch(b$get_style(),
      header1 = shiny::tags$h1(b_content),
      header2 = shiny::tags$h2(b_content),
      header3 = shiny::tags$h3(b_content),
      header4 = shiny::tags$h4(b_content),
      verbatim = shiny::tags$pre(b_content),
      shiny::tags$pre(b_content)
    )
  } else if (inherits(b, "RcodeBlock")) {
    panel_item("R Code", shiny::tags$pre(b_content))
  } else if (inherits(b, "PictureBlock")) {
    shiny::tags$img(src = knitr::image_uri(b_content))
  } else if (inherits(b, "TableBlock")) {
    b_table <- readRDS(b_content)
    shiny::tags$pre(
      flextable::htmltools_value(b_table)
    )
  } else if (inherits(b, "NewpageBlock")) {
    shiny::tags$br()
  } else if (inherits(b, "HTMLBlock")) {
    b_content
  } else {
    stop("Unknown block class")
  }
}

#' @noRd
#' @keywords internal
add_previewer_css <- function() {
  shiny::tagList(
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/Previewer.css", package = "teal.reporter")))
    ),
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
    )
  )
}

#' @noRd
#' @keywords internal
add_previewer_js <- function(ns) {
  shiny::singleton(
    shiny::tags$head(shiny::tags$script(
      shiny::HTML(sprintf('
          $(document).ready(function(event) {
            $("body").on("click", "span.card_remove_id", function() {
              let val = $(this).data("cardid");
              Shiny.setInputValue("%s", val, {priority: "event"});
            });

            $("body").on("click", "span.card_up_id", function() {
              let val = $(this).data("cardid");
              Shiny.setInputValue("%s", val, {priority: "event"});
            });

             $("body").on("click", "span.card_down_id", function() {
              let val = $(this).data("cardid");
              Shiny.setInputValue("%s", val, {priority: "event"});
             });
          });
         ', ns("card_remove_id"), ns("card_up_id"), ns("card_down_id")))
    ))
  )
}

#' @noRd
#' @keywords internal
nav_previewer_icon <- function(name, icon_name, idx, size = 1L) {
  checkmate::assert_string(name)
  checkmate::assert_string(icon_name)
  checkmate::assert_int(size)

  shiny::tags$span(
    class = paste(name, "icon_previewer"),
    # data field needed to record clicked card on the js side
    `data-cardid` = idx,
    shiny::icon(icon_name, sprintf("fa-%sx", size))
  )
}

#' @noRd
#' @keywords internal
nav_previewer_icons <- function(idx, size = 1L) {
  shiny::tags$span(
    class = "preview_card_control",
    nav_previewer_icon(name = "card_remove_id", icon_name = "xmark", idx = idx, size = size),
    nav_previewer_icon(name = "card_up_id", icon_name = "arrow-up", idx = idx, size = size),
    nav_previewer_icon(name = "card_down_id", icon_name = "arrow-down", idx = idx, size = size)
  )
}

#' @noRd
#' @keywords internal
previewer_collapse_item <- function(idx, card_name, card_blocks) {
  shiny::tags$div(.renderHook = function(x) {
    # get bs version
    version <- get_bs_version()

    if (version == "3") {
      shiny::tags$div(
        id = paste0("panel_card_", idx),
        class = "panel panel-default",
        shiny::tags$div(
          class = "panel-heading overflow-auto",
          shiny::tags$div(
            class = "panel-title",
            shiny::tags$span(
              nav_previewer_icons(idx = idx),
              shiny::tags$a(
                class = "accordion-toggle block py-3 px-4 -my-3 -mx-4",
                `data-toggle` = "collapse",
                `data-parent` = "#reporter_previewer_panel",
                href = paste0("#collapse", idx),
                shiny::tags$h4(paste0("Card ", idx, ": ", card_name), shiny::icon("caret-down"))
              )
            )
          )
        ),
        shiny::tags$div(
          id = paste0("collapse", idx), class = "collapse out",
          shiny::tags$div(
            class = "panel-body",
            shiny::tags$div(
              id = paste0("card", idx),
              lapply(
                card_blocks,
                function(b) {
                  block_to_html(b)
                }
              )
            )
          )
        )
      )
    } else {
      shiny::tags$div(
        id = paste0("panel_card_", idx),
        class = "card",
        shiny::tags$div(
          class = "overflow-auto",
          shiny::tags$div(
            class = "card-header",
            shiny::tags$span(
              nav_previewer_icons(idx = idx),
              shiny::tags$a(
                class = "accordion-toggle block py-3 px-4 -my-3 -mx-4",
                # bs4
                `data-toggle` = "collapse",
                # bs5
                `data-bs-toggle` = "collapse",
                href = paste0("#collapse", idx),
                shiny::tags$h4(
                  paste0("Card ", idx, ": ", card_name),
                  shiny::icon("caret-down")
                )
              )
            )
          )
        ),
        shiny::tags$div(
          id = paste0("collapse", idx),
          class = "collapse out",
          # bs4
          `data-parent` = "#reporter_previewer_panel",
          # bs5
          `data-bs-parent` = "#reporter_previewer_panel",
          shiny::tags$div(
            class = "card-body",
            shiny::tags$div(
              id = paste0("card", idx),
              lapply(
                card_blocks,
                function(b) {
                  block_to_html(b)
                }
              )
            )
          )
        )
      )
    }
  })
}

#' Reset report button module
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Provides a button that triggers resetting the report content.
#'
#' For more information, refer to the vignette: `vignette("simpleReporter", "teal.reporter")`.
#'
#' @name reset_report_button
#'
#' @param id (`character(1)`) `shiny` module instance id.
#' @param label (`character(1)`) label before the icon.
#' By default `NULL`.
#' @param reporter (`Reporter`) instance.
#' @return `NULL`.
NULL

#' @rdname reset_report_button
#' @export
reset_report_button_ui <- function(id, label = NULL) {
  checkmate::assert_string(label, null.ok = TRUE)

  ns <- shiny::NS(id)
  shiny::tagList(
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
    ),
    shiny::actionButton(
      ns("reset_reporter"),
      class = "teal-reporter simple_report_button clear-report btn-warning",
      title = "Reset",
      `data-val` = shiny::restoreInput(id = ns("reset_reporter"), default = NULL),
      shiny::tags$span(
        if (!is.null(label)) label,
        shiny::icon("xmark")
      )
    )
  )
}

#' @rdname reset_report_button
#' @export
reset_report_button_srv <- function(id, reporter) {
  checkmate::assert_class(reporter, "Reporter")

  shiny::moduleServer(id, function(input, output, session) {
    shiny::setBookmarkExclude(c("reset_reporter"))

    ns <- session$ns
    nr_cards <- length(reporter$get_cards())


    shiny::observeEvent(input$reset_reporter, {
      shiny::tags$div(
        class = "teal-widgets reporter-modal",
        shiny::showModal(
          shiny::modalDialog(
            shiny::tags$h3("Reset the Report"),
            shiny::tags$hr(),
            shiny::tags$strong(
              shiny::tags$p(
                "Are you sure you want to reset the report? (This will remove ALL previously added cards)."
              )
            ),
            footer = shiny::tagList(
              shiny::tags$button(
                type = "button",
                class = "btn btn-secondary",
                `data-dismiss` = "modal",
                `data-bs-dismiss` = "modal",
                NULL,
                "Cancel"
              ),
              shiny::actionButton(ns("reset_reporter_ok"), "Reset", class = "btn-danger")
            )
          )
        )
      )
    })

    shiny::observeEvent(input$reset_reporter_ok, {
      reporter$reset()
      shiny::removeModal()
    })
  })
}

#' @title `RcodeBlock`
#' @docType class
#' @description
#' Specialized `ContentBlock` designed to embed `R` code in reports.
#'
#' @keywords internal
RcodeBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "RcodeBlock",
  inherit = ContentBlock,
  public = list(
    #' @description Initialize a `RcodeBlock` object.
    #'
    #' @details Returns a `RcodeBlock` object with no content and no parameters.
    #'
    #' @param content (`character(1)` or `character(0)`) a string assigned to this `RcodeBlock`
    #' @param ... any `rmarkdown` `R` chunk parameter and it value.
    #'
    #' @return Object of class `RcodeBlock`, invisibly.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #'
    initialize = function(content = character(0), ...) {
      checkmate::assert_class(content, "character")
      super$set_content(content)
      self$set_params(list(...))
      invisible(self)
    },
    #' @description Sets content of this `RcodeBlock`.
    #'
    #' @param content (`any`) R object
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #' block$set_content("a <- 1")
    #'
    set_content = function(content) {
      checkmate::assert_string(content)
      super$set_content(content)
    },
    #' @description Sets the parameters of this `RcodeBlock`.
    #'
    #' @details Configures `rmarkdown` chunk parameters for the `R` code block,
    #' influencing its rendering and execution behavior.
    #'
    #' @param params (`list`) any `rmarkdown` R chunk parameter and its value.
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #' block$set_params(list(echo = TRUE))
    #'
    set_params = function(params) {
      checkmate::assert_list(params, names = "named")
      checkmate::assert_subset(names(params), self$get_available_params())
      private$params <- params
      invisible(self)
    },
    #' @description Get the parameters of this `RcodeBlock`.
    #'
    #' @return `character` the parameters of this `RcodeBlock`.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #' block$get_params()
    #'
    get_params = function() {
      private$params
    },
    #' @description Get available array of parameters available to this `RcodeBlock`.
    #'
    #' @return A `character` array of parameters.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #' block$get_available_params()
    #'
    get_available_params = function() {
      names(knitr::opts_chunk$get())
    },
    #' @description Create the `RcodeBlock` from a list.
    #'
    #' @param x (`named list`) with two fields `text` and `params`.
    #' Use the `get_available_params` method to get all possible parameters.
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #' block$from_list(list(text = "sth", params = list()))
    #'
    from_list = function(x) {
      checkmate::assert_list(x)
      checkmate::assert_names(names(x), must.include = c("text", "params"))
      self$set_content(x$text)
      self$set_params(x$params)
      invisible(self)
    },
    #' @description Convert the `RcodeBlock` to a list.
    #'
    #' @return `named list` with a text and `params`.
    #' @examples
    #' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
    #' block <- RcodeBlock$new()
    #' block$to_list()
    #'
    to_list = function() {
      list(text = self$get_content(), params = self$get_params())
    }
  ),
  private = list(
    content = character(0),
    params = list()
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' @title `Reporter`: An `R6` class for managing report cards
#' @docType class
#' @description `r lifecycle::badge("experimental")`
#'
#' This `R6` class is designed to store and manage report cards,
#' facilitating the creation, manipulation, and serialization of report-related data.
#'
#' @export
#'
Reporter <- R6::R6Class( # nolint: object_name_linter.
  classname = "Reporter",
  public = list(
    #' @description Initialize a `Reporter` object.
    #'
    #' @return Object of class `Reporter`, invisibly.
    #' @examples
    #' reporter <- Reporter$new()
    #'
    initialize = function() {
      private$cards <- list()
      private$reactive_add_card <- shiny::reactiveVal(0)
      invisible(self)
    },
    #' @description Append one or more `ReportCard` objects to the `Reporter`.
    #'
    #' @param cards (`ReportCard`) or a list of such objects
    #' @return `self`, invisibly.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #' library(rtables)
    #'
    #' card1 <- ReportCard$new()
    #'
    #' card1$append_text("Header 2 text", "header2")
    #' card1$append_text("A paragraph of default text")
    #' card1$append_plot(
    #'   ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )
    #'
    #' card2 <- ReportCard$new()
    #'
    #' card2$append_text("Header 2 text", "header2")
    #' card2$append_text("A paragraph of default text")
    #' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
    #' table_res2 <- build_table(lyt, airquality)
    #' card2$append_table(table_res2)
    #'
    #' reporter <- Reporter$new()
    #' reporter$append_cards(list(card1, card2))
    append_cards = function(cards) {
      checkmate::assert_list(cards, "ReportCard")
      private$cards <- append(private$cards, cards)
      private$reactive_add_card(length(private$cards))
      invisible(self)
    },
    #' @description Retrieves all `ReportCard` objects contained in the `Reporter`.
    #'
    #' @return A (`list`) of [`ReportCard`] objects.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #' library(rtables)
    #'
    #' card1 <- ReportCard$new()
    #'
    #' card1$append_text("Header 2 text", "header2")
    #' card1$append_text("A paragraph of default text")
    #' card1$append_plot(
    #'  ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )
    #'
    #' card2 <- ReportCard$new()
    #'
    #' card2$append_text("Header 2 text", "header2")
    #' card2$append_text("A paragraph of default text")
    #' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
    #' table_res2 <- build_table(lyt, airquality)
    #' card2$append_table(table_res2)
    #'
    #' reporter <- Reporter$new()
    #' reporter$append_cards(list(card1, card2))
    #' reporter$get_cards()
    get_cards = function() {
      private$cards
    },
    #' @description Compiles and returns all content blocks from the [`ReportCard`] in the `Reporter`.
    #'
    #' @param sep An optional separator to insert between each content block.
    #' Default is a `NewpageBlock$new()`object.
    #' @return `list()` list of `TableBlock`, `TextBlock`, `PictureBlock` and `NewpageBlock`.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #' library(rtables)
    #'
    #' card1 <- ReportCard$new()
    #'
    #' card1$append_text("Header 2 text", "header2")
    #' card1$append_text("A paragraph of default text")
    #' card1$append_plot(
    #'  ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )
    #'
    #' card2 <- ReportCard$new()
    #'
    #' card2$append_text("Header 2 text", "header2")
    #' card2$append_text("A paragraph of default text")
    #' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
    #' table_res2 <- build_table(lyt, airquality)
    #' card2$append_table(table_res2)
    #'
    #' reporter <- Reporter$new()
    #' reporter$append_cards(list(card1, card2))
    #' reporter$get_blocks()
    #'
    get_blocks = function(sep = NewpageBlock$new()) {
      blocks <- list()
      if (length(private$cards) > 0) {
        for (card_idx in head(seq_along(private$cards), -1)) {
          blocks <- append(blocks, append(private$cards[[card_idx]]$get_content(), sep))
        }
        blocks <- append(blocks, private$cards[[length(private$cards)]]$get_content())
      }
      blocks
    },
    #' @description Resets the `Reporter`, removing all [`ReportCard`] objects and metadata.
    #'
    #' @return `self`, invisibly.
    #'
    reset = function() {
      private$cards <- list()
      private$metadata <- list()
      private$reactive_add_card(0)
      invisible(self)
    },
    #' @description Removes specific `ReportCard` objects from the `Reporter` by their indices.
    #'
    #' @param ids (`integer(id)`) the indexes of cards
    #' @return `self`, invisibly.
    remove_cards = function(ids = NULL) {
      checkmate::assert(
        checkmate::check_null(ids),
        checkmate::check_integer(ids, min.len = 1, max.len = length(private$cards))
      )
      if (!is.null(ids)) {
        private$cards <- private$cards[-ids]
      }
      private$reactive_add_card(length(private$cards))
      invisible(self)
    },
    #' @description Swaps the positions of two `ReportCard` objects within the `Reporter`.
    #'
    #' @param start (`integer`) the index of the first card
    #' @param end (`integer`) the index of the second card
    #' @return `self`, invisibly.
    swap_cards = function(start, end) {
      checkmate::assert(
        checkmate::check_integer(start,
          min.len = 1, max.len = 1, lower = 1, upper = length(private$cards)
        ),
        checkmate::check_integer(end,
          min.len = 1, max.len = 1, lower = 1, upper = length(private$cards)
        ),
        combine = "and"
      )
      start_val <- private$cards[[start]]$clone()
      end_val <- private$cards[[end]]$clone()
      private$cards[[start]] <- end_val
      private$cards[[end]] <- start_val
      invisible(self)
    },
    #' @description Gets the current value of the reactive variable for adding cards.
    #'
    #' @return `reactive_add_card` current `numeric` value of the reactive variable.
    #' @note The function has to be used in the shiny reactive context.
    #' @examples
    #' library(shiny)
    #'
    #' isolate(Reporter$new()$get_reactive_add_card())
    get_reactive_add_card = function() {
      private$reactive_add_card()
    },
    #' @description Get the metadata associated with this `Reporter`.
    #'
    #' @return `named list` of metadata to be appended.
    #' @examples
    #' reporter <- Reporter$new()$append_metadata(list(sth = "sth"))
    #' reporter$get_metadata()
    #'
    get_metadata = function() {
      private$metadata
    },
    #' @description Appends metadata to this `Reporter`.
    #'
    #' @param meta (`named list`) of metadata to be appended.
    #' @return `self`, invisibly.
    #' @examples
    #' reporter <- Reporter$new()$append_metadata(list(sth = "sth"))
    #' reporter$get_metadata()
    #'
    append_metadata = function(meta) {
      checkmate::assert_list(meta, names = "unique")
      checkmate::assert_true(length(meta) == 0 || all(!names(meta) %in% names(private$metadata)))
      private$metadata <- append(private$metadata, meta)
      invisible(self)
    },
    #' @description
    #' Reinitializes a `Reporter` instance by copying the report cards and metadata from another `Reporter`.
    #' @param reporter (`Reporter`) instance to copy from.
    #' @return invisibly self
    #' @examples
    #' reporter <- Reporter$new()
    #' reporter$from_reporter(reporter)
    from_reporter = function(reporter) {
      checkmate::assert_class(reporter, "Reporter")
      self$reset()
      self$append_cards(reporter$get_cards())
      self$append_metadata(reporter$get_metadata())
      invisible(self)
    },
    #' @description Convert a `Reporter` to a list and transfer any associated files to specified directory.
    #' @param output_dir (`character(1)`) a path to the directory where files will be copied.
    #' @return `named list` representing the `Reporter` instance, including version information,
    #'  metadata, and report cards.
    #' @examples
    #' reporter <- Reporter$new()
    #' tmp_dir <- file.path(tempdir(), "testdir")
    #' dir.create(tmp_dir)
    #' reporter$to_list(tmp_dir)
    to_list = function(output_dir) {
      checkmate::assert_directory_exists(output_dir)
      rlist <- list(name = "teal Reporter", version = "1", id = self$get_id(), cards = list())
      rlist[["metadata"]] <- self$get_metadata()
      for (card in self$get_cards()) {
        # we want to have list names being a class names to indicate the class for $from_list
        card_class <- class(card)[1]
        u_card <- list()
        u_card[[card_class]] <- card$to_list(output_dir)
        rlist$cards <- c(rlist$cards, u_card)
      }
      rlist
    },
    #' @description Reinitializes a `Reporter` from a list representation and associated files in a specified directory.
    #' @param rlist (`named list`) representing a `Reporter` instance.
    #' @param output_dir (`character(1)`) a path to the directory from which files will be copied.
    #' @return `self`, invisibly.
    #' @note if Report has an id when converting to JSON then It will be compared to the currently available one.
    #' @examples
    #' reporter <- Reporter$new()
    #' tmp_dir <- file.path(tempdir(), "testdir")
    #' unlink(tmp_dir, recursive = TRUE)
    #' dir.create(tmp_dir)
    #' reporter$from_list(reporter$to_list(tmp_dir), tmp_dir)
    from_list = function(rlist, output_dir) {
      id <- self$get_id()
      checkmate::assert_list(rlist)
      checkmate::assert_directory_exists(output_dir)
      stopifnot("Report JSON has to have name slot equal to teal Reporter" = rlist$name == "teal Reporter")
      stopifnot("Loaded Report id has to match the current instance one" = rlist$id == id)
      if (rlist$version %in% c("1")) {
        new_cards <- list()
        cards_names <- names(rlist$cards)
        cards_names <- gsub("[.][0-9]*$", "", cards_names)
        for (iter_c in seq_along(rlist$cards)) {
          card_class <- cards_names[iter_c]
          card <- rlist$cards[[iter_c]]
          new_card <- eval(str2lang(card_class))$new()
          new_card$from_list(card, output_dir)
          new_cards <- c(new_cards, new_card)
        }
      } else {
        stop(
          sprintf(
            "The provided %s reporter version is not supported.",
            rlist$version
          )
        )
      }
      self$reset()
      self$set_id(rlist$id)
      self$append_cards(new_cards)
      self$append_metadata(rlist$metadata)
      invisible(self)
    },
    #' @description Serializes the `Reporter` to a `JSON` file and copies any associated files to a specified directory.
    #' @param output_dir (`character(1)`) a path to the directory where files will be copied, `JSON` and statics.
    #' @return `output_dir` argument.
    #' @examples
    #' reporter <- Reporter$new()
    #' tmp_dir <- file.path(tempdir(), "jsondir")
    #' dir.create(tmp_dir)
    #' reporter$to_jsondir(tmp_dir)
    to_jsondir = function(output_dir) {
      checkmate::assert_directory_exists(output_dir)
      json <- self$to_list(output_dir)
      cat(
        jsonlite::toJSON(json, auto_unbox = TRUE, force = TRUE),
        file = file.path(output_dir, "Report.json")
      )
      output_dir
    },
    #' @description Reinitializes a `Reporter` from a `JSON ` file and files in a specified directory.
    #' @param output_dir (`character(1)`) a path to the directory with files, `JSON` and statics.
    #' @return `self`, invisibly.
    #' @note if Report has an id when converting to JSON then It will be compared to the currently available one.
    #' @examples
    #' reporter <- Reporter$new()
    #' tmp_dir <- file.path(tempdir(), "jsondir")
    #' dir.create(tmp_dir)
    #' unlink(list.files(tmp_dir, recursive = TRUE))
    #' reporter$to_jsondir(tmp_dir)
    #' reporter$from_jsondir(tmp_dir)
    from_jsondir = function(output_dir) {
      checkmate::assert_directory_exists(output_dir)
      dir_files <- list.files(output_dir)
      stopifnot("There has to be at least one file in the loaded directory" = length(dir_files) > 0)
      stopifnot("Report.json file has to be in the loaded directory" = "Report.json" %in% basename(dir_files))
      json <- jsonlite::read_json(file.path(output_dir, "Report.json"))
      self$reset()
      self$from_list(json, output_dir)
      invisible(self)
    },
    #' @description Set the `Reporter` id
    #' Optionally add id to a `Reporter` which will be compared when it is rebuilt from a list.
    #' The id is added to the downloaded file name.
    #' @param id (`character(1)`) a Report id.
    #' @return `self`, invisibly.
    set_id = function(id) {
      private$id <- id
      invisible(self)
    },
    #' @description Get the `Reporter` id
    #' @return `character(1)` the `Reporter` id.
    get_id = function() {
      private$id
    }
  ),
  private = list(
    id = "",
    cards = list(),
    metadata = list(),
    reactive_add_card = NULL,
    # @description The copy constructor.
    #
    # @param name the name of the field
    # @param value the value of the field
    # @return the new value of the field
    #
    deep_clone = function(name, value) {
      if (name == "cards") {
        lapply(value, function(card) card$clone(deep = TRUE))
      } else {
        value
      }
    }
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' Mark strings for quotation in `yaml` serialization
#'
#' This function is designed for use with the `yaml` package to explicitly,
#' It adds an attribute to character strings, indicating that they should be serialized with double quotes.
#'
#' @param x (`character`)
#' @keywords internal
#' @examples
#' library(yaml)
#' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
#' yaml <- list(
#'   author = yaml_quoted("NEST"),
#'   title = yaml_quoted("Report"),
#'   date = yaml_quoted("07/04/2019"),
#'   output = list(pdf_document = list(keep_tex = TRUE))
#' )
#' as.yaml(yaml)
yaml_quoted <- function(x) {
  attr(x, "quoted") <- TRUE
  x
}

#' Create `markdown` header from `yaml` string
#'
#' This function wraps a `yaml`-formatted string in Markdown header delimiters.
#'
#' @param x (`character`) `yaml` formatted string.
#' @keywords internal
#' @examples
#' library(yaml)
#' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
#' yaml <- list(
#'   author = yaml_quoted("NEST"),
#'   title = yaml_quoted("Report"),
#'   date = yaml_quoted("07/04/2019"),
#'   output = list(pdf_document = list(keep_tex = TRUE))
#' )
#' md_header <- getFromNamespace("md_header", "teal.reporter")
#' md_header(as.yaml(yaml))
md_header <- function(x) {
  paste0("---\n", x, "---\n")
}

#' Convert `yaml` representation of a boolean strings to logical Values
#'
#' Converts a single `character` string representing a `yaml` boolean value into a logical value in `R`.
#'
#' @param input (`character(1)`)
#' @param name (`charcter(1)`)
#' @param pos_logi (`character`) vector of `yaml` values which should be treated as `TRUE`.
#' @param neg_logi (`character`) vector of `yaml` values which should be treated as `FALSE`.
#' @param silent (`logical(1)`) if to suppress the messages and warnings.
#' @return `input` argument or the appropriate `logical` value.
#' @keywords internal
#' @examples
#' conv_str_logi <- getFromNamespace("conv_str_logi", "teal.reporter")
#' conv_str_logi("TRUE")
#' conv_str_logi("True")
#'
#' conv_str_logi("off")
#' conv_str_logi("n")
#'
#' conv_str_logi("sth")
conv_str_logi <- function(input,
                          name = "",
                          pos_logi = c("TRUE", "true", "True", "yes", "y", "Y", "on"),
                          neg_logi = c("FALSE", "false", "False", "no", "n", "N", "off"),
                          silent = TRUE) {
  checkmate::assert_string(input)
  checkmate::assert_string(name)
  checkmate::assert_character(pos_logi)
  checkmate::assert_character(neg_logi)
  checkmate::assert_flag(silent)

  all_logi <- c(pos_logi, neg_logi)
  if (input %in% all_logi) {
    if (isFALSE(silent)) {
      message(sprintf("The '%s' value should be a logical, so it is automatically converted.", input))
    }
    input %in% pos_logi
  } else {
    input
  }
}

#' Get document output types from the `rmarkdown` package
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Retrieves vector of available document output types from the `rmarkdown` package,
#' such as `pdf_document`, `html_document`, etc.
#'
#' @return `character` vector.
#' @export
#' @examples
#' rmd_outputs()
rmd_outputs <- function() {
  rmarkdown_namespace <- asNamespace("rmarkdown")
  ls(rmarkdown_namespace)[grep("_document|_presentation", ls(rmarkdown_namespace))]
}

#' Get document output arguments from the `rmarkdown` package
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Retrieves the arguments for a specified document output type from the `rmarkdown` package.
#'
#' @param output_name (`character`) `rmarkdown` output name.
#' @param default_values (`logical(1)`) if to return a default values for each argument.
#' @export
#' @examples
#' rmd_output_arguments("pdf_document")
#' rmd_output_arguments("pdf_document", TRUE)
rmd_output_arguments <- function(output_name, default_values = FALSE) {
  checkmate::assert_string(output_name)
  checkmate::assert_subset(output_name, rmd_outputs())

  rmarkdown_namespace <- asNamespace("rmarkdown")
  if (default_values) {
    formals(rmarkdown_namespace[[output_name]])
  } else {
    names(formals(rmarkdown_namespace[[output_name]]))
  }
}

#' Parse a named list to `yaml` header for an `Rmd` file
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Converts a named list into a `yaml` header for `Rmd`, handling output types and arguments
#' as defined in the `rmarkdown` package. This function simplifies the process of generating `yaml` headers.
#'
#' @details
#' This function processes a non-nested (flat) named list into a `yaml` header for an `Rmd` document.
#' It supports all standard `Rmd` `yaml` header fields, including `author`, `date`, `title`, `subtitle`,
#'  `abstract`, `keywords`, `subject`, `description`, `category`, and `lang`.
#' Additionally,  it handles `output` field types and arguments as defined in the `rmarkdown` package.
#'
#' @note Only non-nested lists are automatically parsed.
#' Nested lists require direct processing with `yaml::as.yaml`.
#'
#' @param input_list (`named list`) non nested with slots names and their values compatible with `Rmd` `yaml` header.
#' @param as_header (`logical(1)`) optionally wrap with result with the internal `md_header()`, default `TRUE`.
#' @param convert_logi (`logical(1)`) convert a character values to logical,
#'  if they are recognized as quoted `yaml` logical values , default `TRUE`.
#' @param multi_output (`logical(1)`) multi `output` slots in the `input` argument, default `FALSE`.
#' @param silent (`logical(1)`) suppress messages and warnings, default `FALSE`.
#' @return `character` with `rmd_yaml_header` class,
#' result of [`yaml::as.yaml`], optionally wrapped with internal `md_header()`.
#' @export
#' @examples
#' # nested so using yaml::as.yaml directly
#' as_yaml_auto(
#'   list(author = "", output = list(pdf_document = list(toc = TRUE)))
#' )
#'
#' # auto parsing for a flat list, like shiny input
#' input <- list(author = "", output = "pdf_document", toc = TRUE, keep_tex = TRUE)
#' as_yaml_auto(input)
#'
#' as_yaml_auto(list(author = "", output = "pdf_document", toc = TRUE, keep_tex = "TRUE"))
#'
#' as_yaml_auto(list(
#'   author = "", output = "pdf_document", toc = TRUE, keep_tex = TRUE,
#'   wrong = 2
#' ))
#'
#' as_yaml_auto(list(author = "", output = "pdf_document", toc = TRUE, keep_tex = 2),
#'   silent = TRUE
#' )
#'
#' input <- list(author = "", output = "pdf_document", toc = TRUE, keep_tex = "True")
#' as_yaml_auto(input)
#' as_yaml_auto(input, convert_logi = TRUE, silent = TRUE)
#' as_yaml_auto(input, silent = TRUE)
#' as_yaml_auto(input, convert_logi = FALSE, silent = TRUE)
#'
#' as_yaml_auto(
#'   list(
#'     author = "", output = "pdf_document",
#'     output = "html_document", toc = TRUE, keep_tex = TRUE
#'   ),
#'   multi_output = TRUE
#' )
#' as_yaml_auto(
#'   list(
#'     author = "", output = "pdf_document",
#'     output = "html_document", toc = "True", keep_tex = TRUE
#'   ),
#'   multi_output = TRUE
#' )
as_yaml_auto <- function(input_list,
                         as_header = TRUE,
                         convert_logi = TRUE,
                         multi_output = FALSE,
                         silent = FALSE) {
  checkmate::assert_logical(as_header)
  checkmate::assert_logical(convert_logi)
  checkmate::assert_logical(silent)
  checkmate::assert_logical(multi_output)

  if (multi_output) {
    checkmate::assert_list(input_list, names = "named")
  } else {
    checkmate::assert_list(input_list, names = "unique")
  }

  is_nested <- function(x) any(unlist(lapply(x, is.list)))
  if (is_nested(input_list)) {
    result <- input_list
  } else {
    result <- list()
    input_nams <- names(input_list)

    # top fields
    top_fields <- c(
      "author", "date", "title", "subtitle", "abstract",
      "keywords", "subject", "description", "category", "lang"
    )
    for (itop in top_fields) {
      if (itop %in% input_nams) {
        result[[itop]] <- switch(itop,
          date = as.character(input_list[[itop]]),
          input_list[[itop]]
        )
      }
    }

    # output field
    doc_types <- unlist(input_list[input_nams == "output"])
    if (length(doc_types)) {
      for (dtype in doc_types) {
        doc_type_args <- rmd_output_arguments(dtype, TRUE)
        doc_type_args_nams <- names(doc_type_args)
        any_output_arg <- any(input_nams %in% doc_type_args_nams)

        not_found_args <- setdiff(input_nams, c(doc_type_args_nams, top_fields, "output"))
        if (isFALSE(silent) && length(not_found_args) > 0 && isFALSE(multi_output)) {
          warning(sprintf("Not recognized and skipped arguments: %s", paste(not_found_args, collapse = ", ")))
        }

        if (any_output_arg) {
          doc_list <- list()
          doc_list[[dtype]] <- list()
          for (e in intersect(input_nams, doc_type_args_nams)) {
            if (is.logical(doc_type_args[[e]]) && is.character(input_list[[e]])) {
              pos_logi <- c("TRUE", "true", "True", "yes", "y", "Y", "on")
              neg_logi <- c("FALSE", "false", "False", "no", "n", "N", "off")
              all_logi <- c(pos_logi, neg_logi)
              if (input_list[[e]] %in% all_logi && convert_logi) {
                input_list[[e]] <- conv_str_logi(input_list[[e]], e,
                  pos_logi = pos_logi,
                  neg_logi = neg_logi, silent = silent
                )
              }
            }

            doc_list[[dtype]][[e]] <- input_list[[e]]
          }
          result[["output"]] <- append(result[["output"]], doc_list)
        } else {
          result[["output"]] <- append(result[["output"]], input_list[["output"]])
        }
      }
    }
  }

  result <- yaml::as.yaml(result)
  if (as_header) {
    result <- md_header(result)
  }
  structure(result, class = "rmd_yaml_header")
}

#' Print method for the `yaml_header` class
#'
#' `r lifecycle::badge("experimental")`
#'
#' @param x (`rmd_yaml_header`) class object.
#' @param ... optional text.
#' @return `NULL`.
#' @exportS3Method
#' @examples
#' input <- list(author = "", output = "pdf_document", toc = TRUE, keep_tex = TRUE)
#' out <- as_yaml_auto(input)
#' out
#' print(out)
print.rmd_yaml_header <- function(x, ...) {
  cat(x, ...)
}

#' Extract field from `yaml` text
#'
#' Parses `yaml` text, extracting the specified field. Returns list names if it's a list;
#' otherwise, the field itself.
#'
#' @param yaml_text (`rmd_yaml_header` or `character`) vector containing the `yaml` text.
#' @param field_name (`character`) the name of the field to extract.
#'
#' @return If the field is a list, it returns the names of elements in the list; otherwise,
#' it returns the extracted field.
#'
#' @keywords internal
get_yaml_field <- function(yaml_text, field_name) {
  checkmate::assert_multi_class(yaml_text, c("rmd_yaml_header", "character"))
  checkmate::assert_string(field_name)

  yaml_obj <- yaml::yaml.load(yaml_text)

  result <- yaml_obj[[field_name]]
  if (is.list(result)) {
    result <- names(result)
  }
  result
}

#' @title `ReportCard`: An `R6` class for building report elements
#' @docType class
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' This `R6` class that supports creating a report card containing text, plot, table and
#' metadata blocks that can be appended and rendered to form a report output from a `shiny` app.
#'
#' For more information about the various blocks, refer to the vignette:
#' `vignette("teal-reporter-blocks-overview", "teal.reporter")`.
#'
#' @export
#'
ReportCard <- R6::R6Class( # nolint: object_name_linter.
  classname = "ReportCard",
  public = list(
    #' @description Initialize a `ReportCard` object.
    #'
    #' @return Object of class `ReportCard`, invisibly.
    #' @examples
    #' card <- ReportCard$new()
    #'
    initialize = function() {
      private$content <- list()
      private$metadata <- list()
      invisible(self)
    },
    #' @description Appends a table to this `ReportCard`.
    #'
    #' @param table A (`data.frame` or `rtables` or `TableTree` or `ElementaryTable` or `listing_df`)
    #' that can be coerced into a table.
    #' @return `self`, invisibly.
    #' @examples
    #' card <- ReportCard$new()$append_table(iris)
    #'
    append_table = function(table) {
      self$append_content(TableBlock$new(table))
      invisible(self)
    },
    #' @description Appends a html content to this `ReportCard`.
    #'
    #' @param content An object that can be rendered as a HTML content.
    #' @return `self`, invisibly.
    #' @examples
    #' card <- ReportCard$new()$append_html(shiny::div("HTML Content"))
    #'
    append_html = function(content) {
      self$append_content(HTMLBlock$new(content))
      invisible(self)
    },
    #' @description Appends a plot to this `ReportCard`.
    #'
    #' @param plot (`ggplot` or `grob` or `trellis`) plot object.
    #' @param dim (`numeric(2)`) width and height in pixels.
    #' @return `self`, invisibly.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #'
    #' card <- ReportCard$new()$append_plot(
    #'   ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )
    #'
    append_plot = function(plot, dim = NULL) {
      pb <- PictureBlock$new()
      if (!is.null(dim) && length(dim) == 2) {
        pb$set_dim(dim)
      }
      pb$set_content(plot)
      self$append_content(pb)
      invisible(self)
    },
    #' @description Appends a text paragraph to this `ReportCard`.
    #'
    #' @param text (`character`) The text content to add.
    #' @param style (`character(1)`) the style of the paragraph. One of: `r TextBlock$new()$get_available_styles()`.
    #' @return `self`, invisibly.
    #' @examples
    #' card <- ReportCard$new()$append_text("A paragraph of default text")
    #'
    append_text = function(text, style = TextBlock$new()$get_available_styles()[1]) {
      self$append_content(TextBlock$new(text, style))
      invisible(self)
    },
    #' @description Appends an `R` code chunk to `ReportCard`.
    #'
    #' @param text (`character`) The `R` code to include.
    #' @param ... Additional  `rmarkdown` parameters for formatting the `R` code chunk.
    #' @return `self`, invisibly.
    #' @examples
    #' card <- ReportCard$new()$append_rcode("2+2", echo = FALSE)
    #'
    append_rcode = function(text, ...) {
      self$append_content(RcodeBlock$new(text, ...))
      invisible(self)
    },
    #' @description Appends a generic `ContentBlock` to this `ReportCard`.
    #'
    #' @param content (`ContentBlock`) object.
    #' @return `self`, invisibly.
    #' @examples
    #' NewpageBlock <- getFromNamespace("NewpageBlock", "teal.reporter")
    #' card <- ReportCard$new()$append_content(NewpageBlock$new())
    #'
    append_content = function(content) {
      checkmate::assert_class(content, "ContentBlock")
      private$content <- append(private$content, content)
      invisible(self)
    },
    #' @description Get all content blocks from this `ReportCard`.
    #'
    #' @return `list()` list of `TableBlock`, `TextBlock` and `PictureBlock`.
    #' @examples
    #' card <- ReportCard$new()$append_text("Some text")$append_metadata("rc", "a <- 2 + 2")
    #'
    #' card$get_content()
    #'
    #'
    get_content = function() {
      private$content
    },
    #' @description Clears all content and metadata from `ReportCard`.
    #'
    #' @return `self`, invisibly.
    #'
    reset = function() {
      private$content <- list()
      private$metadata <- list()
      invisible(self)
    },
    #' @description Get the metadata associated with `ReportCard`.
    #'
    #' @return `named list` list of elements.
    #' @examples
    #' card <- ReportCard$new()$append_text("Some text")$append_metadata("rc", "a <- 2 + 2")
    #'
    #' card$get_metadata()
    #'
    get_metadata = function() {
      private$metadata
    },
    #' @description Appends metadata to this `ReportCard`.
    #'
    #' @param key (`character(1)`) string specifying the metadata key.
    #' @param value value associated with the metadata key.
    #' @return `self`, invisibly.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #'
    #' card <- ReportCard$new()$append_text("Some text")$append_plot(
    #'   ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )$append_text("Some text")$append_metadata(key = "lm",
    #'                   value = lm(Ozone ~ Solar.R, airquality))
    #' card$get_content()
    #' card$get_metadata()
    #'
    append_metadata = function(key, value) {
      checkmate::assert_character(key, min.len = 0, max.len = 1)
      checkmate::assert_false(key %in% names(private$metadata))
      meta_list <- list()
      meta_list[[key]] <- value
      private$metadata <- append(private$metadata, meta_list)
      invisible(self)
    },
    #' @description Get the name of the `ReportCard`.
    #'
    #' @return `character` a card name.
    #' @examples
    #' ReportCard$new()$set_name("NAME")$get_name()
    get_name = function() {
      private$name
    },
    #' @description Set the name of the `ReportCard`.
    #'
    #' @param name (`character(1)`) a card name.
    #' @return `self`, invisibly.
    #' @examples
    #' ReportCard$new()$set_name("NAME")$get_name()
    set_name = function(name) {
      checkmate::assert_character(name)
      private$name <- name
      invisible(self)
    },
    #' @description Convert the `ReportCard` to a list, including content and metadata.
    #' @param output_dir (`character`) with a path to the directory where files will be copied.
    #' @return (`named list`) a `ReportCard` representation.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #'
    #' card <- ReportCard$new()$append_text("Some text")$append_plot(
    #'   ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )$append_text("Some text")$append_metadata(key = "lm",
    #'                   value = lm(Ozone ~ Solar.R, airquality))
    #' card$get_content()
    #'
    #' card$to_list(tempdir())
    #'
    to_list = function(output_dir) {
      new_blocks <- list()
      for (block in self$get_content()) {
        block_class <- class(block)[1]
        formal_args <- formalArgs(block$to_list)
        cblock <- if ("output_dir" %in% formal_args) {
          block$to_list(output_dir)
        } else {
          block$to_list()
        }
        new_block <- list()
        new_block[[block_class]] <- cblock
        new_blocks <- c(new_blocks, new_block)
      }
      new_card <- list()
      new_card[["blocks"]] <- new_blocks
      new_card[["metadata"]] <- self$get_metadata()
      new_card[["name"]] <- self$get_name()
      new_card
    },
    #' @description Reconstructs the `ReportCard` from a list representation.
    #' @param card (`named list`) a `ReportCard` representation.
    #' @param output_dir (`character`) with a path to the directory where a file will be copied.
    #' @return `self`, invisibly.
    #' @examplesIf require("ggplot2")
    #' library(ggplot2)
    #'
    #' card <- ReportCard$new()$append_text("Some text")$append_plot(
    #'   ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
    #' )$append_text("Some text")$append_metadata(key = "lm",
    #'                   value = lm(Ozone ~ Solar.R, airquality))
    #' card$get_content()
    #'
    #' ReportCard$new()$from_list(card$to_list(tempdir()), tempdir())
    #'
    from_list = function(card, output_dir) {
      self$reset()
      blocks <- card$blocks
      metadata <- card$metadata
      name <- card$name
      if (length(name) == 0) name <- character(0)
      blocks_names <- names(blocks)
      blocks_names <- gsub("[.][0-9]*$", "", blocks_names)
      for (iter_b in seq_along(blocks)) {
        block_class <- blocks_names[iter_b]
        block <- blocks[[iter_b]]
        instance <- private$dispatch_block(block_class)
        formal_args <- formalArgs(instance$new()$from_list)
        cblock <- if (all(c("x", "output_dir") %in% formal_args)) {
          instance$new()$from_list(block, output_dir)
        } else if ("x" %in% formal_args) {
          instance$new()$from_list(block)
        } else {
          instance$new()$from_list()
        }
        self$append_content(cblock)
      }
      for (meta in names(metadata)) {
        self$append_metadata(meta, metadata[[meta]])
      }
      self$set_name(name)
      invisible(self)
    }
  ),
  private = list(
    content = list(),
    metadata = list(),
    name = character(0),
    dispatch_block = function(block_class) {
      eval(str2lang(block_class))
    },
    # @description The copy constructor.
    #
    # @param name the name of the field
    # @param value the value of the field
    # @return the new value of the field
    #
    deep_clone = function(name, value) {
      if (name == "content") {
        lapply(value, function(content_block) {
          if (inherits(content_block, "R6")) {
            content_block$clone(deep = TRUE)
          } else {
            content_block
          }
        })
      } else {
        value
      }
    }
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' @title `TextBlock`
#' @docType class
#' @description
#' Specialized `ContentBlock` for embedding styled text within reports.
#' It supports multiple styling options to accommodate various text roles,
#' such as headers or verbatim text, in the report content.
#'
#' @keywords internal
TextBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "TextBlock",
  inherit = ContentBlock,
  public = list(
    #' @description Initialize a `TextBlock` object.
    #'
    #' @details Constructs a `TextBlock` object with no content and the default style.
    #'
    #' @param content (`character`) a string assigned to this `TextBlock`
    #' @param style (`character(1)`) one of: `"default"`, `"header2"`, `"header3"` `"verbatim"`
    #'
    #' @return Object of class `TextBlock`, invisibly.
    #' @examples
    #' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
    #' block <- TextBlock$new()
    #'
    initialize = function(content = character(0), style = private$styles[1]) {
      super$set_content(content)
      self$set_style(style)
      invisible(self)
    },
    #' @description Sets content of this `TextBlock`.
    #'
    #' @param content (`any`) R object
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' ContentBlock <- getFromNamespace("ContentBlock", "teal.reporter")
    #' block <- ContentBlock$new()
    #' block$set_content("Base64 encoded picture")
    #'
    set_content = function(content) {
      checkmate::assert_string(content)
      super$set_content(content)
    },
    #' @description Sets the style of this `TextBlock`.
    #'
    #' @details The style has bearing on the rendering of this block.
    #'
    #' @param style (`character(1)`) one of: `"default"`, `"header2"`, `"header3"` `"verbatim"`
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
    #' block <- TextBlock$new()
    #' block$set_style("header2")
    #'
    set_style = function(style) {
      private$style <- match.arg(style, private$styles)
      invisible(self)
    },
    #' @description Get the style of this `TextBlock`.
    #'
    #' @return `character(1)` the style of this `TextBlock`.
    #' @examples
    #' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
    #' block <- TextBlock$new()
    #' block$get_style()
    #'
    get_style = function() {
      private$style
    },
    #' @description Get available an array of styles available to this `TextBlock`.
    #'
    #' @return A `character` array of styles.
    #' @examples
    #' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
    #' block <- TextBlock$new()
    #' block$get_available_styles()
    #'
    get_available_styles = function() {
      private$styles
    },
    #' @description Create the `TextBlock` from a list.
    #'
    #' @param x (`named list`) with two fields `text` and `style`.
    #' Use the `get_available_styles` method to get all possible styles.
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
    #' block <- TextBlock$new()
    #' block$from_list(list(text = "sth", style = "default"))
    #'
    from_list = function(x) {
      checkmate::assert_list(x)
      checkmate::assert_names(names(x), must.include = c("text", "style"))
      self$set_content(x$text)
      self$set_style(x$style)
      invisible(self)
    },
    #' @description Convert the `TextBlock` to a list.
    #'
    #' @return `named list` with a text and style.
    #' @examples
    #' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
    #' block <- TextBlock$new()
    #' block$to_list()
    #'
    to_list = function() {
      list(text = self$get_content(), style = self$get_style())
    }
  ),
  private = list(
    content = character(0),
    style = character(0),
    styles = c("default", "header2", "header3", "verbatim")
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' @title `HTMLBlock`
#' @docType class
#' @description
#' Specialized `FileBlock` for managing HTML content in reports.
#' It's designed to handle various HTML content, and render the report as HTML,
#' however `htmlwidgets` objects can also be rendered to static document-ready format.
#'
#' @keywords internal
HTMLBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "HTMLBlock",
  inherit = ContentBlock,
  public = list(
    #' @description Initialize a `HTMLBlock` object.
    #'
    #' @param content An object that can be rendered as a HTML content assigned to
    #'   this `HTMLBlock`
    #'
    #' @return Object of class `HTMLBlock`, invisibly.
    initialize = function(content) {
      if (!missing(content)) {
        checkmate::assert_multi_class(content, private$supported_types)
        self$set_content(content)
      }
      invisible(self)
    },

    #' @description Create the `HTMLBlock` from a list.
    #'
    #' @param x (`named list`) with a single field `content` containing `shiny.tag`,
    #' `shiny.tag.list` or `htmlwidget`.
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' HTMLBlock <- getFromNamespace("HTMLBlock", "teal.reporter")
    #' block <- HTMLBlock$new()
    #' block$from_list(list(content = shiny::tags$div("test")))
    #'
    from_list = function(x) {
      checkmate::assert_list(x, types = private$supported_types)
      checkmate::assert_names(names(x), must.include = "content")
      self$set_content(x$content)
      invisible(self)
    },

    #' @description Convert the `HTMLBlock` to a list.
    #'
    #' @return `named list` with a text and style.
    #' @examples
    #' HTMLBlock <- getFromNamespace("HTMLBlock", "teal.reporter")
    #' block <- HTMLBlock$new(shiny::tags$div("test"))
    #' block$to_list()
    #'
    to_list = function() {
      list(content = self$get_content())
    }
  ),
  private = list(
    supported_types = c("shiny.tag", "shiny.tag.list", "htmlwidget")
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' Add card button module
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Provides a button to add views/cards to a report.
#'
#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
#'
#' @details
#' The `card_fun` function is designed to create a new `ReportCard` instance and optionally customize it:
#' - The `card` parameter allows for specifying a custom or default `ReportCard` instance.
#' - Use the `comment` parameter to add a comment to the card via `card$append_text()` - if `card_fun` does not
#' have the `comment` parameter, then `comment` from `Add Card UI` module will be added at the end of the content of the
#' card.
#' - The `label` parameter enables customization of the card's name and its content through `card$append_text()`-
#' if `card_fun` does not have the `label` parameter, then card name will be set to the name passed in
#' `Add Card UI` module, but no text will be added to the content of the `card`.
#'
#' This module supports using a subclass of [`ReportCard`] for added flexibility.
#' A subclass instance should be passed as the default value of
#' the `card` argument in the `card_fun` function.
#' See below:
#' ```{r}
#' CustomReportCard <- R6::R6Class(
#'   classname = "CustomReportCard",
#'   inherit = teal.reporter::ReportCard
#' )
#'
#' custom_function <- function(card = CustomReportCard$new()) {
#'   card
#' }
#' ```
#' @name add_card_button
#'
#' @param id (`character(1)`) this `shiny` module's id.
#' @param reporter (`Reporter`) instance.
#' @param card_fun (`function`) which returns a [`ReportCard`] instance. See `Details`.
#'
#' @return `NULL`.
NULL

#' @rdname add_card_button
#' @export
add_card_button_ui <- function(id) {
  ns <- shiny::NS(id)

  # Buttons with custom css and
  # js code to disable the add card button when clicked to prevent multi-clicks
  shiny::tagList(
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
    ),
    shiny::singleton(
      shiny::tags$head(
        shiny::tags$script(
          shiny::HTML(
            sprintf(
              '
              $(document).ready(function(event) {
                $("body").on("click", "#%s", function() {
                  $(this).addClass("disabled");
                })
              })',
              ns("add_card_ok")
            )
          )
        )
      )
    ),
    shiny::actionButton(
      ns("add_report_card_button"),
      title = "Add Card",
      class = "teal-reporter simple_report_button btn-primary",
      `data-val` = shiny::restoreInput(id = ns("add_report_card_button"), default = NULL),
      shiny::tags$span(
        shiny::icon("plus")
      )
    )
  )
}

#' @rdname add_card_button
#' @export
add_card_button_srv <- function(id, reporter, card_fun) {
  checkmate::assert_function(card_fun)
  checkmate::assert_class(reporter, "Reporter")
  checkmate::assert_subset(names(formals(card_fun)), c("card", "comment", "label"), empty.ok = TRUE)

  shiny::moduleServer(id, function(input, output, session) {
    shiny::setBookmarkExclude(c(
      "add_report_card_button", "download_button", "reset_reporter",
      "add_card_ok", "download_data", "reset_reporter_ok",
      "label", "comment"
    ))

    ns <- session$ns

    add_modal <- function() {
      shiny::div(
        class = "teal-widgets reporter-modal",
        shiny::modalDialog(
          easyClose = TRUE,
          shiny::tags$h3("Add a Card to the Report"),
          shiny::tags$hr(),
          shiny::textInput(
            ns("label"),
            "Card Name",
            value = "",
            placeholder = "Add the card title here",
            width = "100%"
          ),
          shiny::textAreaInput(
            ns("comment"),
            "Comment",
            value = "",
            placeholder = "Add a comment here...",
            width = "100%"
          ),
          shiny::tags$script(
            shiny::HTML(
              sprintf(
                "
                $('#shiny-modal').on('shown.bs.modal', () => {
                  $('#%s').focus()
                })
                ",
                ns("label")
              )
            )
          ),
          footer = shiny::div(
            shiny::tags$button(
              type = "button",
              class = "btn btn-secondary",
              `data-dismiss` = "modal",
              `data-bs-dismiss` = "modal",
              NULL,
              "Cancel"
            ),
            shiny::tags$button(
              id = ns("add_card_ok"),
              type = "button",
              class = "btn btn-primary action-button",
              `data-val` = shiny::restoreInput(id = ns("add_card_ok"), default = NULL),
              NULL,
              "Add Card"
            )
          )
        )
      )
    }

    shiny::observeEvent(input$add_report_card_button, {
      shiny::showModal(add_modal())
    })

    # the add card button is disabled when clicked to prevent multi-clicks
    # please check the ui part for more information
    shiny::observeEvent(input$add_card_ok, {
      card_fun_args_nams <- names(formals(card_fun))
      has_card_arg <- "card" %in% card_fun_args_nams
      has_comment_arg <- "comment" %in% card_fun_args_nams
      has_label_arg <- "label" %in% card_fun_args_nams

      arg_list <- list()

      if (has_comment_arg) {
        arg_list <- c(arg_list, list(comment = input$comment))
      }
      if (has_label_arg) {
        arg_list <- c(arg_list, list(label = input$label))
      }

      if (has_card_arg) {
        # The default_card is defined here because formals() returns a pairedlist object
        # of formal parameter names and their default values. The values are missing
        # if not defined and the missing check does not work if supplied formals(card_fun)[[1]]
        default_card <- formals(card_fun)$card
        card <- `if`(
          missing(default_card),
          ReportCard$new(),
          eval(default_card, envir = environment(card_fun))
        )
        arg_list <- c(arg_list, list(card = card))
      }

      card <- try(do.call(card_fun, arg_list))

      if (inherits(card, "try-error")) {
        msg <- paste0(
          "The card could not be added to the report. ",
          "Have the outputs for the report been created yet? If not please try again when they ",
          "are ready. Otherwise contact your application developer"
        )
        warning(msg)
        shiny::showNotification(
          msg,
          type = "error"
        )
      } else {
        checkmate::assert_class(card, "ReportCard")
        if (!has_comment_arg && length(input$comment) > 0 && input$comment != "") {
          card$append_text("Comment", "header3")
          card$append_text(input$comment)
        }

        if (!has_label_arg && length(input$label) == 1 && input$label != "") {
          card$set_name(input$label)
        }

        reporter$append_cards(list(card))
        shiny::showNotification(sprintf("The card added successfully."), type = "message")
        shiny::removeModal()
      }
    })
  })
}

#' User Interface to Load `Reporter`
#' @description `r lifecycle::badge("experimental")`
#' Button to upload `ReporterCard`(s) to the `Reporter`.
#'
#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
#' @param id `character(1)` this `shiny` module's id.
#' @return `shiny::tagList`
#' @export
report_load_ui <- function(id) {
  ns <- shiny::NS(id)

  shiny::tagList(
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
    ),
    shiny::actionButton(
      ns("reporter_load"),
      class = "teal-reporter simple_report_button btn-primary",
      title = "Load",
      shiny::tags$span(
        shiny::icon("upload")
      )
    )
  )
}

#' Server to Load `Reporter`
#' @description `r lifecycle::badge("experimental")`
#' Server to load `ReporterCard`(s) to the `Reporter`
#'
#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
#'
#' @param id `character(1)` this `shiny` module's id.
#' @param reporter [`Reporter`] instance.
#'
#' @return `shiny::moduleServer`
#' @export
report_load_srv <- function(id, reporter) {
  checkmate::assert_class(reporter, "Reporter")

  shiny::moduleServer(
    id,
    function(input, output, session) {
      shiny::setBookmarkExclude(c("reporter_load_main", "reporter_load"))
      ns <- session$ns

      archiver_modal <- function() {
        nr_cards <- length(reporter$get_cards())
        shiny::div(
          class = "teal-widgets reporter-modal",
          shiny::modalDialog(
            easyClose = TRUE,
            shiny::tags$h3("Load the Report"),
            shiny::tags$hr(),
            shiny::fileInput(ns("archiver_zip"), "Choose saved Reporter file to Load (a zip file)",
              multiple = FALSE,
              accept = c(".zip")
            ),
            footer = shiny::div(
              shiny::tags$button(
                type = "button",
                class = "btn btn-danger",
                `data-dismiss` = "modal",
                `data-bs-dismiss` = "modal",
                NULL,
                "Cancel"
              ),
              shiny::tags$button(
                id = ns("reporter_load_main"),
                type = "button",
                class = "btn btn-primary action-button",
                NULL,
                "Load"
              )
            )
          )
        )
      }

      shiny::observeEvent(input$reporter_load, {
        shiny::showModal(archiver_modal())
      })

      shiny::observeEvent(input$reporter_load_main, {
        load_json_report(reporter, input$archiver_zip[["datapath"]], input$archiver_zip[["name"]])
        shiny::removeModal()
      })
    }
  )
}

#' @keywords internal
load_json_report <- function(reporter, zip_path, filename) {
  tmp_dir <- tempdir()
  output_dir <- file.path(tmp_dir, sprintf("report_load_%s", gsub("[.]", "", format(Sys.time(), "%Y%m%d%H%M%OS4"))))
  dir.create(path = output_dir)
  if (!is.null(zip_path) && grepl("report_", filename)) {
    tryCatch(
      expr = zip::unzip(zip_path, exdir = output_dir, junkpaths = TRUE),
      warning = function(cond) {
        print(cond)
        shiny::showNotification(
          ui = "Unzipping folder warning!",
          action = "Please contact app developer",
          type = "warning"
        )
      },
      error = function(cond) {
        print(cond)
        shiny::showNotification(
          ui = "Unzipping folder error!",
          action = "Please contact app developer",
          type = "error"
        )
      }
    )
    tryCatch(
      reporter$from_jsondir(output_dir),
      warning = function(cond) {
        print(cond)
        shiny::showNotification(
          ui = "Loading reporter warning!",
          action = "Please contact app developer",
          type = "warning"
        )
      },
      error = function(cond) {
        print(cond)
        shiny::showNotification(
          ui = "Loading reporter error!",
          action = "Please contact app developer",
          type = "error"
        )
      }
    )
  } else {
    shiny::showNotification("Failed to load the Reporter file.", type = "error")
  }
}

#' @title `TableBlock`
#' @docType class
#' @description
#' Specialized `FileBlock` for managing table content in reports.
#' It's designed to handle various table formats, converting them into a consistent,
#' document-ready format (e.g., `flextable`) for inclusion in reports.
#'
#' @keywords internal
TableBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "TableBlock",
  inherit = FileBlock,
  public = list(
    #' @description Initialize a `TableBlock` object.
    #'
    #' @param table (`data.frame` or `rtables` or `TableTree` or `ElementaryTable` or `listing_df`) a table assigned to
    #'   this `TableBlock`
    #'
    #' @return Object of class `TableBlock`, invisibly.
    initialize = function(table) {
      if (!missing(table)) {
        self$set_content(table)
      }
      invisible(self)
    },
    #' @description Sets content of this `TableBlock`.
    #'
    #' @details Raises error if argument is not a table-like object.
    #'
    #' @param content (`data.frame` or `rtables` or `TableTree` or `ElementaryTable` or `listing_df`)
    #' a table assigned to this `TableBlock`
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' TableBlock <- getFromNamespace("TableBlock", "teal.reporter")
    #' block <- TableBlock$new()
    #' block$set_content(iris)
    #'
    set_content = function(content) {
      checkmate::assert_multi_class(content, private$supported_tables)
      content <- to_flextable(content)
      path <- tempfile(fileext = ".rds")
      saveRDS(content, file = path)
      super$set_content(path)
      invisible(self)
    }
  ),
  private = list(
    supported_tables = c("data.frame", "rtables", "TableTree", "ElementaryTable", "listing_df")
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' Get bootstrap current version
#' @note will work properly mainly inside a tag `.renderHook`
#' @keywords internal
get_bs_version <- function() {
  theme <- bslib::bs_current_theme()
  if (bslib::is_bs_theme(theme)) {
    bslib::theme_version(theme)
  } else {
    "3"
  }
}

#' Panel group widget
#'
#' `r lifecycle::badge("experimental")`
#'
#' @param title (`character`) title of panel
#' @param ... content of panel
#' @param collapsed (`logical`, optional)
#'  whether to initially collapse panel
#' @param input_id (`character`, optional)
#'  name of the panel item element. If supplied, this will register a shiny input variable that
#'  indicates whether the panel item is open or collapsed and is accessed with `input$input_id`.
#'
#' @return `shiny.tag`.
#'
#' @keywords internal
panel_item <- function(title, ..., collapsed = TRUE, input_id = NULL) {
  stopifnot(checkmate::test_character(title, len = 1) || inherits(title, c("shiny.tag", "shiny.tag.list", "html")))
  checkmate::assert_flag(collapsed)
  checkmate::assert_string(input_id, null.ok = TRUE)

  div_id <- paste0(input_id, "_div")
  panel_id <- paste0(input_id, "_panel_body_", sample(1:10000, 1))


  shiny::tags$div(.renderHook = function(res_tag) {
    bs_version <- get_bs_version()

    # alter tag structure
    if (bs_version == "3") {
      res_tag$children <- list(
        shiny::tags$div(
          class = "panel panel-default",
          shiny::tags$div(
            id = div_id,
            class = paste("panel-heading", ifelse(collapsed, "collapsed", "")),
            `data-toggle` = "collapse",
            href = paste0("#", panel_id),
            `aria-expanded` = ifelse(collapsed, "false", "true"),
            shiny::icon("angle-down", class = "dropdown-icon"),
            shiny::tags$label(
              class = "panel-title inline",
              title,
            )
          ),
          shiny::tags$div(
            class = paste("panel-collapse collapse", ifelse(collapsed, "", "in")),
            id = panel_id,
            shiny::tags$div(
              class = "panel-body",
              ...
            )
          )
        )
      )
    } else if (bs_version %in% c("4", "5")) {
      res_tag$children <- list(
        shiny::tags$div(
          class = "card my-2",
          shiny::tags$div(
            class = "card-header",
            shiny::tags$div(
              class = ifelse(collapsed, "collapsed", ""),
              # bs4
              `data-toggle` = "collapse",
              # bs5
              `data-bs-toggle` = "collapse",
              href = paste0("#", panel_id),
              `aria-expanded` = ifelse(collapsed, "false", "true"),
              shiny::icon("angle-down", class = "dropdown-icon"),
              shiny::tags$label(
                class = "card-title inline",
                title,
              )
            )
          ),
          shiny::tags$div(
            id = panel_id,
            class = paste("collapse", ifelse(collapsed, "", "show")),
            shiny::tags$div(
              class = "card-body",
              ...
            )
          )
        )
      )
    } else {
      stop("Bootstrap 3, 4, and 5 are supported.")
    }

    shiny::tagList(
      shiny::singleton(
        shiny::tags$head(
          shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter"))
        )
      ),
      res_tag
    )
  })
}

#' Convert content into a `flextable`
#'
#' Converts supported table formats into a `flextable` for enhanced formatting and presentation.
#'
#' Function merges cells with `colspan` > 1,
#' aligns columns to the center and row names to the left,
#' indents the row names by 10 times indentation.
#'
#' @param content Supported formats: `data.frame`, `rtables`, `TableTree`, `ElementaryTable`, `listing_df`
#'
#' @return `flextable`.
#'
#' @keywords internal
to_flextable <- function(content) {
  if (inherits(content, c("rtables", "TableTree", "ElementaryTable"))) {
    ft <- rtables.officer::tt_to_flextable(content)
  } else if (inherits(content, "listing_df")) {
    mf <- rlistings::matrix_form(content)
    nr_header <- attr(mf, "nrow_header")
    df <- as.data.frame(mf$strings[seq(nr_header + 1, nrow(mf$strings)), , drop = FALSE])
    header_df <- as.data.frame(mf$strings[seq_len(nr_header), , drop = FALSE])

    ft <- rtables::df_to_tt(df)
    if (length(mf$main_title) != 0) {
      rtables::main_title(ft) <- mf$main_title
    }
    rtables::subtitles(ft) <- mf$subtitles
    rtables::main_footer(ft) <- mf$main_footer
    rtables::prov_footer(ft) <- mf$prov_footer
    rtables::header_section_div(ft) <- mf$header_section_div
    ft <- rtables.officer::tt_to_flextable(ft, total_width = c(grDevices::pdf.options()$width - 1))
  } else if (inherits(content, "data.frame")) {
    ft <- rtables.officer::tt_to_flextable(
      rtables::df_to_tt(content)
    )
  } else {
    stop(paste0("Unsupported class `(", format(class(content)), ")` when exporting table"))
  }

  ft
}

#' Get the merge index for a single span.
#' This function retrieves the merge index for a single span,
#' which is used in merging cells.
#' @noRd
#' @keywords internal
get_merge_index_single <- function(span) {
  ret <- list()
  j <- 1
  while (j < length(span)) {
    if (span[j] != 1) {
      ret <- c(ret, list(seq(j, j + span[j] - 1)))
    }
    j <- j + span[j]
  }
  return(ret)
}

#' Divide text block into smaller blocks
#'
#' Split a text block into smaller blocks with a specified number of lines.
#'
#' A single character string containing a text block of multiple lines (separated by `\n`)
#' is split into multiple strings with n or less lines each.
#'
#' @param x (`character`) string containing the input block of text
#' @param n (`integer`) number of lines per block
#'
#' @return
#' List of character strings with up to `n` lines in each element.
#'
#' @keywords internal
split_text_block <- function(x, n) {
  checkmate::assert_string(x)
  checkmate::assert_integerish(n, lower = 1L, len = 1L)

  lines <- strsplit(x, "\n")[[1]]

  if (length(lines) <= n) {
    return(list(x))
  }

  nblocks <- ceiling(length(lines) / n)
  ind <- rep(1:nblocks, each = n)[seq_along(lines)]
  unname(lapply(split(lines, ind), paste, collapse = "\n"))
}

#' Retrieve text details for global_knitr options
#' This function returns a character string describing the default settings for the global_knitr options.
#' @noRd
#' @keywords internal
global_knitr_details <- function() {
  paste0(
    c(
      " To access the default values for the `global_knitr` parameter,",
      "  use `getOption('teal.reporter.global_knitr')`. These defaults include:",
      " - `echo = TRUE`",
      " - `tidy.opts = list(width.cutoff = 60)`",
      " - `tidy = TRUE`  if `formatR` package is installed, `FALSE` otherwise"
    ),
    collapse = "\n"
  )
}

#' @title `FileBlock`
#' @docType class
#' @description
#' `FileBlock` manages file-based content in a report,
#'  ensuring appropriate handling of content files.
#'
#' @keywords internal
FileBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "FileBlock",
  inherit = ContentBlock,
  public = list(
    #' @description Finalize the `FileBlock`.
    #'
    #' @details Removes the temporary file created in the constructor.
    finalize = function() {
      try(unlink(super$get_content()))
    },
    #' @description Create the `FileBlock` from a list.
    #' The list should contain one named field, `"basename"`.
    #'
    #' @param x (`named list`) with one field `"basename"`, a name of the file.
    #' @param output_dir (`character`) with a path to the directory where a file will be copied.
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' FileBlock <- getFromNamespace("FileBlock", "teal.reporter")
    #' block <- FileBlock$new()
    #' file_path <- tempfile(fileext = ".png")
    #' saveRDS(iris, file_path)
    #' block$from_list(list(basename = basename(file_path)), dirname(file_path))
    #'
    from_list = function(x, output_dir) {
      checkmate::assert_list(x)
      checkmate::assert_names(names(x), must.include = "basename")
      path <- file.path(output_dir, x$basename)
      file_type <- paste0(".", tools::file_ext(path))
      checkmate::assert_file_exists(path, extension = file_type)
      new_file_path <- tempfile(fileext = file_type)
      file.copy(path, new_file_path)
      super$set_content(new_file_path)
      invisible(self)
    },
    #' @description Convert the `FileBlock` to a list.
    #'
    #' @param output_dir (`character`) with a path to the directory where a file will be copied.
    #'
    #' @return `named list` with a `basename` of the file.
    #' @examples
    #' FileBlock <- getFromNamespace("FileBlock", "teal.reporter")
    #' block <- FileBlock$new()
    #' block$to_list(tempdir())
    #'
    to_list = function(output_dir) {
      base_name <- basename(super$get_content())
      file.copy(super$get_content(), file.path(output_dir, base_name))
      list(basename = base_name)
    }
  ),
  private = list(
    content = character(0)
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

.onLoad <- function(libname, pkgname) {
  op <- options()
  default_global_knitr <- list(teal.reporter.global_knitr = list(
    echo = TRUE,
    tidy.opts = list(width.cutoff = 60),
    tidy = requireNamespace("formatR", quietly = TRUE)
  ))

  if (!("teal.reporter.global_knitr" %in% names(op))) {
    options(default_global_knitr)
  }

  invisible()
}

.onAttach <- function(libname, pkgname) {
  if (!requireNamespace("formatR", quietly = TRUE)) {
    packageStartupMessage(
      "For better code formatting, consider installing the formatR package."
    )
  }
}

#' @title `PictureBlock`
#' @docType class
#' @description
#' Specialized `FileBlock` for managing picture content in reports.
#' It's designed to handle plots from packages such as `ggplot2`, `grid`, or `lattice`.
#' It can save plots to files, set titles and specify dimensions.
#'
#' @keywords internal
PictureBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "PictureBlock",
  inherit = FileBlock,
  public = list(
    #' @description Initialize a `PictureBlock` object.
    #'
    #' @param plot (`ggplot` or `grid`) a picture in this `PictureBlock`
    #'
    #' @return Object of class `PictureBlock`, invisibly.
    initialize = function(plot) {
      if (!missing(plot)) {
        self$set_content(plot)
      }
      invisible(self)
    },
    #' @description Sets the content of this `PictureBlock`.
    #'
    #' @details Raises error if argument is not a `ggplot`, `grob` or `trellis` plot.
    #'
    #' @param content (`ggplot` or `grob` or `trellis`) a picture in this `PictureBlock`
    #'
    #' @return `self`, invisibly.
    #' @examplesIf require("ggplot2") && require("lattice")
    #' library(ggplot2)
    #' library(lattice)
    #'
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$set_content(ggplot(iris))
    #'
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$set_content(bwplot(1))
    #'
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$set_content(ggplotGrob(ggplot(iris)))
    set_content = function(content) {
      checkmate::assert_multi_class(content, private$supported_plots)
      path <- tempfile(fileext = ".png")
      grDevices::png(filename = path, width = private$dim[1], height = private$dim[2])
      tryCatch(
        expr = {
          if (inherits(content, "grob")) {
            grid::grid.newpage()
            grid::grid.draw(content)
          } else if (inherits(content, c("gg", "Heatmap"))) { # "Heatmap" S4 from ComplexHeatmap
            print(content)
          } else if (inherits(content, "trellis")) {
            grid::grid.newpage()
            grid::grid.draw(grid::grid.grabExpr(print(content), warn = 0, wrap.grobs = TRUE))
          }
          super$set_content(path)
        },
        finally = grDevices::dev.off()
      )
      invisible(self)
    },
    #' @description Sets the title of this `PictureBlock`.
    #'
    #' @details Raises error if argument is not `character(1)`.
    #'
    #' @param title (`character(1)`) a string assigned to this `PictureBlock`
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$set_title("Title")
    #'
    set_title = function(title) {
      checkmate::assert_string(title)
      private$title <- title
      invisible(self)
    },
    #' @description Get the title of this `PictureBlock`.
    #'
    #' @return The content of this `PictureBlock`.
    #' @examples
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$get_title()
    #'
    get_title = function() {
      private$title
    },
    #' @description Sets the dimensions of this `PictureBlock`.
    #'
    #' @param dim (`numeric(2)`) figure dimensions (width and height) in pixels.
    #'
    #' @return `self`, invisibly.
    #' @examples
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$set_dim(c(800, 600))
    #'
    set_dim = function(dim) {
      checkmate::assert_numeric(dim, len = 2)
      private$dim <- dim
      invisible(self)
    },
    #' @description Get `PictureBlock` dimensions as a numeric vector.
    #'
    #' @return `numeric` the array of 2 numeric values representing width and height in pixels.
    #' @examples
    #' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
    #' block <- PictureBlock$new()
    #' block$get_dim()
    get_dim = function() {
      private$dim
    }
  ),
  private = list(
    supported_plots = c("ggplot", "grob", "trellis", "Heatmap"),
    type = character(0),
    title = "",
    dim = c(800, 600)
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

#' Simple reporter module
#'
#' @description `r lifecycle::badge("experimental")`
#'
#' Module provides compact UI and server functions for managing a report in a `shiny` app.
#' This module combines functionalities for [adding cards to a report][add_card_button],
#'  [downloading the report][download_report_button], and [resetting report content][reset_report_button].
#'
#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
#'
#' @details `r global_knitr_details()`
#'
#' @name simple_reporter
#'
#' @param id (`character(1)`) `shiny` module instance id.
#' @param reporter (`Reporter`) instance.
#' @param card_fun (`function`) which returns a [`ReportCard`] instance,
#' the function has a `card` argument and an optional `comment` argument.
#' @param global_knitr (`list`) a global `knitr` parameters for customizing the rendering process.
#' @inheritParams reporter_download_inputs
#'
#' @return `NULL`.
#'
#' @examples
#' if (interactive()) {
#'   library(shiny)
#'
#'   shinyApp(
#'     ui = fluidPage(simple_reporter_ui("simple")),
#'     server = function(input, output, session) {
#'       simple_reporter_srv("simple", Reporter$new(), function(card) card)
#'     }
#'   )
#' }
NULL

#' @rdname simple_reporter
#' @export
simple_reporter_ui <- function(id) {
  ns <- shiny::NS(id)
  shiny::tagList(
    shiny::singleton(
      shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
    ),
    shiny::tags$div(
      class = "block mb-4 p-1",
      shiny::tags$label(class = "text-primary block -ml-1", shiny::tags$strong("Reporter")),
      shiny::tags$div(
        class = "simple_reporter_container",
        add_card_button_ui(ns("add_report_card_simple")),
        download_report_button_ui(ns("download_button_simple")),
        report_load_ui(ns("archive_load_simple")),
        reset_report_button_ui(ns("reset_button_simple"))
      )
    )
  )
}

#' @rdname simple_reporter
#' @export
simple_reporter_srv <- function(
    id,
    reporter,
    card_fun,
    global_knitr = getOption("teal.reporter.global_knitr"),
    rmd_output = c(
      "html" = "html_document", "pdf" = "pdf_document",
      "powerpoint" = "powerpoint_presentation", "word" = "word_document"
    ),
    rmd_yaml_args = list(
      author = "NEST", title = "Report",
      date = as.character(Sys.Date()), output = "html_document",
      toc = FALSE
    )) {
  shiny::moduleServer(
    id,
    function(input, output, session) {
      add_card_button_srv("add_report_card_simple", reporter = reporter, card_fun = card_fun)
      download_report_button_srv(
        "download_button_simple",
        reporter = reporter,
        global_knitr = global_knitr,
        rmd_output = rmd_output,
        rmd_yaml_args = rmd_yaml_args
      )
      report_load_srv("archive_load_simple", reporter = reporter)
      reset_report_button_srv("reset_button_simple", reporter = reporter)
    }
  )
}

#' @title `NewpageBlock`
#' @docType class
#' @description
#' A `ContentBlock` subclass that represents a page break in a report output.
#'
#' @keywords internal
NewpageBlock <- R6::R6Class( # nolint: object_name_linter.
  classname = "NewpageBlock",
  inherit = ContentBlock,
  public = list(
    #' @description Initialize a `NewpageBlock` object.
    #'
    #' @details Returns a `NewpageBlock` object with no content and the default style.
    #'
    #' @return Object of class `NewpageBlock`, invisibly.
    #' @examples
    #' NewpageBlock <- getFromNamespace("NewpageBlock", "teal.reporter")
    #' block <- NewpageBlock$new()
    #'
    initialize = function() {
      super$set_content("\n\\newpage\n")
      invisible(self)
    }
  ),
  lock_objects = TRUE,
  lock_class = TRUE
)

1		#' Download report button module
2		#'
3		#' @description `r lifecycle::badge("experimental")`
4		#'
5		#' Provides a button that triggers downloading a report.
6		#'
7		#' For more information, refer to the vignette: `vignette("simpleReporter", "teal.reporter")`.
8		#'
9		#' @details `r global_knitr_details()`
10		#'
11		#' @name download_report_button
12		#'
13		#' @param id (`character(1)`) this `shiny` module's id.
14		#' @param reporter (`Reporter`) instance.
15		#' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
16		#' for customizing the rendering process.
17		#' @inheritParams reporter_download_inputs
18		#'
19		#' @return `NULL`.
20		NULL
21
22		#' @rdname download_report_button
23		#' @export
24		download_report_button_ui <- function(id) {
25	2x	ns <- shiny::NS(id)
26	2x	shiny::tagList(
27	2x	shiny::singleton(
28	2x	shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
29		),
30	2x	shiny::actionButton(
31	2x	ns("download_button"),
32	2x	class = "teal-reporter simple_report_button btn-primary",
33	2x	title = "Download",
34	2x	`data-val` = shiny::restoreInput(id = ns("download_button"), default = NULL),
35	2x	shiny::tags$span(
36	2x	shiny::icon("download")
37		)
38		)
39		)
40		}
41
42		#' @rdname download_report_button
43		#' @export
44		download_report_button_srv <- function(id,
45		reporter,
46		global_knitr = getOption("teal.reporter.global_knitr"),
47		rmd_output = c(
48		"html" = "html_document", "pdf" = "pdf_document",
49		"powerpoint" = "powerpoint_presentation", "word" = "word_document"
50		),
51		rmd_yaml_args = list(
52		author = "NEST", title = "Report",
53		date = as.character(Sys.Date()), output = "html_document",
54		toc = FALSE
55		)) {
56	10x	checkmate::assert_class(reporter, "Reporter")
57	10x	checkmate::assert_subset(names(global_knitr), names(knitr::opts_chunk$get()))
58	10x	checkmate::assert_subset(
59	10x	rmd_output,
60	10x	c(
61	10x	"html_document", "pdf_document",
62	10x	"powerpoint_presentation", "word_document"
63		),
64	10x	empty.ok = FALSE
65		)
66	10x	checkmate::assert_list(rmd_yaml_args, names = "named")
67	10x	checkmate::assert_names(
68	10x	names(rmd_yaml_args),
69	10x	subset.of = c("author", "title", "date", "output", "toc"),
70	10x	must.include = "output"
71		)
72	8x	checkmate::assert_true(rmd_yaml_args[["output"]] %in% rmd_output)
73
74	7x	shiny::moduleServer(id, function(input, output, session) {
75	7x	shiny::setBookmarkExclude(c("download_button"))
76
77	7x	ns <- session$ns
78
79	7x	download_modal <- function() {
80	1x	nr_cards <- length(reporter$get_cards())
81	1x	downb <- shiny::tags$a(
82	1x	id = ns("download_data"),
83	1x	class = paste("btn btn-primary shiny-download-link", if (nr_cards) NULL else "disabled"),
84	1x	style = if (nr_cards) NULL else "pointer-events: none;",
85	1x	href = "",
86	1x	target = "_blank",
87	1x	download = NA,
88	1x	shiny::icon("download"),
89	1x	"Download"
90		)
91	1x	shiny::tags$div(
92	1x	class = "teal-widgets reporter-modal",
93	1x	shiny::modalDialog(
94	1x	easyClose = TRUE,
95	1x	shiny::tags$h3("Download the Report"),
96	1x	shiny::tags$hr(),
97	1x	if (length(reporter$get_cards()) == 0) {
98	!	shiny::tags$div(
99	!	class = "mb-4",
100	!	shiny::tags$p(
101	!	class = "text-danger",
102	!	shiny::tags$strong("No Cards Added")
103		)
104		)
105		} else {
106	1x	shiny::tags$div(
107	1x	class = "mb-4",
108	1x	shiny::tags$p(
109	1x	class = "text-success",
110	1x	shiny::tags$strong(paste("Number of cards: ", nr_cards))
111		),
112		)
113		},
114	1x	reporter_download_inputs(
115	1x	rmd_yaml_args = rmd_yaml_args,
116	1x	rmd_output = rmd_output,
117	1x	showrcode = any_rcode_block(reporter),
118	1x	session = session
119		),
120	1x	footer = shiny::tagList(
121	1x	shiny::tags$button(
122	1x	type = "button",
123	1x	class = "btn btn-secondary",
124	1x	`data-dismiss` = "modal",
125	1x	`data-bs-dismiss` = "modal",
126	1x	NULL,
127	1x	"Cancel"
128		),
129	1x	downb
130		)
131		)
132		)
133		}
134
135	7x	shiny::observeEvent(input$download_button, {
136	1x	shiny::showModal(download_modal())
137		})
138
139	7x	output$download_data <- shiny::downloadHandler(
140	7x	filename = function() {
141	2x	paste0(
142	2x	"report_",
143	2x	if (reporter$get_id() == "") NULL else paste0(reporter$get_id(), "_"),
144	2x	format(Sys.time(), "%y%m%d%H%M%S"),
145	2x	".zip"
146		)
147		},
148	7x	content = function(file) {
149	2x	shiny::showNotification("Rendering and Downloading the document.")
150	2x	shinybusy::block(id = ns("download_data"), text = "", type = "dots")
151	2x	input_list <- lapply(names(rmd_yaml_args), function(x) input[[x]])
152	2x	names(input_list) <- names(rmd_yaml_args)
153	!	if (is.logical(input$showrcode)) global_knitr[["echo"]] <- input$showrcode
154	2x	report_render_and_compress(reporter, input_list, global_knitr, file)
155	2x	shinybusy::unblock(id = ns("download_data"))
156		},
157	7x	contentType = "application/zip"
158		)
159		})
160		}
161
162		#' Render the report
163		#'
164		#' Render the report and zip the created directory.
165		#'
166		#' @param reporter (`Reporter`) instance.
167		#' @param input_list (`list`) like `shiny` input converted to a regular named list.
168		#' @param global_knitr (`list`) a global `knitr` parameters, like echo.
169		#' But if local parameter is set it will have priority.
170		#' @param file (`character(1)`) where to copy the returned directory.
171		#'
172		#' @return `file` argument, invisibly.
173		#'
174		#' @keywords internal
175		report_render_and_compress <- function(reporter, input_list, global_knitr, file = tempdir()) {
176	8x	checkmate::assert_class(reporter, "Reporter")
177	8x	checkmate::assert_list(input_list, names = "named")
178	7x	checkmate::assert_string(file)
179
180		if (
181	5x	identical("pdf_document", input_list$output) &&
182	5x	inherits(try(system2("pdflatex", "--version", stdout = TRUE), silent = TRUE), "try-error")
183		) {
184	!	shiny::showNotification(
185	!	ui = "pdflatex is not available so the pdf_document could not be rendered. Please use other output type.",
186	!	action = "Please contact app developer",
187	!	type = "error"
188		)
189	!	stop("pdflatex is not available so the pdf_document could not be rendered.")
190		}
191
192	5x	yaml_header <- as_yaml_auto(input_list)
193	5x	renderer <- Renderer$new()
194
195	5x	tryCatch(
196	5x	renderer$render(reporter$get_blocks(), yaml_header, global_knitr),
197	5x	warning = function(cond) {
198	!	print(cond)
199	!	shiny::showNotification(
200	!	ui = "Render document warning!",
201	!	action = "Please contact app developer",
202	!	type = "warning"
203		)
204		},
205	5x	error = function(cond) {
206	!	print(cond)
207	!	shiny::showNotification(
208	!	ui = "Render document error!",
209	!	action = "Please contact app developer",
210	!	type = "error"
211		)
212		}
213		)
214
215	5x	output_dir <- renderer$get_output_dir()
216
217	5x	tryCatch(
218	5x	archiver_dir <- reporter$to_jsondir(output_dir),
219	5x	warning = function(cond) {
220	!	print(cond)
221	!	shiny::showNotification(
222	!	ui = "Archive document warning!",
223	!	action = "Please contact app developer",
224	!	type = "warning"
225		)
226		},
227	5x	error = function(cond) {
228	!	print(cond)
229	!	shiny::showNotification(
230	!	ui = "Archive document error!",
231	!	action = "Please contact app developer",
232	!	type = "error"
233		)
234		}
235		)
236
237	5x	temp_zip_file <- tempfile(fileext = ".zip")
238	5x	tryCatch(
239	5x	expr = zip::zipr(temp_zip_file, output_dir),
240	5x	warning = function(cond) {
241	!	print(cond)
242	!	shiny::showNotification(
243	!	ui = "Zipping folder warning!",
244	!	action = "Please contact app developer",
245	!	type = "warning"
246		)
247		},
248	5x	error = function(cond) {
249	!	print(cond)
250	!	shiny::showNotification(
251	!	ui = "Zipping folder error!",
252	!	action = "Please contact app developer",
253	!	type = "error"
254		)
255		}
256		)
257
258	5x	tryCatch(
259	5x	expr = file.copy(temp_zip_file, file),
260	5x	warning = function(cond) {
261	!	print(cond)
262	!	shiny::showNotification(
263	!	ui = "Copying file warning!",
264	!	action = "Please contact app developer",
265	!	type = "warning"
266		)
267		},
268	5x	error = function(cond) {
269	!	print(cond)
270	!	shiny::showNotification(
271	!	ui = "Copying file error!",
272	!	action = "Please contact app developer",
273	!	type = "error"
274		)
275		}
276		)
277
278	5x	rm(renderer)
279	5x	invisible(file)
280		}
281
282		#' Get the custom list of UI inputs
283		#'
284		#' @param rmd_output (`character`) vector with `rmarkdown` output types,
285		#' by default all possible `pdf_document`, `html_document`, `powerpoint_presentation`, and `word_document`.
286		#' If vector is named then those names will appear in the `UI`.
287		#' @param rmd_yaml_args (`named list`) with `Rmd` `yaml` header fields and their default values.
288		#' This `list` will result in the custom subset of UI inputs for the download reporter functionality.
289		#' Default `list(author = "NEST", title = "Report", date = Sys.Date(), output = "html_document", toc = FALSE)`.
290		#' The `list` must include at least `"output"` field.
291		#' The default value for `"output"` has to be in the `rmd_output` argument.
292		#'
293		#' @keywords internal
294		reporter_download_inputs <- function(rmd_yaml_args, rmd_output, showrcode, session) {
295	8x	shiny::tagList(
296	8x	lapply(names(rmd_yaml_args), function(e) {
297	40x	switch(e,
298	8x	author = shiny::textInput(session$ns("author"), label = "Author:", value = rmd_yaml_args$author),
299	8x	title = shiny::textInput(session$ns("title"), label = "Title:", value = rmd_yaml_args$title),
300	8x	date = shiny::dateInput(session$ns("date"), "Date:", value = rmd_yaml_args$date),
301	8x	output = shiny::tags$div(
302	8x	shinyWidgets::pickerInput(
303	8x	inputId = session$ns("output"),
304	8x	label = "Choose a document type: ",
305	8x	choices = rmd_output,
306	8x	selected = rmd_yaml_args$output
307		)
308		),
309	8x	toc = shiny::checkboxInput(session$ns("toc"), label = "Include Table of Contents", value = rmd_yaml_args$toc)
310		)
311		}),
312	8x	if (showrcode) {
313	!	shiny::checkboxInput(
314	!	session$ns("showrcode"),
315	!	label = "Include R Code",
316	!	value = FALSE
317		)
318		}
319		)
320		}
321
322		#' @noRd
323		#' @keywords internal
324		any_rcode_block <- function(reporter) {
325	10x	any(
326	10x	vapply(
327	10x	reporter$get_blocks(),
328	10x	function(e) inherits(e, "RcodeBlock"),
329	10x	logical(1)
330		)
331		)
332		}

1		#' @title `Renderer`
2		#' @docType class
3		#' @description
4		#' A class for rendering reports from `ContentBlock` into various formats using `rmarkdown`.
5		#' It supports `TextBlock`, `PictureBlock`, `RcodeBlock`, `NewpageBlock`, and `TableBlock`.
6		#'
7		#' @keywords internal
8		Renderer <- R6::R6Class( # nolint: object_name_linter.
9		classname = "Renderer",
10		public = list(
11		#' @description Initialize a `Renderer` object.
12		#'
13		#' @details Creates a new instance of `Renderer`
14		#' with a temporary directory for storing report files.
15		#'
16		#' @return Object of class `Renderer`, invisibly.
17		#' @examples
18		#' Renderer <- getFromNamespace("Renderer", "teal.reporter")
19		#' Renderer$new()
20		#'
21		initialize = function() {
22	10x	tmp_dir <- tempdir()
23	10x	output_dir <- file.path(tmp_dir, sprintf("report_%s", gsub("[.]", "", format(Sys.time(), "%Y%m%d%H%M%OS4"))))
24	10x	dir.create(path = output_dir)
25	10x	private$output_dir <- output_dir
26	10x	invisible(self)
27		},
28		#' @description Finalizes a `Renderer` object.
29		finalize = function() {
30	10x	unlink(private$output_dir, recursive = TRUE)
31		},
32		#' @description Getting the `Rmd` text which could be easily rendered later.
33		#'
34		#' @param blocks (`list`) of `TextBlock`, `PictureBlock` and `NewpageBlock` objects.
35		#' @param yaml_header (`character`) an `rmarkdown` `yaml` header.
36		#' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
37		#' for customizing the rendering process.
38		#' @details `r global_knitr_details()`
39		#'
40		#' @return Character vector constituting `rmarkdown` text (`yaml` header + body), ready to be rendered.
41		#' @examplesIf require("ggplot2")
42		#' library(yaml)
43		#' library(rtables)
44		#' library(ggplot2)
45		#'
46		#' ReportCard <- getFromNamespace("ReportCard", "teal.reporter")
47		#' Reporter <- getFromNamespace("Reporter", "teal.reporter")
48		#' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
49		#' md_header <- getFromNamespace("md_header", "teal.reporter")
50		#' Renderer <- getFromNamespace("Renderer", "teal.reporter")
51		#'
52		#' card1 <- ReportCard$new()
53		#' card1$append_text("Header 2 text", "header2")
54		#' card1$append_text("A paragraph of default text")
55		#' card1$append_plot(
56		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
57		#' )
58		#'
59		#' card2 <- ReportCard$new()
60		#' card2$append_text("Header 2 text", "header2")
61		#' card2$append_text("A paragraph of default text")
62		#' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
63		#' table_res2 <- build_table(lyt, airquality)
64		#' card2$append_table(table_res2)
65		#' card2$append_rcode("2+2", echo = FALSE)
66		#'
67		#' reporter <- Reporter$new()
68		#' reporter$append_cards(list(card1, card2))
69		#'
70		#' yaml_l <- list(
71		#' author = yaml_quoted("NEST"),
72		#' title = yaml_quoted("Report"),
73		#' date = yaml_quoted("07/04/2019"),
74		#' output = list(html_document = list(toc = FALSE))
75		#' )
76		#'
77		#' yaml_header <- md_header(as.yaml(yaml_l))
78		#'
79		#' result_path <- Renderer$new()$renderRmd(reporter$get_blocks(), yaml_header)
80		#'
81		renderRmd = function(blocks, yaml_header, global_knitr = getOption("teal.reporter.global_knitr")) {
82	8x	checkmate::assert_list(
83	8x	blocks,
84	8x	c("TextBlock", "PictureBlock", "NewpageBlock", "TableBlock", "RcodeBlock", "HTMLBlock")
85		)
86	7x	checkmate::assert_subset(names(global_knitr), names(knitr::opts_chunk$get()))
87	7x	if (missing(yaml_header)) {
88	2x	yaml_header <- md_header(yaml::as.yaml(list(title = "Report")))
89		}
90
91	7x	private$report_type <- get_yaml_field(yaml_header, "output")
92
93	7x	parsed_global_knitr <- sprintf(
94	7x	"\n```{r setup, include=FALSE}\nknitr::opts_chunk$set(%s)\n%s\n```\n",
95	7x	capture.output(dput(global_knitr)),
96	7x	if (identical(private$report_type, "powerpoint_presentation")) {
97	!	format_code_block_function <- quote(
98	!	code_block <- function(code_text) {
99	!	df <- data.frame(code_text)
100	!	ft <- flextable::flextable(df)
101	!	ft <- flextable::delete_part(ft, part = "header")
102	!	ft <- flextable::autofit(ft, add_h = 0)
103	!	ft <- flextable::fontsize(ft, size = 7, part = "body")
104	!	ft <- flextable::bg(x = ft, bg = "lightgrey")
105	!	ft <- flextable::border_outer(ft)
106	!	if (flextable::flextable_dim(ft)$widths > 8) {
107	!	ft <- flextable::width(ft, width = 8)
108		}
109	!	ft
110		}
111		)
112	!	paste(deparse(format_code_block_function), collapse = "\n")
113		} else {
114		""
115		}
116		)
117
118	7x	parsed_blocks <- paste(
119	7x	unlist(
120	7x	lapply(blocks, function(b) private$block2md(b))
121		),
122	7x	collapse = "\n\n"
123		)
124
125	7x	rmd_text <- paste0(yaml_header, "\n", parsed_global_knitr, "\n", parsed_blocks, "\n")
126	7x	tmp <- tempfile(fileext = ".Rmd")
127	7x	input_path <- file.path(
128	7x	private$output_dir,
129	7x	sprintf("input_%s.Rmd", gsub("[.]", "", format(Sys.time(), "%Y%m%d%H%M%OS3")))
130		)
131	7x	cat(rmd_text, file = input_path)
132	7x	input_path
133		},
134		#' @description Renders the `Report` to the desired output format by compiling the `rmarkdown` file.
135		#'
136		#' @param blocks (`list`) of `TextBlock`, `PictureBlock` or `NewpageBlock` objects.
137		#' @param yaml_header (`character`) an `rmarkdown` `yaml` header.
138		#' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
139		#' for customizing the rendering process.
140		#' @param ... `rmarkdown::render` arguments, `input` and `output_dir` should not be updated.
141		#' @details `r global_knitr_details()`
142		#'
143		#' @return `character` path to the output.
144		#' @examplesIf require("ggplot2")
145		#' library(yaml)
146		#' library(ggplot2)
147		#'
148		#' ReportCard <- getFromNamespace("ReportCard", "teal.reporter")
149		#' Reporter <- getFromNamespace("Reporter", "teal.reporter")
150		#' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
151		#' md_header <- getFromNamespace("md_header", "teal.reporter")
152		#' Renderer <- getFromNamespace("Renderer", "teal.reporter")
153		#'
154		#' card1 <- ReportCard$new()
155		#' card1$append_text("Header 2 text", "header2")
156		#' card1$append_text("A paragraph of default text")
157		#' card1$append_plot(
158		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
159		#' )
160		#'
161		#' card2 <- ReportCard$new()
162		#' card2$append_text("Header 2 text", "header2")
163		#' card2$append_text("A paragraph of default text")
164		#' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
165		#' table_res2 <- build_table(lyt, airquality)
166		#' card2$append_table(table_res2)
167		#' card2$append_rcode("2+2", echo = FALSE)
168		#'
169		#' reporter <- Reporter$new()
170		#' reporter$append_cards(list(card1, card2))
171		#'
172		#' yaml_l <- list(
173		#' author = yaml_quoted("NEST"),
174		#' title = yaml_quoted("Report"),
175		#' date = yaml_quoted("07/04/2019"),
176		#' output = list(html_document = list(toc = FALSE))
177		#' )
178		#'
179		#' yaml_header <- md_header(as.yaml(yaml_l))
180		#' result_path <- Renderer$new()$render(reporter$get_blocks(), yaml_header)
181		#'
182		render = function(blocks, yaml_header, global_knitr = getOption("teal.reporter.global_knitr"), ...) {
183	6x	args <- list(...)
184	6x	input_path <- self$renderRmd(blocks, yaml_header, global_knitr)
185	6x	args <- append(args, list(
186	6x	input = input_path,
187	6x	output_dir = private$output_dir,
188	6x	output_format = "all",
189	6x	quiet = TRUE
190		))
191	6x	args_nams <- unique(names(args))
192	6x	args <- lapply(args_nams, function(x) args[[x]])
193	6x	names(args) <- args_nams
194	6x	do.call(rmarkdown::render, args)
195		},
196		#' @description Get `output_dir` field.
197		#'
198		#' @return `character` a `output_dir` field path.
199		#' @examples
200		#' Renderer <- getFromNamespace("Renderer", "teal.reporter")$new()
201		#' Renderer$get_output_dir()
202		#'
203		get_output_dir = function() {
204	7x	private$output_dir
205		}
206		),
207		private = list(
208		output_dir = character(0),
209		report_type = NULL,
210		# factory method
211		block2md = function(block) {
212	27x	if (inherits(block, "TextBlock")) {
213	14x	private$textBlock2md(block)
214	13x	} else if (inherits(block, "RcodeBlock")) {
215	!	private$rcodeBlock2md(block)
216	13x	} else if (inherits(block, "PictureBlock")) {
217	7x	private$pictureBlock2md(block)
218	6x	} else if (inherits(block, "TableBlock")) {
219	2x	private$tableBlock2md(block)
220	4x	} else if (inherits(block, "NewpageBlock")) {
221	2x	block$get_content()
222	2x	} else if (inherits(block, "HTMLBlock")) {
223	2x	private$htmlBlock2md(block)
224		} else {
225	!	stop("Unknown block class")
226		}
227		},
228		# card specific methods
229		textBlock2md = function(block) {
230	14x	text_style <- block$get_style()
231	14x	block_content <- block$get_content()
232	14x	switch(text_style,
233	2x	"default" = block_content,
234	!	"verbatim" = sprintf("\n```\n%s\n```\n", block_content),
235	12x	"header2" = paste0("## ", block_content),
236	!	"header3" = paste0("### ", block_content),
237	!	block_content
238		)
239		},
240		rcodeBlock2md = function(block) {
241	!	params <- block$get_params()
242	!	params <- lapply(params, function(l) if (is.character(l)) shQuote(l) else l)
243	!	if (identical(private$report_type, "powerpoint_presentation")) {
244	!	block_content_list <- split_text_block(block$get_content(), 30)
245	!	paste(
246	!	sprintf(
247	!	"\\newpage\n\n---\n\n```{r, echo=FALSE}\ncode_block(\n%s)\n```\n",
248	!	shQuote(block_content_list, type = "cmd")
249		),
250	!	collapse = "\n\n"
251		)
252		} else {
253	!	sprintf(
254	!	"\\newpage\n\n--- \n\n```{r, %s}\n%s\n```\n",
255	!	paste(names(params), params, sep = "=", collapse = ", "),
256	!	block$get_content()
257		)
258		}
259		},
260		pictureBlock2md = function(block) {
261	7x	basename_pic <- basename(block$get_content())
262	7x	file.copy(block$get_content(), file.path(private$output_dir, basename_pic))
263	7x	params <- c(
264	7x	`out.width` = "'100%'",
265	7x	`out.height` = "'100%'"
266		)
267	7x	title <- block$get_title()
268	7x	if (length(title)) params["fig.cap"] <- shQuote(title)
269	7x	sprintf(
270	7x	"\n```{r, echo = FALSE, %s}\nknitr::include_graphics(path = '%s')\n```\n",
271	7x	paste(names(params), params, sep = "=", collapse = ", "),
272	7x	basename_pic
273		)
274		},
275		tableBlock2md = function(block) {
276	2x	basename_table <- basename(block$get_content())
277	2x	file.copy(block$get_content(), file.path(private$output_dir, basename_table))
278	2x	sprintf("```{r echo = FALSE}\nreadRDS('%s')\n```", basename_table)
279		},
280		htmlBlock2md = function(block) {
281	2x	basename <- basename(tempfile(fileext = ".rds"))
282	2x	suppressWarnings(saveRDS(block$get_content(), file = file.path(private$output_dir, basename)))
283	2x	sprintf("```{r echo = FALSE}\nreadRDS('%s')\n```", basename)
284		}
285		),
286		lock_objects = TRUE,
287		lock_class = TRUE
288		)

1		#' @title `ContentBlock`: A building block for report content
2		#' @docType class
3		#' @description This class represents a basic content unit in a report,
4		#' such as text, images, or other multimedia elements.
5		#' It serves as a foundation for constructing complex report structures.
6		#'
7		#' @keywords internal
8		ContentBlock <- R6::R6Class( # nolint: object_name_linter.
9		classname = "ContentBlock",
10		public = list(
11		#' @description Sets content of this `ContentBlock`.
12		#'
13		#' @param content (`any`) R object
14		#'
15		#' @return `self`, invisibly.
16		#' @examples
17		#' ContentBlock <- getFromNamespace("ContentBlock", "teal.reporter")
18		#' block <- ContentBlock$new()
19		#' block$set_content("Base64 encoded picture")
20		#'
21		set_content = function(content) {
22	311x	private$content <- content
23	311x	invisible(self)
24		},
25		#' @description Retrieves the content assigned to this block.
26		#'
27		#' @return object stored in a `private$content` field
28		#' @examples
29		#' ContentBlock <- getFromNamespace("ContentBlock", "teal.reporter")
30		#' block <- ContentBlock$new()
31		#' block$get_content()
32		#'
33		get_content = function() {
34	271x	private$content
35		},
36		#' @description Create the `ContentBlock` from a list.
37		#'
38		#' @param x (`named list`) with two fields `text` and `style`.
39		#' Use the `get_available_styles` method to get all possible styles.
40		#'
41		#' @return `self`, invisibly.
42		from_list = function(x) {
43	!	invisible(self)
44		},
45		#' @description Convert the `ContentBlock` to a list.
46		#'
47		#' @return `named list` with a text and style.
48		to_list = function() {
49	!	list()
50		}
51		),
52		private = list(
53		content = NULL, # this can be any R object
54		# @description The copy constructor.
55		#
56		# @param name (`character(1)`) the name of the field
57		# @param value the value assigned to the field
58		#
59		# @return the value of the copied field
60		deep_clone = function(name, value) {
61	156x	if (name == "content" && checkmate::test_file_exists(value)) {
62	7x	extension <- ""
63	7x	split <- strsplit(basename(value), split = "\\.")
64		# The below ensures no extension is found for files such as this: .gitignore but is found for files like
65		# .gitignore.txt
66	7x	if (length(split[[1]]) > 1 && split[[1]][length(split[[1]]) - 1] != "") {
67	5x	extension <- split[[1]][length(split[[1]])]
68	5x	extension <- paste0(".", extension)
69		}
70	7x	copied_file <- tempfile(fileext = extension)
71	7x	file.copy(value, copied_file, copy.date = TRUE, copy.mode = TRUE)
72	7x	copied_file
73		} else {
74	149x	value
75		}
76		}
77		),
78		lock_objects = TRUE,
79		lock_class = TRUE
80		)

1		#' Report previewer module
2		#'
3		#' @description `r lifecycle::badge("experimental")`
4		#'
5		#' Module offers functionalities to visualize, manipulate,
6		#' and interact with report cards that have been added to a report.
7		#' It includes a previewer interface to see the cards and options to modify the report before downloading.
8		#'
9		#' Cards are saved by the `shiny` bookmarking mechanism.
10		#'
11		#' For more details see the vignette: `vignette("previewerReporter", "teal.reporter")`.
12		#'
13		#' @details `r global_knitr_details()`
14		#'
15		#' @name reporter_previewer
16		#'
17		#' @param id (`character(1)`) `shiny` module instance id.
18		#' @param reporter (`Reporter`) instance.
19		#' @param global_knitr (`list`) of `knitr` parameters (passed to `knitr::opts_chunk$set`)
20		#' for customizing the rendering process.
21		#' @param previewer_buttons (`character`) set of modules to include with `c("download", "load", "reset")` possible
22		#' values and `"download"` is required.
23		#' Default `c("download", "load", "reset")`
24		#' @inheritParams reporter_download_inputs
25		#'
26		#' @return `NULL`.
27		NULL
28
29		#' @rdname reporter_previewer
30		#' @export
31		reporter_previewer_ui <- function(id) {
32	1x	ns <- shiny::NS(id)
33
34	1x	shiny::fluidRow(
35	1x	add_previewer_js(ns),
36	1x	add_previewer_css(),
37	1x	shiny::tagList(
38	1x	shiny::tags$div(
39	1x	class = "col-md-3",
40	1x	shiny::tags$div(class = "well", shiny::uiOutput(ns("encoding")))
41		),
42	1x	shiny::tags$div(
43	1x	class = "col-md-9",
44	1x	shiny::tags$div(
45	1x	id = "reporter_previewer",
46	1x	shiny::uiOutput(ns("pcards"))
47		)
48		)
49		)
50		)
51		}
52
53		#' @rdname reporter_previewer
54		#' @export
55		reporter_previewer_srv <- function(id,
56		reporter,
57		global_knitr = getOption("teal.reporter.global_knitr"),
58		rmd_output = c(
59		"html" = "html_document", "pdf" = "pdf_document",
60		"powerpoint" = "powerpoint_presentation",
61		"word" = "word_document"
62		),
63		rmd_yaml_args = list(
64		author = "NEST", title = "Report",
65		date = as.character(Sys.Date()), output = "html_document",
66		toc = FALSE
67		),
68		previewer_buttons = c("download", "load", "reset")) {
69	12x	checkmate::assert_subset(previewer_buttons, c("download", "load", "reset"), empty.ok = FALSE)
70	12x	checkmate::assert_true("download" %in% previewer_buttons)
71	12x	checkmate::assert_class(reporter, "Reporter")
72	12x	checkmate::assert_subset(names(global_knitr), names(knitr::opts_chunk$get()))
73	12x	checkmate::assert_subset(
74	12x	rmd_output,
75	12x	c(
76	12x	"html_document", "pdf_document",
77	12x	"powerpoint_presentation", "word_document"
78		),
79	12x	empty.ok = FALSE
80		)
81	12x	checkmate::assert_list(rmd_yaml_args, names = "named")
82	12x	checkmate::assert_names(
83	12x	names(rmd_yaml_args),
84	12x	subset.of = c("author", "title", "date", "output", "toc"),
85	12x	must.include = "output"
86		)
87	10x	checkmate::assert_true(rmd_yaml_args[["output"]] %in% rmd_output)
88
89	9x	shiny::moduleServer(id, function(input, output, session) {
90	9x	shiny::setBookmarkExclude(c(
91	9x	"card_remove_id", "card_down_id", "card_up_id", "remove_card_ok", "showrcode", "download_data_prev",
92	9x	"load_reporter_previewer", "load_reporter"
93		))
94
95	9x	session$onBookmark(function(state) {
96	!	reporterdir <- file.path(state$dir, "reporter")
97	!	dir.create(reporterdir)
98	!	reporter$to_jsondir(reporterdir)
99		})
100	9x	session$onRestored(function(state) {
101	!	reporterdir <- file.path(state$dir, "reporter")
102	!	reporter$from_jsondir(reporterdir)
103		})
104
105	9x	ns <- session$ns
106
107	9x	reset_report_button_srv("resetButtonPreviewer", reporter)
108
109	9x	output$encoding <- shiny::renderUI({
110	7x	reporter$get_reactive_add_card()
111	7x	nr_cards <- length(reporter$get_cards())
112
113	7x	previewer_buttons_list <- list(
114	7x	download = htmltools::tagAppendAttributes(
115	7x	shiny::actionButton(
116	7x	ns("download_data_prev"),
117	7x	class = "teal-reporter simple_report_button",
118	7x	shiny::tags$span("Download Report", shiny::icon("download"))
119		),
120	7x	class = if (nr_cards) "" else "disabled"
121		),
122	7x	load = shiny::actionButton(
123	7x	ns("load_reporter_previewer"),
124	7x	class = "teal-reporter simple_report_button",
125	7x	`data-val` = shiny::restoreInput(id = ns("load_reporter_previewer"), default = NULL),
126	7x	shiny::tags$span(
127	7x	"Load Report", shiny::icon("upload")
128		)
129		),
130	7x	reset = reset_report_button_ui(ns("resetButtonPreviewer"), label = "Reset Report")
131		)
132
133	7x	shiny::tags$div(
134	7x	id = "previewer_reporter_encoding",
135	7x	shiny::tags$h3("Download the Report"),
136	7x	shiny::tags$hr(),
137	7x	reporter_download_inputs(
138	7x	rmd_yaml_args = rmd_yaml_args,
139	7x	rmd_output = rmd_output,
140	7x	showrcode = any_rcode_block(reporter),
141	7x	session = session
142		),
143	7x	shiny::tags$div(
144	7x	id = "previewer_reporter_buttons",
145	7x	class = "previewer_buttons_line",
146	7x	lapply(previewer_buttons_list[previewer_buttons], shiny::tags$div)
147		)
148		)
149		})
150
151	9x	output$pcards <- shiny::renderUI({
152	9x	reporter$get_reactive_add_card()
153	9x	input$card_remove_id
154	9x	input$card_down_id
155	9x	input$card_up_id
156
157	9x	cards <- reporter$get_cards()
158
159	9x	if (length(cards)) {
160	8x	shiny::tags$div(
161	8x	class = "panel-group accordion",
162	8x	id = "reporter_previewer_panel",
163	8x	lapply(seq_along(cards), function(ic) {
164	14x	previewer_collapse_item(ic, cards[[ic]]$get_name(), cards[[ic]]$get_content())
165		})
166		)
167		} else {
168	1x	shiny::tags$div(
169	1x	id = "reporter_previewer_panel_no_cards",
170	1x	shiny::tags$p(
171	1x	class = "text-danger mt-4",
172	1x	shiny::tags$strong("No Cards added")
173		)
174		)
175		}
176		})
177
178	9x	shiny::observeEvent(input$load_reporter_previewer, {
179	!	nr_cards <- length(reporter$get_cards())
180	!	shiny::showModal(
181	!	shiny::modalDialog(
182	!	easyClose = TRUE,
183	!	shiny::tags$h3("Load the Reporter"),
184	!	shiny::tags$hr(),
185	!	shiny::fileInput(ns("archiver_zip"), "Choose Reporter File to Load (a zip file)",
186	!	multiple = FALSE,
187	!	accept = c(".zip")
188		),
189	!	footer = shiny::div(
190	!	shiny::tags$button(
191	!	type = "button",
192	!	class = "btn btn-danger",
193	!	`data-dismiss` = "modal",
194	!	`data-bs-dismiss` = "modal",
195	!	NULL,
196	!	"Cancel"
197		),
198	!	shiny::tags$button(
199	!	id = ns("load_reporter"),
200	!	type = "button",
201	!	class = "btn btn-primary action-button",
202	!	`data-val` = shiny::restoreInput(id = ns("load_reporter"), default = NULL),
203	!	NULL,
204	!	"Load"
205		)
206		)
207		)
208		)
209		})
210
211	9x	shiny::observeEvent(input$load_reporter, {
212	!	switch("JSON",
213	!	JSON = load_json_report(reporter, input$archiver_zip[["datapath"]], input$archiver_zip[["name"]]),
214	!	stop("The provided Reporter file format is not supported")
215		)
216
217	!	shiny::removeModal()
218		})
219
220	9x	shiny::observeEvent(input$card_remove_id, {
221	1x	shiny::showModal(
222	1x	shiny::modalDialog(
223	1x	title = "Remove the Report Card",
224	1x	shiny::tags$p(
225	1x	shiny::HTML(
226	1x	sprintf(
227	1x	"Do you really want to remove <strong>the card %s</strong> from the Report?",
228	1x	input$card_remove_id
229		)
230		)
231		),
232	1x	footer = shiny::tagList(
233	1x	shiny::tags$button(
234	1x	type = "button",
235	1x	class = "btn btn-secondary",
236	1x	`data-dismiss` = "modal",
237	1x	`data-bs-dismiss` = "modal",
238	1x	NULL,
239	1x	"Cancel"
240		),
241	1x	shiny::actionButton(ns("remove_card_ok"), "OK", class = "btn-danger")
242		)
243		)
244		)
245		})
246
247	9x	shiny::observeEvent(input$remove_card_ok, {
248	1x	reporter$remove_cards(input$card_remove_id)
249	1x	shiny::removeModal()
250		})
251
252	9x	shiny::observeEvent(input$card_up_id, {
253	3x	if (input$card_up_id > 1) {
254	2x	reporter$swap_cards(
255	2x	as.integer(input$card_up_id),
256	2x	as.integer(input$card_up_id - 1)
257		)
258		}
259		})
260
261	9x	shiny::observeEvent(input$card_down_id, {
262	3x	if (input$card_down_id < length(reporter$get_cards())) {
263	2x	reporter$swap_cards(
264	2x	as.integer(input$card_down_id),
265	2x	as.integer(input$card_down_id + 1)
266		)
267		}
268		})
269
270	9x	output$download_data_prev <- shiny::downloadHandler(
271	9x	filename = function() {
272	1x	paste0(
273	1x	"report_",
274	1x	if (reporter$get_id() == "") NULL else paste0(reporter$get_id(), "_"),
275	1x	format(Sys.time(), "%y%m%d%H%M%S"),
276	1x	".zip"
277		)
278		},
279	9x	content = function(file) {
280	1x	shiny::showNotification("Rendering and Downloading the document.")
281	1x	shinybusy::block(id = ns("download_data_prev"), text = "", type = "dots")
282	1x	input_list <- lapply(names(rmd_yaml_args), function(x) input[[x]])
283	1x	names(input_list) <- names(rmd_yaml_args)
284	!	if (is.logical(input$showrcode)) global_knitr[["echo"]] <- input$showrcode
285	1x	report_render_and_compress(reporter, input_list, global_knitr, file)
286	1x	shinybusy::unblock(id = ns("download_data_prev"))
287		},
288	9x	contentType = "application/zip"
289		)
290		})
291		}
292
293		#' @noRd
294		#' @keywords internal
295		block_to_html <- function(b) {
296	42x	b_content <- b$get_content()
297	42x	if (inherits(b, "TextBlock")) {
298	28x	switch(b$get_style(),
299	!	header1 = shiny::tags$h1(b_content),
300	28x	header2 = shiny::tags$h2(b_content),
301	!	header3 = shiny::tags$h3(b_content),
302	!	header4 = shiny::tags$h4(b_content),
303	!	verbatim = shiny::tags$pre(b_content),
304	!	shiny::tags$pre(b_content)
305		)
306	14x	} else if (inherits(b, "RcodeBlock")) {
307	!	panel_item("R Code", shiny::tags$pre(b_content))
308	14x	} else if (inherits(b, "PictureBlock")) {
309	14x	shiny::tags$img(src = knitr::image_uri(b_content))
310	!	} else if (inherits(b, "TableBlock")) {
311	!	b_table <- readRDS(b_content)
312	!	shiny::tags$pre(
313	!	flextable::htmltools_value(b_table)
314		)
315	!	} else if (inherits(b, "NewpageBlock")) {
316	!	shiny::tags$br()
317	!	} else if (inherits(b, "HTMLBlock")) {
318	!	b_content
319		} else {
320	!	stop("Unknown block class")
321		}
322		}
323
324		#' @noRd
325		#' @keywords internal
326		add_previewer_css <- function() {
327	1x	shiny::tagList(
328	1x	shiny::singleton(
329	1x	shiny::tags$head(shiny::includeCSS(system.file("css/Previewer.css", package = "teal.reporter")))
330		),
331	1x	shiny::singleton(
332	1x	shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
333		)
334		)
335		}
336
337		#' @noRd
338		#' @keywords internal
339		add_previewer_js <- function(ns) {
340	1x	shiny::singleton(
341	1x	shiny::tags$head(shiny::tags$script(
342	1x	shiny::HTML(sprintf('
343	1x	$(document).ready(function(event) {
344	1x	$("body").on("click", "span.card_remove_id", function() {
345	1x	let val = $(this).data("cardid");
346	1x	Shiny.setInputValue("%s", val, {priority: "event"});
347		});
348
349	1x	$("body").on("click", "span.card_up_id", function() {
350	1x	let val = $(this).data("cardid");
351	1x	Shiny.setInputValue("%s", val, {priority: "event"});
352		});
353
354	1x	$("body").on("click", "span.card_down_id", function() {
355	1x	let val = $(this).data("cardid");
356	1x	Shiny.setInputValue("%s", val, {priority: "event"});
357		});
358		});
359	1x	', ns("card_remove_id"), ns("card_up_id"), ns("card_down_id")))
360		))
361		)
362		}
363
364		#' @noRd
365		#' @keywords internal
366		nav_previewer_icon <- function(name, icon_name, idx, size = 1L) {
367	42x	checkmate::assert_string(name)
368	42x	checkmate::assert_string(icon_name)
369	42x	checkmate::assert_int(size)
370
371	42x	shiny::tags$span(
372	42x	class = paste(name, "icon_previewer"),
373		# data field needed to record clicked card on the js side
374	42x	`data-cardid` = idx,
375	42x	shiny::icon(icon_name, sprintf("fa-%sx", size))
376		)
377		}
378
379		#' @noRd
380		#' @keywords internal
381		nav_previewer_icons <- function(idx, size = 1L) {
382	14x	shiny::tags$span(
383	14x	class = "preview_card_control",
384	14x	nav_previewer_icon(name = "card_remove_id", icon_name = "xmark", idx = idx, size = size),
385	14x	nav_previewer_icon(name = "card_up_id", icon_name = "arrow-up", idx = idx, size = size),
386	14x	nav_previewer_icon(name = "card_down_id", icon_name = "arrow-down", idx = idx, size = size)
387		)
388		}
389
390		#' @noRd
391		#' @keywords internal
392		previewer_collapse_item <- function(idx, card_name, card_blocks) {
393	14x	shiny::tags$div(.renderHook = function(x) {
394		# get bs version
395	14x	version <- get_bs_version()
396
397	14x	if (version == "3") {
398	14x	shiny::tags$div(
399	14x	id = paste0("panel_card_", idx),
400	14x	class = "panel panel-default",
401	14x	shiny::tags$div(
402	14x	class = "panel-heading overflow-auto",
403	14x	shiny::tags$div(
404	14x	class = "panel-title",
405	14x	shiny::tags$span(
406	14x	nav_previewer_icons(idx = idx),
407	14x	shiny::tags$a(
408	14x	class = "accordion-toggle block py-3 px-4 -my-3 -mx-4",
409	14x	`data-toggle` = "collapse",
410	14x	`data-parent` = "#reporter_previewer_panel",
411	14x	href = paste0("#collapse", idx),
412	14x	shiny::tags$h4(paste0("Card ", idx, ": ", card_name), shiny::icon("caret-down"))
413		)
414		)
415		)
416		),
417	14x	shiny::tags$div(
418	14x	id = paste0("collapse", idx), class = "collapse out",
419	14x	shiny::tags$div(
420	14x	class = "panel-body",
421	14x	shiny::tags$div(
422	14x	id = paste0("card", idx),
423	14x	lapply(
424	14x	card_blocks,
425	14x	function(b) {
426	42x	block_to_html(b)
427		}
428		)
429		)
430		)
431		)
432		)
433		} else {
434	!	shiny::tags$div(
435	!	id = paste0("panel_card_", idx),
436	!	class = "card",
437	!	shiny::tags$div(
438	!	class = "overflow-auto",
439	!	shiny::tags$div(
440	!	class = "card-header",
441	!	shiny::tags$span(
442	!	nav_previewer_icons(idx = idx),
443	!	shiny::tags$a(
444	!	class = "accordion-toggle block py-3 px-4 -my-3 -mx-4",
445		# bs4
446	!	`data-toggle` = "collapse",
447		# bs5
448	!	`data-bs-toggle` = "collapse",
449	!	href = paste0("#collapse", idx),
450	!	shiny::tags$h4(
451	!	paste0("Card ", idx, ": ", card_name),
452	!	shiny::icon("caret-down")
453		)
454		)
455		)
456		)
457		),
458	!	shiny::tags$div(
459	!	id = paste0("collapse", idx),
460	!	class = "collapse out",
461		# bs4
462	!	`data-parent` = "#reporter_previewer_panel",
463		# bs5
464	!	`data-bs-parent` = "#reporter_previewer_panel",
465	!	shiny::tags$div(
466	!	class = "card-body",
467	!	shiny::tags$div(
468	!	id = paste0("card", idx),
469	!	lapply(
470	!	card_blocks,
471	!	function(b) {
472	!	block_to_html(b)
473		}
474		)
475		)
476		)
477		)
478		)
479		}
480		})
481		}

1		#' Reset report button module
2		#'
3		#' @description `r lifecycle::badge("experimental")`
4		#'
5		#' Provides a button that triggers resetting the report content.
6		#'
7		#' For more information, refer to the vignette: `vignette("simpleReporter", "teal.reporter")`.
8		#'
9		#' @name reset_report_button
10		#'
11		#' @param id (`character(1)`) `shiny` module instance id.
12		#' @param label (`character(1)`) label before the icon.
13		#' By default `NULL`.
14		#' @param reporter (`Reporter`) instance.
15		#' @return `NULL`.
16		NULL
17
18		#' @rdname reset_report_button
19		#' @export
20		reset_report_button_ui <- function(id, label = NULL) {
21	8x	checkmate::assert_string(label, null.ok = TRUE)
22
23	8x	ns <- shiny::NS(id)
24	8x	shiny::tagList(
25	8x	shiny::singleton(
26	8x	shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
27		),
28	8x	shiny::actionButton(
29	8x	ns("reset_reporter"),
30	8x	class = "teal-reporter simple_report_button clear-report btn-warning",
31	8x	title = "Reset",
32	8x	`data-val` = shiny::restoreInput(id = ns("reset_reporter"), default = NULL),
33	8x	shiny::tags$span(
34	8x	if (!is.null(label)) label,
35	8x	shiny::icon("xmark")
36		)
37		)
38		)
39		}
40
41		#' @rdname reset_report_button
42		#' @export
43		reset_report_button_srv <- function(id, reporter) {
44	12x	checkmate::assert_class(reporter, "Reporter")
45
46	12x	shiny::moduleServer(id, function(input, output, session) {
47	12x	shiny::setBookmarkExclude(c("reset_reporter"))
48
49	12x	ns <- session$ns
50	12x	nr_cards <- length(reporter$get_cards())
51
52
53	12x	shiny::observeEvent(input$reset_reporter, {
54	1x	shiny::tags$div(
55	1x	class = "teal-widgets reporter-modal",
56	1x	shiny::showModal(
57	1x	shiny::modalDialog(
58	1x	shiny::tags$h3("Reset the Report"),
59	1x	shiny::tags$hr(),
60	1x	shiny::tags$strong(
61	1x	shiny::tags$p(
62	1x	"Are you sure you want to reset the report? (This will remove ALL previously added cards)."
63		)
64		),
65	1x	footer = shiny::tagList(
66	1x	shiny::tags$button(
67	1x	type = "button",
68	1x	class = "btn btn-secondary",
69	1x	`data-dismiss` = "modal",
70	1x	`data-bs-dismiss` = "modal",
71	1x	NULL,
72	1x	"Cancel"
73		),
74	1x	shiny::actionButton(ns("reset_reporter_ok"), "Reset", class = "btn-danger")
75		)
76		)
77		)
78		)
79		})
80
81	12x	shiny::observeEvent(input$reset_reporter_ok, {
82	1x	reporter$reset()
83	1x	shiny::removeModal()
84		})
85		})
86		}

1		#' @title `RcodeBlock`
2		#' @docType class
3		#' @description
4		#' Specialized `ContentBlock` designed to embed `R` code in reports.
5		#'
6		#' @keywords internal
7		RcodeBlock <- R6::R6Class( # nolint: object_name_linter.
8		classname = "RcodeBlock",
9		inherit = ContentBlock,
10		public = list(
11		#' @description Initialize a `RcodeBlock` object.
12		#'
13		#' @details Returns a `RcodeBlock` object with no content and no parameters.
14		#'
15		#' @param content (`character(1)` or `character(0)`) a string assigned to this `RcodeBlock`
16		#' @param ... any `rmarkdown` `R` chunk parameter and it value.
17		#'
18		#' @return Object of class `RcodeBlock`, invisibly.
19		#' @examples
20		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
21		#' block <- RcodeBlock$new()
22		#'
23		initialize = function(content = character(0), ...) {
24	75x	checkmate::assert_class(content, "character")
25	75x	super$set_content(content)
26	75x	self$set_params(list(...))
27	75x	invisible(self)
28		},
29		#' @description Sets content of this `RcodeBlock`.
30		#'
31		#' @param content (`any`) R object
32		#'
33		#' @return `self`, invisibly.
34		#' @examples
35		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
36		#' block <- RcodeBlock$new()
37		#' block$set_content("a <- 1")
38		#'
39		set_content = function(content) {
40	11x	checkmate::assert_string(content)
41	10x	super$set_content(content)
42		},
43		#' @description Sets the parameters of this `RcodeBlock`.
44		#'
45		#' @details Configures `rmarkdown` chunk parameters for the `R` code block,
46		#' influencing its rendering and execution behavior.
47		#'
48		#' @param params (`list`) any `rmarkdown` R chunk parameter and its value.
49		#'
50		#' @return `self`, invisibly.
51		#' @examples
52		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
53		#' block <- RcodeBlock$new()
54		#' block$set_params(list(echo = TRUE))
55		#'
56		set_params = function(params) {
57	133x	checkmate::assert_list(params, names = "named")
58	133x	checkmate::assert_subset(names(params), self$get_available_params())
59	133x	private$params <- params
60	133x	invisible(self)
61		},
62		#' @description Get the parameters of this `RcodeBlock`.
63		#'
64		#' @return `character` the parameters of this `RcodeBlock`.
65		#' @examples
66		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
67		#' block <- RcodeBlock$new()
68		#' block$get_params()
69		#'
70		get_params = function() {
71	3x	private$params
72		},
73		#' @description Get available array of parameters available to this `RcodeBlock`.
74		#'
75		#' @return A `character` array of parameters.
76		#' @examples
77		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
78		#' block <- RcodeBlock$new()
79		#' block$get_available_params()
80		#'
81		get_available_params = function() {
82	5x	names(knitr::opts_chunk$get())
83		},
84		#' @description Create the `RcodeBlock` from a list.
85		#'
86		#' @param x (`named list`) with two fields `text` and `params`.
87		#' Use the `get_available_params` method to get all possible parameters.
88		#'
89		#' @return `self`, invisibly.
90		#' @examples
91		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
92		#' block <- RcodeBlock$new()
93		#' block$from_list(list(text = "sth", params = list()))
94		#'
95		from_list = function(x) {
96	3x	checkmate::assert_list(x)
97	3x	checkmate::assert_names(names(x), must.include = c("text", "params"))
98	3x	self$set_content(x$text)
99	3x	self$set_params(x$params)
100	3x	invisible(self)
101		},
102		#' @description Convert the `RcodeBlock` to a list.
103		#'
104		#' @return `named list` with a text and `params`.
105		#' @examples
106		#' RcodeBlock <- getFromNamespace("RcodeBlock", "teal.reporter")
107		#' block <- RcodeBlock$new()
108		#' block$to_list()
109		#'
110		to_list = function() {
111	3x	list(text = self$get_content(), params = self$get_params())
112		}
113		),
114		private = list(
115		content = character(0),
116		params = list()
117		),
118		lock_objects = TRUE,
119		lock_class = TRUE
120		)

1		#' @title `Reporter`: An `R6` class for managing report cards
2		#' @docType class
3		#' @description `r lifecycle::badge("experimental")`
4		#'
5		#' This `R6` class is designed to store and manage report cards,
6		#' facilitating the creation, manipulation, and serialization of report-related data.
7		#'
8		#' @export
9		#'
10		Reporter <- R6::R6Class( # nolint: object_name_linter.
11		classname = "Reporter",
12		public = list(
13		#' @description Initialize a `Reporter` object.
14		#'
15		#' @return Object of class `Reporter`, invisibly.
16		#' @examples
17		#' reporter <- Reporter$new()
18		#'
19		initialize = function() {
20	38x	private$cards <- list()
21	38x	private$reactive_add_card <- shiny::reactiveVal(0)
22	38x	invisible(self)
23		},
24		#' @description Append one or more `ReportCard` objects to the `Reporter`.
25		#'
26		#' @param cards (`ReportCard`) or a list of such objects
27		#' @return `self`, invisibly.
28		#' @examplesIf require("ggplot2")
29		#' library(ggplot2)
30		#' library(rtables)
31		#'
32		#' card1 <- ReportCard$new()
33		#'
34		#' card1$append_text("Header 2 text", "header2")
35		#' card1$append_text("A paragraph of default text")
36		#' card1$append_plot(
37		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
38		#' )
39		#'
40		#' card2 <- ReportCard$new()
41		#'
42		#' card2$append_text("Header 2 text", "header2")
43		#' card2$append_text("A paragraph of default text")
44		#' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
45		#' table_res2 <- build_table(lyt, airquality)
46		#' card2$append_table(table_res2)
47		#'
48		#' reporter <- Reporter$new()
49		#' reporter$append_cards(list(card1, card2))
50		append_cards = function(cards) {
51	36x	checkmate::assert_list(cards, "ReportCard")
52	36x	private$cards <- append(private$cards, cards)
53	36x	private$reactive_add_card(length(private$cards))
54	36x	invisible(self)
55		},
56		#' @description Retrieves all `ReportCard` objects contained in the `Reporter`.
57		#'
58		#' @return A (`list`) of [`ReportCard`] objects.
59		#' @examplesIf require("ggplot2")
60		#' library(ggplot2)
61		#' library(rtables)
62		#'
63		#' card1 <- ReportCard$new()
64		#'
65		#' card1$append_text("Header 2 text", "header2")
66		#' card1$append_text("A paragraph of default text")
67		#' card1$append_plot(
68		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
69		#' )
70		#'
71		#' card2 <- ReportCard$new()
72		#'
73		#' card2$append_text("Header 2 text", "header2")
74		#' card2$append_text("A paragraph of default text")
75		#' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
76		#' table_res2 <- build_table(lyt, airquality)
77		#' card2$append_table(table_res2)
78		#'
79		#' reporter <- Reporter$new()
80		#' reporter$append_cards(list(card1, card2))
81		#' reporter$get_cards()
82		get_cards = function() {
83	79x	private$cards
84		},
85		#' @description Compiles and returns all content blocks from the [`ReportCard`] in the `Reporter`.
86		#'
87		#' @param sep An optional separator to insert between each content block.
88		#' Default is a `NewpageBlock$new()`object.
89		#' @return `list()` list of `TableBlock`, `TextBlock`, `PictureBlock` and `NewpageBlock`.
90		#' @examplesIf require("ggplot2")
91		#' library(ggplot2)
92		#' library(rtables)
93		#'
94		#' card1 <- ReportCard$new()
95		#'
96		#' card1$append_text("Header 2 text", "header2")
97		#' card1$append_text("A paragraph of default text")
98		#' card1$append_plot(
99		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
100		#' )
101		#'
102		#' card2 <- ReportCard$new()
103		#'
104		#' card2$append_text("Header 2 text", "header2")
105		#' card2$append_text("A paragraph of default text")
106		#' lyt <- analyze(split_rows_by(basic_table(), "Day"), "Ozone", afun = mean)
107		#' table_res2 <- build_table(lyt, airquality)
108		#' card2$append_table(table_res2)
109		#'
110		#' reporter <- Reporter$new()
111		#' reporter$append_cards(list(card1, card2))
112		#' reporter$get_blocks()
113		#'
114		get_blocks = function(sep = NewpageBlock$new()) {
115	38x	blocks <- list()
116	38x	if (length(private$cards) > 0) {
117	35x	for (card_idx in head(seq_along(private$cards), -1)) {
118	10x	blocks <- append(blocks, append(private$cards[[card_idx]]$get_content(), sep))
119		}
120	35x	blocks <- append(blocks, private$cards[[length(private$cards)]]$get_content())
121		}
122	38x	blocks
123		},
124		#' @description Resets the `Reporter`, removing all [`ReportCard`] objects and metadata.
125		#'
126		#' @return `self`, invisibly.
127		#'
128		reset = function() {
129	20x	private$cards <- list()
130	20x	private$metadata <- list()
131	20x	private$reactive_add_card(0)
132	20x	invisible(self)
133		},
134		#' @description Removes specific `ReportCard` objects from the `Reporter` by their indices.
135		#'
136		#' @param ids (`integer(id)`) the indexes of cards
137		#' @return `self`, invisibly.
138		remove_cards = function(ids = NULL) {
139	1x	checkmate::assert(
140	1x	checkmate::check_null(ids),
141	1x	checkmate::check_integer(ids, min.len = 1, max.len = length(private$cards))
142		)
143	1x	if (!is.null(ids)) {
144	1x	private$cards <- private$cards[-ids]
145		}
146	1x	private$reactive_add_card(length(private$cards))
147	1x	invisible(self)
148		},
149		#' @description Swaps the positions of two `ReportCard` objects within the `Reporter`.
150		#'
151		#' @param start (`integer`) the index of the first card
152		#' @param end (`integer`) the index of the second card
153		#' @return `self`, invisibly.
154		swap_cards = function(start, end) {
155	6x	checkmate::assert(
156	6x	checkmate::check_integer(start,
157	6x	min.len = 1, max.len = 1, lower = 1, upper = length(private$cards)
158		),
159	6x	checkmate::check_integer(end,
160	6x	min.len = 1, max.len = 1, lower = 1, upper = length(private$cards)
161		),
162	6x	combine = "and"
163		)
164	6x	start_val <- private$cards[[start]]$clone()
165	6x	end_val <- private$cards[[end]]$clone()
166	6x	private$cards[[start]] <- end_val
167	6x	private$cards[[end]] <- start_val
168	6x	invisible(self)
169		},
170		#' @description Gets the current value of the reactive variable for adding cards.
171		#'
172		#' @return `reactive_add_card` current `numeric` value of the reactive variable.
173		#' @note The function has to be used in the shiny reactive context.
174		#' @examples
175		#' library(shiny)
176		#'
177		#' isolate(Reporter$new()$get_reactive_add_card())
178		get_reactive_add_card = function() {
179	23x	private$reactive_add_card()
180		},
181		#' @description Get the metadata associated with this `Reporter`.
182		#'
183		#' @return `named list` of metadata to be appended.
184		#' @examples
185		#' reporter <- Reporter$new()$append_metadata(list(sth = "sth"))
186		#' reporter$get_metadata()
187		#'
188		get_metadata = function() {
189	23x	private$metadata
190		},
191		#' @description Appends metadata to this `Reporter`.
192		#'
193		#' @param meta (`named list`) of metadata to be appended.
194		#' @return `self`, invisibly.
195		#' @examples
196		#' reporter <- Reporter$new()$append_metadata(list(sth = "sth"))
197		#' reporter$get_metadata()
198		#'
199		append_metadata = function(meta) {
200	20x	checkmate::assert_list(meta, names = "unique")
201	17x	checkmate::assert_true(length(meta) == 0 \|\| all(!names(meta) %in% names(private$metadata)))
202	16x	private$metadata <- append(private$metadata, meta)
203	16x	invisible(self)
204		},
205		#' @description
206		#' Reinitializes a `Reporter` instance by copying the report cards and metadata from another `Reporter`.
207		#' @param reporter (`Reporter`) instance to copy from.
208		#' @return invisibly self
209		#' @examples
210		#' reporter <- Reporter$new()
211		#' reporter$from_reporter(reporter)
212		from_reporter = function(reporter) {
213	8x	checkmate::assert_class(reporter, "Reporter")
214	8x	self$reset()
215	8x	self$append_cards(reporter$get_cards())
216	8x	self$append_metadata(reporter$get_metadata())
217	8x	invisible(self)
218		},
219		#' @description Convert a `Reporter` to a list and transfer any associated files to specified directory.
220		#' @param output_dir (`character(1)`) a path to the directory where files will be copied.
221		#' @return `named list` representing the `Reporter` instance, including version information,
222		#' metadata, and report cards.
223		#' @examples
224		#' reporter <- Reporter$new()
225		#' tmp_dir <- file.path(tempdir(), "testdir")
226		#' dir.create(tmp_dir)
227		#' reporter$to_list(tmp_dir)
228		to_list = function(output_dir) {
229	14x	checkmate::assert_directory_exists(output_dir)
230	12x	rlist <- list(name = "teal Reporter", version = "1", id = self$get_id(), cards = list())
231	12x	rlist[["metadata"]] <- self$get_metadata()
232	12x	for (card in self$get_cards()) {
233		# we want to have list names being a class names to indicate the class for $from_list
234	10x	card_class <- class(card)[1]
235	10x	u_card <- list()
236	10x	u_card[[card_class]] <- card$to_list(output_dir)
237	10x	rlist$cards <- c(rlist$cards, u_card)
238		}
239	12x	rlist
240		},
241		#' @description Reinitializes a `Reporter` from a list representation and associated files in a specified directory.
242		#' @param rlist (`named list`) representing a `Reporter` instance.
243		#' @param output_dir (`character(1)`) a path to the directory from which files will be copied.
244		#' @return `self`, invisibly.
245		#' @note if Report has an id when converting to JSON then It will be compared to the currently available one.
246		#' @examples
247		#' reporter <- Reporter$new()
248		#' tmp_dir <- file.path(tempdir(), "testdir")
249		#' unlink(tmp_dir, recursive = TRUE)
250		#' dir.create(tmp_dir)
251		#' reporter$from_list(reporter$to_list(tmp_dir), tmp_dir)
252		from_list = function(rlist, output_dir) {
253	6x	id <- self$get_id()
254	6x	checkmate::assert_list(rlist)
255	6x	checkmate::assert_directory_exists(output_dir)
256	6x	stopifnot("Report JSON has to have name slot equal to teal Reporter" = rlist$name == "teal Reporter")
257	6x	stopifnot("Loaded Report id has to match the current instance one" = rlist$id == id)
258	5x	if (rlist$version %in% c("1")) {
259	5x	new_cards <- list()
260	5x	cards_names <- names(rlist$cards)
261	5x	cards_names <- gsub("[.][0-9]*$", "", cards_names)
262	5x	for (iter_c in seq_along(rlist$cards)) {
263	5x	card_class <- cards_names[iter_c]
264	5x	card <- rlist$cards[[iter_c]]
265	5x	new_card <- eval(str2lang(card_class))$new()
266	5x	new_card$from_list(card, output_dir)
267	5x	new_cards <- c(new_cards, new_card)
268		}
269		} else {
270	!	stop(
271	!	sprintf(
272	!	"The provided %s reporter version is not supported.",
273	!	rlist$version
274		)
275		)
276		}
277	5x	self$reset()
278	5x	self$set_id(rlist$id)
279	5x	self$append_cards(new_cards)
280	5x	self$append_metadata(rlist$metadata)
281	5x	invisible(self)
282		},
283		#' @description Serializes the `Reporter` to a `JSON` file and copies any associated files to a specified directory.
284		#' @param output_dir (`character(1)`) a path to the directory where files will be copied, `JSON` and statics.
285		#' @return `output_dir` argument.
286		#' @examples
287		#' reporter <- Reporter$new()
288		#' tmp_dir <- file.path(tempdir(), "jsondir")
289		#' dir.create(tmp_dir)
290		#' reporter$to_jsondir(tmp_dir)
291		to_jsondir = function(output_dir) {
292	11x	checkmate::assert_directory_exists(output_dir)
293	9x	json <- self$to_list(output_dir)
294	9x	cat(
295	9x	jsonlite::toJSON(json, auto_unbox = TRUE, force = TRUE),
296	9x	file = file.path(output_dir, "Report.json")
297		)
298	9x	output_dir
299		},
300		#' @description Reinitializes a `Reporter` from a `JSON ` file and files in a specified directory.
301		#' @param output_dir (`character(1)`) a path to the directory with files, `JSON` and statics.
302		#' @return `self`, invisibly.
303		#' @note if Report has an id when converting to JSON then It will be compared to the currently available one.
304		#' @examples
305		#' reporter <- Reporter$new()
306		#' tmp_dir <- file.path(tempdir(), "jsondir")
307		#' dir.create(tmp_dir)
308		#' unlink(list.files(tmp_dir, recursive = TRUE))
309		#' reporter$to_jsondir(tmp_dir)
310		#' reporter$from_jsondir(tmp_dir)
311		from_jsondir = function(output_dir) {
312	4x	checkmate::assert_directory_exists(output_dir)
313	4x	dir_files <- list.files(output_dir)
314	4x	stopifnot("There has to be at least one file in the loaded directory" = length(dir_files) > 0)
315	4x	stopifnot("Report.json file has to be in the loaded directory" = "Report.json" %in% basename(dir_files))
316	4x	json <- jsonlite::read_json(file.path(output_dir, "Report.json"))
317	4x	self$reset()
318	4x	self$from_list(json, output_dir)
319	3x	invisible(self)
320		},
321		#' @description Set the `Reporter` id
322		#' Optionally add id to a `Reporter` which will be compared when it is rebuilt from a list.
323		#' The id is added to the downloaded file name.
324		#' @param id (`character(1)`) a Report id.
325		#' @return `self`, invisibly.
326		set_id = function(id) {
327	10x	private$id <- id
328	10x	invisible(self)
329		},
330		#' @description Get the `Reporter` id
331		#' @return `character(1)` the `Reporter` id.
332		get_id = function() {
333	23x	private$id
334		}
335		),
336		private = list(
337		id = "",
338		cards = list(),
339		metadata = list(),
340		reactive_add_card = NULL,
341		# @description The copy constructor.
342		#
343		# @param name the name of the field
344		# @param value the value of the field
345		# @return the new value of the field
346		#
347		deep_clone = function(name, value) {
348	23x	if (name == "cards") {
349	1x	lapply(value, function(card) card$clone(deep = TRUE))
350		} else {
351	22x	value
352		}
353		}
354		),
355		lock_objects = TRUE,
356		lock_class = TRUE
357		)

1		#' Mark strings for quotation in `yaml` serialization
2		#'
3		#' This function is designed for use with the `yaml` package to explicitly,
4		#' It adds an attribute to character strings, indicating that they should be serialized with double quotes.
5		#'
6		#' @param x (`character`)
7		#' @keywords internal
8		#' @examples
9		#' library(yaml)
10		#' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
11		#' yaml <- list(
12		#' author = yaml_quoted("NEST"),
13		#' title = yaml_quoted("Report"),
14		#' date = yaml_quoted("07/04/2019"),
15		#' output = list(pdf_document = list(keep_tex = TRUE))
16		#' )
17		#' as.yaml(yaml)
18		yaml_quoted <- function(x) {
19	2x	attr(x, "quoted") <- TRUE
20	2x	x
21		}
22
23		#' Create `markdown` header from `yaml` string
24		#'
25		#' This function wraps a `yaml`-formatted string in Markdown header delimiters.
26		#'
27		#' @param x (`character`) `yaml` formatted string.
28		#' @keywords internal
29		#' @examples
30		#' library(yaml)
31		#' yaml_quoted <- getFromNamespace("yaml_quoted", "teal.reporter")
32		#' yaml <- list(
33		#' author = yaml_quoted("NEST"),
34		#' title = yaml_quoted("Report"),
35		#' date = yaml_quoted("07/04/2019"),
36		#' output = list(pdf_document = list(keep_tex = TRUE))
37		#' )
38		#' md_header <- getFromNamespace("md_header", "teal.reporter")
39		#' md_header(as.yaml(yaml))
40		md_header <- function(x) {
41	14x	paste0("---\n", x, "---\n")
42		}
43
44		#' Convert `yaml` representation of a boolean strings to logical Values
45		#'
46		#' Converts a single `character` string representing a `yaml` boolean value into a logical value in `R`.
47		#'
48		#' @param input (`character(1)`)
49		#' @param name (`charcter(1)`)
50		#' @param pos_logi (`character`) vector of `yaml` values which should be treated as `TRUE`.
51		#' @param neg_logi (`character`) vector of `yaml` values which should be treated as `FALSE`.
52		#' @param silent (`logical(1)`) if to suppress the messages and warnings.
53		#' @return `input` argument or the appropriate `logical` value.
54		#' @keywords internal
55		#' @examples
56		#' conv_str_logi <- getFromNamespace("conv_str_logi", "teal.reporter")
57		#' conv_str_logi("TRUE")
58		#' conv_str_logi("True")
59		#'
60		#' conv_str_logi("off")
61		#' conv_str_logi("n")
62		#'
63		#' conv_str_logi("sth")
64		conv_str_logi <- function(input,
65		name = "",
66		pos_logi = c("TRUE", "true", "True", "yes", "y", "Y", "on"),
67		neg_logi = c("FALSE", "false", "False", "no", "n", "N", "off"),
68		silent = TRUE) {
69	18x	checkmate::assert_string(input)
70	17x	checkmate::assert_string(name)
71	17x	checkmate::assert_character(pos_logi)
72	17x	checkmate::assert_character(neg_logi)
73	17x	checkmate::assert_flag(silent)
74
75	17x	all_logi <- c(pos_logi, neg_logi)
76	17x	if (input %in% all_logi) {
77	15x	if (isFALSE(silent)) {
78	!	message(sprintf("The '%s' value should be a logical, so it is automatically converted.", input))
79		}
80	15x	input %in% pos_logi
81		} else {
82	2x	input
83		}
84		}
85
86		#' Get document output types from the `rmarkdown` package
87		#'
88		#' @description `r lifecycle::badge("experimental")`
89		#'
90		#' Retrieves vector of available document output types from the `rmarkdown` package,
91		#' such as `pdf_document`, `html_document`, etc.
92		#'
93		#' @return `character` vector.
94		#' @export
95		#' @examples
96		#' rmd_outputs()
97		rmd_outputs <- function() {
98	18x	rmarkdown_namespace <- asNamespace("rmarkdown")
99	18x	ls(rmarkdown_namespace)[grep("_document\|_presentation", ls(rmarkdown_namespace))]
100		}
101
102		#' Get document output arguments from the `rmarkdown` package
103		#'
104		#' @description `r lifecycle::badge("experimental")`
105		#'
106		#' Retrieves the arguments for a specified document output type from the `rmarkdown` package.
107		#'
108		#' @param output_name (`character`) `rmarkdown` output name.
109		#' @param default_values (`logical(1)`) if to return a default values for each argument.
110		#' @export
111		#' @examples
112		#' rmd_output_arguments("pdf_document")
113		#' rmd_output_arguments("pdf_document", TRUE)
114		rmd_output_arguments <- function(output_name, default_values = FALSE) {
115	17x	checkmate::assert_string(output_name)
116	17x	checkmate::assert_subset(output_name, rmd_outputs())
117
118	16x	rmarkdown_namespace <- asNamespace("rmarkdown")
119	16x	if (default_values) {
120	14x	formals(rmarkdown_namespace[[output_name]])
121		} else {
122	2x	names(formals(rmarkdown_namespace[[output_name]]))
123		}
124		}
125
126		#' Parse a named list to `yaml` header for an `Rmd` file
127		#'
128		#' @description `r lifecycle::badge("experimental")`
129		#'
130		#' Converts a named list into a `yaml` header for `Rmd`, handling output types and arguments
131		#' as defined in the `rmarkdown` package. This function simplifies the process of generating `yaml` headers.
132		#'
133		#' @details
134		#' This function processes a non-nested (flat) named list into a `yaml` header for an `Rmd` document.
135		#' It supports all standard `Rmd` `yaml` header fields, including `author`, `date`, `title`, `subtitle`,
136		#' `abstract`, `keywords`, `subject`, `description`, `category`, and `lang`.
137		#' Additionally, it handles `output` field types and arguments as defined in the `rmarkdown` package.
138		#'
139		#' @note Only non-nested lists are automatically parsed.
140		#' Nested lists require direct processing with `yaml::as.yaml`.
141		#'
142		#' @param input_list (`named list`) non nested with slots names and their values compatible with `Rmd` `yaml` header.
143		#' @param as_header (`logical(1)`) optionally wrap with result with the internal `md_header()`, default `TRUE`.
144		#' @param convert_logi (`logical(1)`) convert a character values to logical,
145		#' if they are recognized as quoted `yaml` logical values , default `TRUE`.
146		#' @param multi_output (`logical(1)`) multi `output` slots in the `input` argument, default `FALSE`.
147		#' @param silent (`logical(1)`) suppress messages and warnings, default `FALSE`.
148		#' @return `character` with `rmd_yaml_header` class,
149		#' result of [`yaml::as.yaml`], optionally wrapped with internal `md_header()`.
150		#' @export
151		#' @examples
152		#' # nested so using yaml::as.yaml directly
153		#' as_yaml_auto(
154		#' list(author = "", output = list(pdf_document = list(toc = TRUE)))
155		#' )
156		#'
157		#' # auto parsing for a flat list, like shiny input
158		#' input <- list(author = "", output = "pdf_document", toc = TRUE, keep_tex = TRUE)
159		#' as_yaml_auto(input)
160		#'
161		#' as_yaml_auto(list(author = "", output = "pdf_document", toc = TRUE, keep_tex = "TRUE"))
162		#'
163		#' as_yaml_auto(list(
164		#' author = "", output = "pdf_document", toc = TRUE, keep_tex = TRUE,
165		#' wrong = 2
166		#' ))
167		#'
168		#' as_yaml_auto(list(author = "", output = "pdf_document", toc = TRUE, keep_tex = 2),
169		#' silent = TRUE
170		#' )
171		#'
172		#' input <- list(author = "", output = "pdf_document", toc = TRUE, keep_tex = "True")
173		#' as_yaml_auto(input)
174		#' as_yaml_auto(input, convert_logi = TRUE, silent = TRUE)
175		#' as_yaml_auto(input, silent = TRUE)
176		#' as_yaml_auto(input, convert_logi = FALSE, silent = TRUE)
177		#'
178		#' as_yaml_auto(
179		#' list(
180		#' author = "", output = "pdf_document",
181		#' output = "html_document", toc = TRUE, keep_tex = TRUE
182		#' ),
183		#' multi_output = TRUE
184		#' )
185		#' as_yaml_auto(
186		#' list(
187		#' author = "", output = "pdf_document",
188		#' output = "html_document", toc = "True", keep_tex = TRUE
189		#' ),
190		#' multi_output = TRUE
191		#' )
192		as_yaml_auto <- function(input_list,
193		as_header = TRUE,
194		convert_logi = TRUE,
195		multi_output = FALSE,
196		silent = FALSE) {
197	16x	checkmate::assert_logical(as_header)
198	16x	checkmate::assert_logical(convert_logi)
199	16x	checkmate::assert_logical(silent)
200	16x	checkmate::assert_logical(multi_output)
201
202	16x	if (multi_output) {
203	1x	checkmate::assert_list(input_list, names = "named")
204		} else {
205	15x	checkmate::assert_list(input_list, names = "unique")
206		}
207
208	13x	is_nested <- function(x) any(unlist(lapply(x, is.list)))
209	13x	if (is_nested(input_list)) {
210	2x	result <- input_list
211		} else {
212	11x	result <- list()
213	11x	input_nams <- names(input_list)
214
215		# top fields
216	11x	top_fields <- c(
217	11x	"author", "date", "title", "subtitle", "abstract",
218	11x	"keywords", "subject", "description", "category", "lang"
219		)
220	11x	for (itop in top_fields) {
221	110x	if (itop %in% input_nams) {
222	20x	result[[itop]] <- switch(itop,
223	20x	date = as.character(input_list[[itop]]),
224	20x	input_list[[itop]]
225		)
226		}
227		}
228
229		# output field
230	11x	doc_types <- unlist(input_list[input_nams == "output"])
231	11x	if (length(doc_types)) {
232	11x	for (dtype in doc_types) {
233	12x	doc_type_args <- rmd_output_arguments(dtype, TRUE)
234	12x	doc_type_args_nams <- names(doc_type_args)
235	12x	any_output_arg <- any(input_nams %in% doc_type_args_nams)
236
237	12x	not_found_args <- setdiff(input_nams, c(doc_type_args_nams, top_fields, "output"))
238	12x	if (isFALSE(silent) && length(not_found_args) > 0 && isFALSE(multi_output)) {
239	1x	warning(sprintf("Not recognized and skipped arguments: %s", paste(not_found_args, collapse = ", ")))
240		}
241
242	12x	if (any_output_arg) {
243	11x	doc_list <- list()
244	11x	doc_list[[dtype]] <- list()
245	11x	for (e in intersect(input_nams, doc_type_args_nams)) {
246	17x	if (is.logical(doc_type_args[[e]]) && is.character(input_list[[e]])) {
247	1x	pos_logi <- c("TRUE", "true", "True", "yes", "y", "Y", "on")
248	1x	neg_logi <- c("FALSE", "false", "False", "no", "n", "N", "off")
249	1x	all_logi <- c(pos_logi, neg_logi)
250	1x	if (input_list[[e]] %in% all_logi && convert_logi) {
251	1x	input_list[[e]] <- conv_str_logi(input_list[[e]], e,
252	1x	pos_logi = pos_logi,
253	1x	neg_logi = neg_logi, silent = silent
254		)
255		}
256		}
257
258	17x	doc_list[[dtype]][[e]] <- input_list[[e]]
259		}
260	11x	result[["output"]] <- append(result[["output"]], doc_list)
261		} else {
262	1x	result[["output"]] <- append(result[["output"]], input_list[["output"]])
263		}
264		}
265		}
266		}
267
268	13x	result <- yaml::as.yaml(result)
269	13x	if (as_header) {
270	12x	result <- md_header(result)
271		}
272	13x	structure(result, class = "rmd_yaml_header")
273		}
274
275		#' Print method for the `yaml_header` class
276		#'
277		#' `r lifecycle::badge("experimental")`
278		#'
279		#' @param x (`rmd_yaml_header`) class object.
280		#' @param ... optional text.
281		#' @return `NULL`.
282		#' @exportS3Method
283		#' @examples
284		#' input <- list(author = "", output = "pdf_document", toc = TRUE, keep_tex = TRUE)
285		#' out <- as_yaml_auto(input)
286		#' out
287		#' print(out)
288		print.rmd_yaml_header <- function(x, ...) {
289	!	cat(x, ...)
290		}
291
292		#' Extract field from `yaml` text
293		#'
294		#' Parses `yaml` text, extracting the specified field. Returns list names if it's a list;
295		#' otherwise, the field itself.
296		#'
297		#' @param yaml_text (`rmd_yaml_header` or `character`) vector containing the `yaml` text.
298		#' @param field_name (`character`) the name of the field to extract.
299		#'
300		#' @return If the field is a list, it returns the names of elements in the list; otherwise,
301		#' it returns the extracted field.
302		#'
303		#' @keywords internal
304		get_yaml_field <- function(yaml_text, field_name) {
305	8x	checkmate::assert_multi_class(yaml_text, c("rmd_yaml_header", "character"))
306	8x	checkmate::assert_string(field_name)
307
308	8x	yaml_obj <- yaml::yaml.load(yaml_text)
309
310	8x	result <- yaml_obj[[field_name]]
311	8x	if (is.list(result)) {
312	5x	result <- names(result)
313		}
314	8x	result
315		}

1		#' @title `ReportCard`: An `R6` class for building report elements
2		#' @docType class
3		#'
4		#' @description `r lifecycle::badge("experimental")`
5		#'
6		#' This `R6` class that supports creating a report card containing text, plot, table and
7		#' metadata blocks that can be appended and rendered to form a report output from a `shiny` app.
8		#'
9		#' For more information about the various blocks, refer to the vignette:
10		#' `vignette("teal-reporter-blocks-overview", "teal.reporter")`.
11		#'
12		#' @export
13		#'
14		ReportCard <- R6::R6Class( # nolint: object_name_linter.
15		classname = "ReportCard",
16		public = list(
17		#' @description Initialize a `ReportCard` object.
18		#'
19		#' @return Object of class `ReportCard`, invisibly.
20		#' @examples
21		#' card <- ReportCard$new()
22		#'
23		initialize = function() {
24	65x	private$content <- list()
25	65x	private$metadata <- list()
26	65x	invisible(self)
27		},
28		#' @description Appends a table to this `ReportCard`.
29		#'
30		#' @param table A (`data.frame` or `rtables` or `TableTree` or `ElementaryTable` or `listing_df`)
31		#' that can be coerced into a table.
32		#' @return `self`, invisibly.
33		#' @examples
34		#' card <- ReportCard$new()$append_table(iris)
35		#'
36		append_table = function(table) {
37	4x	self$append_content(TableBlock$new(table))
38	4x	invisible(self)
39		},
40		#' @description Appends a html content to this `ReportCard`.
41		#'
42		#' @param content An object that can be rendered as a HTML content.
43		#' @return `self`, invisibly.
44		#' @examples
45		#' card <- ReportCard$new()$append_html(shiny::div("HTML Content"))
46		#'
47		append_html = function(content) {
48	1x	self$append_content(HTMLBlock$new(content))
49	1x	invisible(self)
50		},
51		#' @description Appends a plot to this `ReportCard`.
52		#'
53		#' @param plot (`ggplot` or `grob` or `trellis`) plot object.
54		#' @param dim (`numeric(2)`) width and height in pixels.
55		#' @return `self`, invisibly.
56		#' @examplesIf require("ggplot2")
57		#' library(ggplot2)
58		#'
59		#' card <- ReportCard$new()$append_plot(
60		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
61		#' )
62		#'
63		append_plot = function(plot, dim = NULL) {
64	19x	pb <- PictureBlock$new()
65	19x	if (!is.null(dim) && length(dim) == 2) {
66	1x	pb$set_dim(dim)
67		}
68	19x	pb$set_content(plot)
69	19x	self$append_content(pb)
70	19x	invisible(self)
71		},
72		#' @description Appends a text paragraph to this `ReportCard`.
73		#'
74		#' @param text (`character`) The text content to add.
75		#' @param style (`character(1)`) the style of the paragraph. One of: `r TextBlock$new()$get_available_styles()`.
76		#' @return `self`, invisibly.
77		#' @examples
78		#' card <- ReportCard$new()$append_text("A paragraph of default text")
79		#'
80		append_text = function(text, style = TextBlock$new()$get_available_styles()[1]) {
81	50x	self$append_content(TextBlock$new(text, style))
82	50x	invisible(self)
83		},
84		#' @description Appends an `R` code chunk to `ReportCard`.
85		#'
86		#' @param text (`character`) The `R` code to include.
87		#' @param ... Additional `rmarkdown` parameters for formatting the `R` code chunk.
88		#' @return `self`, invisibly.
89		#' @examples
90		#' card <- ReportCard$new()$append_rcode("2+2", echo = FALSE)
91		#'
92		append_rcode = function(text, ...) {
93	4x	self$append_content(RcodeBlock$new(text, ...))
94	4x	invisible(self)
95		},
96		#' @description Appends a generic `ContentBlock` to this `ReportCard`.
97		#'
98		#' @param content (`ContentBlock`) object.
99		#' @return `self`, invisibly.
100		#' @examples
101		#' NewpageBlock <- getFromNamespace("NewpageBlock", "teal.reporter")
102		#' card <- ReportCard$new()$append_content(NewpageBlock$new())
103		#'
104		append_content = function(content) {
105	100x	checkmate::assert_class(content, "ContentBlock")
106	100x	private$content <- append(private$content, content)
107	100x	invisible(self)
108		},
109		#' @description Get all content blocks from this `ReportCard`.
110		#'
111		#' @return `list()` list of `TableBlock`, `TextBlock` and `PictureBlock`.
112		#' @examples
113		#' card <- ReportCard$new()$append_text("Some text")$append_metadata("rc", "a <- 2 + 2")
114		#'
115		#' card$get_content()
116		#'
117		#'
118		get_content = function() {
119	87x	private$content
120		},
121		#' @description Clears all content and metadata from `ReportCard`.
122		#'
123		#' @return `self`, invisibly.
124		#'
125		reset = function() {
126	6x	private$content <- list()
127	6x	private$metadata <- list()
128	6x	invisible(self)
129		},
130		#' @description Get the metadata associated with `ReportCard`.
131		#'
132		#' @return `named list` list of elements.
133		#' @examples
134		#' card <- ReportCard$new()$append_text("Some text")$append_metadata("rc", "a <- 2 + 2")
135		#'
136		#' card$get_metadata()
137		#'
138		get_metadata = function() {
139	15x	private$metadata
140		},
141		#' @description Appends metadata to this `ReportCard`.
142		#'
143		#' @param key (`character(1)`) string specifying the metadata key.
144		#' @param value value associated with the metadata key.
145		#' @return `self`, invisibly.
146		#' @examplesIf require("ggplot2")
147		#' library(ggplot2)
148		#'
149		#' card <- ReportCard$new()$append_text("Some text")$append_plot(
150		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
151		#' )$append_text("Some text")$append_metadata(key = "lm",
152		#' value = lm(Ozone ~ Solar.R, airquality))
153		#' card$get_content()
154		#' card$get_metadata()
155		#'
156		append_metadata = function(key, value) {
157	16x	checkmate::assert_character(key, min.len = 0, max.len = 1)
158	13x	checkmate::assert_false(key %in% names(private$metadata))
159	12x	meta_list <- list()
160	12x	meta_list[[key]] <- value
161	11x	private$metadata <- append(private$metadata, meta_list)
162	11x	invisible(self)
163		},
164		#' @description Get the name of the `ReportCard`.
165		#'
166		#' @return `character` a card name.
167		#' @examples
168		#' ReportCard$new()$set_name("NAME")$get_name()
169		get_name = function() {
170	27x	private$name
171		},
172		#' @description Set the name of the `ReportCard`.
173		#'
174		#' @param name (`character(1)`) a card name.
175		#' @return `self`, invisibly.
176		#' @examples
177		#' ReportCard$new()$set_name("NAME")$get_name()
178		set_name = function(name) {
179	7x	checkmate::assert_character(name)
180	7x	private$name <- name
181	7x	invisible(self)
182		},
183		#' @description Convert the `ReportCard` to a list, including content and metadata.
184		#' @param output_dir (`character`) with a path to the directory where files will be copied.
185		#' @return (`named list`) a `ReportCard` representation.
186		#' @examplesIf require("ggplot2")
187		#' library(ggplot2)
188		#'
189		#' card <- ReportCard$new()$append_text("Some text")$append_plot(
190		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
191		#' )$append_text("Some text")$append_metadata(key = "lm",
192		#' value = lm(Ozone ~ Solar.R, airquality))
193		#' card$get_content()
194		#'
195		#' card$to_list(tempdir())
196		#'
197		to_list = function(output_dir) {
198	11x	new_blocks <- list()
199	11x	for (block in self$get_content()) {
200	37x	block_class <- class(block)[1]
201	37x	formal_args <- formalArgs(block$to_list)
202	37x	cblock <- if ("output_dir" %in% formal_args) {
203	13x	block$to_list(output_dir)
204		} else {
205	24x	block$to_list()
206		}
207	37x	new_block <- list()
208	37x	new_block[[block_class]] <- cblock
209	37x	new_blocks <- c(new_blocks, new_block)
210		}
211	11x	new_card <- list()
212	11x	new_card[["blocks"]] <- new_blocks
213	11x	new_card[["metadata"]] <- self$get_metadata()
214	11x	new_card[["name"]] <- self$get_name()
215	11x	new_card
216		},
217		#' @description Reconstructs the `ReportCard` from a list representation.
218		#' @param card (`named list`) a `ReportCard` representation.
219		#' @param output_dir (`character`) with a path to the directory where a file will be copied.
220		#' @return `self`, invisibly.
221		#' @examplesIf require("ggplot2")
222		#' library(ggplot2)
223		#'
224		#' card <- ReportCard$new()$append_text("Some text")$append_plot(
225		#' ggplot(iris, aes(x = Petal.Length)) + geom_histogram()
226		#' )$append_text("Some text")$append_metadata(key = "lm",
227		#' value = lm(Ozone ~ Solar.R, airquality))
228		#' card$get_content()
229		#'
230		#' ReportCard$new()$from_list(card$to_list(tempdir()), tempdir())
231		#'
232		from_list = function(card, output_dir) {
233	6x	self$reset()
234	6x	blocks <- card$blocks
235	6x	metadata <- card$metadata
236	6x	name <- card$name
237	6x	if (length(name) == 0) name <- character(0)
238	6x	blocks_names <- names(blocks)
239	6x	blocks_names <- gsub("[.][0-9]*$", "", blocks_names)
240	6x	for (iter_b in seq_along(blocks)) {
241	22x	block_class <- blocks_names[iter_b]
242	22x	block <- blocks[[iter_b]]
243	22x	instance <- private$dispatch_block(block_class)
244	22x	formal_args <- formalArgs(instance$new()$from_list)
245	22x	cblock <- if (all(c("x", "output_dir") %in% formal_args)) {
246	8x	instance$new()$from_list(block, output_dir)
247	22x	} else if ("x" %in% formal_args) {
248	14x	instance$new()$from_list(block)
249		} else {
250	!	instance$new()$from_list()
251		}
252	22x	self$append_content(cblock)
253		}
254	6x	for (meta in names(metadata)) {
255	!	self$append_metadata(meta, metadata[[meta]])
256		}
257	6x	self$set_name(name)
258	6x	invisible(self)
259		}
260		),
261		private = list(
262		content = list(),
263		metadata = list(),
264		name = character(0),
265		dispatch_block = function(block_class) {
266	22x	eval(str2lang(block_class))
267		},
268		# @description The copy constructor.
269		#
270		# @param name the name of the field
271		# @param value the value of the field
272		# @return the new value of the field
273		#
274		deep_clone = function(name, value) {
275	63x	if (name == "content") {
276	3x	lapply(value, function(content_block) {
277	5x	if (inherits(content_block, "R6")) {
278	5x	content_block$clone(deep = TRUE)
279		} else {
280	!	content_block
281		}
282		})
283		} else {
284	60x	value
285		}
286		}
287		),
288		lock_objects = TRUE,
289		lock_class = TRUE
290		)

1		#' @title `TextBlock`
2		#' @docType class
3		#' @description
4		#' Specialized `ContentBlock` for embedding styled text within reports.
5		#' It supports multiple styling options to accommodate various text roles,
6		#' such as headers or verbatim text, in the report content.
7		#'
8		#' @keywords internal
9		TextBlock <- R6::R6Class( # nolint: object_name_linter.
10		classname = "TextBlock",
11		inherit = ContentBlock,
12		public = list(
13		#' @description Initialize a `TextBlock` object.
14		#'
15		#' @details Constructs a `TextBlock` object with no content and the default style.
16		#'
17		#' @param content (`character`) a string assigned to this `TextBlock`
18		#' @param style (`character(1)`) one of: `"default"`, `"header2"`, `"header3"` `"verbatim"`
19		#'
20		#' @return Object of class `TextBlock`, invisibly.
21		#' @examples
22		#' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
23		#' block <- TextBlock$new()
24		#'
25		initialize = function(content = character(0), style = private$styles[1]) {
26	118x	super$set_content(content)
27	118x	self$set_style(style)
28	118x	invisible(self)
29		},
30		#' @description Sets content of this `TextBlock`.
31		#'
32		#' @param content (`any`) R object
33		#'
34		#' @return `self`, invisibly.
35		#' @examples
36		#' ContentBlock <- getFromNamespace("ContentBlock", "teal.reporter")
37		#' block <- ContentBlock$new()
38		#' block$set_content("Base64 encoded picture")
39		#'
40		set_content = function(content) {
41	24x	checkmate::assert_string(content)
42	23x	super$set_content(content)
43		},
44		#' @description Sets the style of this `TextBlock`.
45		#'
46		#' @details The style has bearing on the rendering of this block.
47		#'
48		#' @param style (`character(1)`) one of: `"default"`, `"header2"`, `"header3"` `"verbatim"`
49		#'
50		#' @return `self`, invisibly.
51		#' @examples
52		#' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
53		#' block <- TextBlock$new()
54		#' block$set_style("header2")
55		#'
56		set_style = function(style) {
57	140x	private$style <- match.arg(style, private$styles)
58	139x	invisible(self)
59		},
60		#' @description Get the style of this `TextBlock`.
61		#'
62		#' @return `character(1)` the style of this `TextBlock`.
63		#' @examples
64		#' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
65		#' block <- TextBlock$new()
66		#' block$get_style()
67		#'
68		get_style = function() {
69	67x	private$style
70		},
71		#' @description Get available an array of styles available to this `TextBlock`.
72		#'
73		#' @return A `character` array of styles.
74		#' @examples
75		#' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
76		#' block <- TextBlock$new()
77		#' block$get_available_styles()
78		#'
79		get_available_styles = function() {
80	23x	private$styles
81		},
82		#' @description Create the `TextBlock` from a list.
83		#'
84		#' @param x (`named list`) with two fields `text` and `style`.
85		#' Use the `get_available_styles` method to get all possible styles.
86		#'
87		#' @return `self`, invisibly.
88		#' @examples
89		#' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
90		#' block <- TextBlock$new()
91		#' block$from_list(list(text = "sth", style = "default"))
92		#'
93		from_list = function(x) {
94	14x	checkmate::assert_list(x)
95	14x	checkmate::assert_names(names(x), must.include = c("text", "style"))
96	14x	self$set_content(x$text)
97	14x	self$set_style(x$style)
98	14x	invisible(self)
99		},
100		#' @description Convert the `TextBlock` to a list.
101		#'
102		#' @return `named list` with a text and style.
103		#' @examples
104		#' TextBlock <- getFromNamespace("TextBlock", "teal.reporter")
105		#' block <- TextBlock$new()
106		#' block$to_list()
107		#'
108		to_list = function() {
109	24x	list(text = self$get_content(), style = self$get_style())
110		}
111		),
112		private = list(
113		content = character(0),
114		style = character(0),
115		styles = c("default", "header2", "header3", "verbatim")
116		),
117		lock_objects = TRUE,
118		lock_class = TRUE
119		)

1		#' @title `HTMLBlock`
2		#' @docType class
3		#' @description
4		#' Specialized `FileBlock` for managing HTML content in reports.
5		#' It's designed to handle various HTML content, and render the report as HTML,
6		#' however `htmlwidgets` objects can also be rendered to static document-ready format.
7		#'
8		#' @keywords internal
9		HTMLBlock <- R6::R6Class( # nolint: object_name_linter.
10		classname = "HTMLBlock",
11		inherit = ContentBlock,
12		public = list(
13		#' @description Initialize a `HTMLBlock` object.
14		#'
15		#' @param content An object that can be rendered as a HTML content assigned to
16		#' this `HTMLBlock`
17		#'
18		#' @return Object of class `HTMLBlock`, invisibly.
19		initialize = function(content) {
20	12x	if (!missing(content)) {
21	7x	checkmate::assert_multi_class(content, private$supported_types)
22	6x	self$set_content(content)
23		}
24	11x	invisible(self)
25		},
26
27		#' @description Create the `HTMLBlock` from a list.
28		#'
29		#' @param x (`named list`) with a single field `content` containing `shiny.tag`,
30		#' `shiny.tag.list` or `htmlwidget`.
31		#'
32		#' @return `self`, invisibly.
33		#' @examples
34		#' HTMLBlock <- getFromNamespace("HTMLBlock", "teal.reporter")
35		#' block <- HTMLBlock$new()
36		#' block$from_list(list(content = shiny::tags$div("test")))
37		#'
38		from_list = function(x) {
39	2x	checkmate::assert_list(x, types = private$supported_types)
40	2x	checkmate::assert_names(names(x), must.include = "content")
41	2x	self$set_content(x$content)
42	2x	invisible(self)
43		},
44
45		#' @description Convert the `HTMLBlock` to a list.
46		#'
47		#' @return `named list` with a text and style.
48		#' @examples
49		#' HTMLBlock <- getFromNamespace("HTMLBlock", "teal.reporter")
50		#' block <- HTMLBlock$new(shiny::tags$div("test"))
51		#' block$to_list()
52		#'
53		to_list = function() {
54	2x	list(content = self$get_content())
55		}
56		),
57		private = list(
58		supported_types = c("shiny.tag", "shiny.tag.list", "htmlwidget")
59		),
60		lock_objects = TRUE,
61		lock_class = TRUE
62		)

1		#' Add card button module
2		#'
3		#' @description `r lifecycle::badge("experimental")`
4		#'
5		#' Provides a button to add views/cards to a report.
6		#'
7		#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
8		#'
9		#' @details
10		#' The `card_fun` function is designed to create a new `ReportCard` instance and optionally customize it:
11		#' - The `card` parameter allows for specifying a custom or default `ReportCard` instance.
12		#' - Use the `comment` parameter to add a comment to the card via `card$append_text()` - if `card_fun` does not
13		#' have the `comment` parameter, then `comment` from `Add Card UI` module will be added at the end of the content of the
14		#' card.
15		#' - The `label` parameter enables customization of the card's name and its content through `card$append_text()`-
16		#' if `card_fun` does not have the `label` parameter, then card name will be set to the name passed in
17		#' `Add Card UI` module, but no text will be added to the content of the `card`.
18		#'
19		#' This module supports using a subclass of [`ReportCard`] for added flexibility.
20		#' A subclass instance should be passed as the default value of
21		#' the `card` argument in the `card_fun` function.
22		#' See below:
23		#' ```{r}
24		#' CustomReportCard <- R6::R6Class(
25		#' classname = "CustomReportCard",
26		#' inherit = teal.reporter::ReportCard
27		#' )
28		#'
29		#' custom_function <- function(card = CustomReportCard$new()) {
30		#' card
31		#' }
32		#' ```
33		#' @name add_card_button
34		#'
35		#' @param id (`character(1)`) this `shiny` module's id.
36		#' @param reporter (`Reporter`) instance.
37		#' @param card_fun (`function`) which returns a [`ReportCard`] instance. See `Details`.
38		#'
39		#' @return `NULL`.
40		NULL
41
42		#' @rdname add_card_button
43		#' @export
44		add_card_button_ui <- function(id) {
45	2x	ns <- shiny::NS(id)
46
47		# Buttons with custom css and
48		# js code to disable the add card button when clicked to prevent multi-clicks
49	2x	shiny::tagList(
50	2x	shiny::singleton(
51	2x	shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
52		),
53	2x	shiny::singleton(
54	2x	shiny::tags$head(
55	2x	shiny::tags$script(
56	2x	shiny::HTML(
57	2x	sprintf(
58		'
59	2x	$(document).ready(function(event) {
60	2x	$("body").on("click", "#%s", function() {
61	2x	$(this).addClass("disabled");
62		})
63		})',
64	2x	ns("add_card_ok")
65		)
66		)
67		)
68		)
69		),
70	2x	shiny::actionButton(
71	2x	ns("add_report_card_button"),
72	2x	title = "Add Card",
73	2x	class = "teal-reporter simple_report_button btn-primary",
74	2x	`data-val` = shiny::restoreInput(id = ns("add_report_card_button"), default = NULL),
75	2x	shiny::tags$span(
76	2x	shiny::icon("plus")
77		)
78		)
79		)
80		}
81
82		#' @rdname add_card_button
83		#' @export
84		add_card_button_srv <- function(id, reporter, card_fun) {
85	13x	checkmate::assert_function(card_fun)
86	13x	checkmate::assert_class(reporter, "Reporter")
87	13x	checkmate::assert_subset(names(formals(card_fun)), c("card", "comment", "label"), empty.ok = TRUE)
88
89	13x	shiny::moduleServer(id, function(input, output, session) {
90	13x	shiny::setBookmarkExclude(c(
91	13x	"add_report_card_button", "download_button", "reset_reporter",
92	13x	"add_card_ok", "download_data", "reset_reporter_ok",
93	13x	"label", "comment"
94		))
95
96	13x	ns <- session$ns
97
98	13x	add_modal <- function() {
99	11x	shiny::div(
100	11x	class = "teal-widgets reporter-modal",
101	11x	shiny::modalDialog(
102	11x	easyClose = TRUE,
103	11x	shiny::tags$h3("Add a Card to the Report"),
104	11x	shiny::tags$hr(),
105	11x	shiny::textInput(
106	11x	ns("label"),
107	11x	"Card Name",
108	11x	value = "",
109	11x	placeholder = "Add the card title here",
110	11x	width = "100%"
111		),
112	11x	shiny::textAreaInput(
113	11x	ns("comment"),
114	11x	"Comment",
115	11x	value = "",
116	11x	placeholder = "Add a comment here...",
117	11x	width = "100%"
118		),
119	11x	shiny::tags$script(
120	11x	shiny::HTML(
121	11x	sprintf(
122		"
123	11x	$('#shiny-modal').on('shown.bs.modal', () => {
124	11x	$('#%s').focus()
125		})
126		",
127	11x	ns("label")
128		)
129		)
130		),
131	11x	footer = shiny::div(
132	11x	shiny::tags$button(
133	11x	type = "button",
134	11x	class = "btn btn-secondary",
135	11x	`data-dismiss` = "modal",
136	11x	`data-bs-dismiss` = "modal",
137	11x	NULL,
138	11x	"Cancel"
139		),
140	11x	shiny::tags$button(
141	11x	id = ns("add_card_ok"),
142	11x	type = "button",
143	11x	class = "btn btn-primary action-button",
144	11x	`data-val` = shiny::restoreInput(id = ns("add_card_ok"), default = NULL),
145	11x	NULL,
146	11x	"Add Card"
147		)
148		)
149		)
150		)
151		}
152
153	13x	shiny::observeEvent(input$add_report_card_button, {
154	11x	shiny::showModal(add_modal())
155		})
156
157		# the add card button is disabled when clicked to prevent multi-clicks
158		# please check the ui part for more information
159	13x	shiny::observeEvent(input$add_card_ok, {
160	11x	card_fun_args_nams <- names(formals(card_fun))
161	11x	has_card_arg <- "card" %in% card_fun_args_nams
162	11x	has_comment_arg <- "comment" %in% card_fun_args_nams
163	11x	has_label_arg <- "label" %in% card_fun_args_nams
164
165	11x	arg_list <- list()
166
167	11x	if (has_comment_arg) {
168	4x	arg_list <- c(arg_list, list(comment = input$comment))
169		}
170	11x	if (has_label_arg) {
171	!	arg_list <- c(arg_list, list(label = input$label))
172		}
173
174	11x	if (has_card_arg) {
175		# The default_card is defined here because formals() returns a pairedlist object
176		# of formal parameter names and their default values. The values are missing
177		# if not defined and the missing check does not work if supplied formals(card_fun)[[1]]
178	8x	default_card <- formals(card_fun)$card
179	8x	card <- `if`(
180	8x	missing(default_card),
181	8x	ReportCard$new(),
182	8x	eval(default_card, envir = environment(card_fun))
183		)
184	8x	arg_list <- c(arg_list, list(card = card))
185		}
186
187	11x	card <- try(do.call(card_fun, arg_list))
188
189	11x	if (inherits(card, "try-error")) {
190	3x	msg <- paste0(
191	3x	"The card could not be added to the report. ",
192	3x	"Have the outputs for the report been created yet? If not please try again when they ",
193	3x	"are ready. Otherwise contact your application developer"
194		)
195	3x	warning(msg)
196	3x	shiny::showNotification(
197	3x	msg,
198	3x	type = "error"
199		)
200		} else {
201	8x	checkmate::assert_class(card, "ReportCard")
202	8x	if (!has_comment_arg && length(input$comment) > 0 && input$comment != "") {
203	1x	card$append_text("Comment", "header3")
204	1x	card$append_text(input$comment)
205		}
206
207	8x	if (!has_label_arg && length(input$label) == 1 && input$label != "") {
208	!	card$set_name(input$label)
209		}
210
211	8x	reporter$append_cards(list(card))
212	8x	shiny::showNotification(sprintf("The card added successfully."), type = "message")
213	8x	shiny::removeModal()
214		}
215		})
216		})
217		}

1		#' User Interface to Load `Reporter`
2		#' @description `r lifecycle::badge("experimental")`
3		#' Button to upload `ReporterCard`(s) to the `Reporter`.
4		#'
5		#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
6		#' @param id `character(1)` this `shiny` module's id.
7		#' @return `shiny::tagList`
8		#' @export
9		report_load_ui <- function(id) {
10	2x	ns <- shiny::NS(id)
11
12	2x	shiny::tagList(
13	2x	shiny::singleton(
14	2x	shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
15		),
16	2x	shiny::actionButton(
17	2x	ns("reporter_load"),
18	2x	class = "teal-reporter simple_report_button btn-primary",
19	2x	title = "Load",
20	2x	shiny::tags$span(
21	2x	shiny::icon("upload")
22		)
23		)
24		)
25		}
26
27		#' Server to Load `Reporter`
28		#' @description `r lifecycle::badge("experimental")`
29		#' Server to load `ReporterCard`(s) to the `Reporter`
30		#'
31		#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
32		#'
33		#' @param id `character(1)` this `shiny` module's id.
34		#' @param reporter [`Reporter`] instance.
35		#'
36		#' @return `shiny::moduleServer`
37		#' @export
38		report_load_srv <- function(id, reporter) {
39	5x	checkmate::assert_class(reporter, "Reporter")
40
41	5x	shiny::moduleServer(
42	5x	id,
43	5x	function(input, output, session) {
44	5x	shiny::setBookmarkExclude(c("reporter_load_main", "reporter_load"))
45	5x	ns <- session$ns
46
47	5x	archiver_modal <- function() {
48	2x	nr_cards <- length(reporter$get_cards())
49	2x	shiny::div(
50	2x	class = "teal-widgets reporter-modal",
51	2x	shiny::modalDialog(
52	2x	easyClose = TRUE,
53	2x	shiny::tags$h3("Load the Report"),
54	2x	shiny::tags$hr(),
55	2x	shiny::fileInput(ns("archiver_zip"), "Choose saved Reporter file to Load (a zip file)",
56	2x	multiple = FALSE,
57	2x	accept = c(".zip")
58		),
59	2x	footer = shiny::div(
60	2x	shiny::tags$button(
61	2x	type = "button",
62	2x	class = "btn btn-danger",
63	2x	`data-dismiss` = "modal",
64	2x	`data-bs-dismiss` = "modal",
65	2x	NULL,
66	2x	"Cancel"
67		),
68	2x	shiny::tags$button(
69	2x	id = ns("reporter_load_main"),
70	2x	type = "button",
71	2x	class = "btn btn-primary action-button",
72	2x	NULL,
73	2x	"Load"
74		)
75		)
76		)
77		)
78		}
79
80	5x	shiny::observeEvent(input$reporter_load, {
81	2x	shiny::showModal(archiver_modal())
82		})
83
84	5x	shiny::observeEvent(input$reporter_load_main, {
85	2x	load_json_report(reporter, input$archiver_zip[["datapath"]], input$archiver_zip[["name"]])
86	2x	shiny::removeModal()
87		})
88		}
89		)
90		}
91
92		#' @keywords internal
93		load_json_report <- function(reporter, zip_path, filename) {
94	2x	tmp_dir <- tempdir()
95	2x	output_dir <- file.path(tmp_dir, sprintf("report_load_%s", gsub("[.]", "", format(Sys.time(), "%Y%m%d%H%M%OS4"))))
96	2x	dir.create(path = output_dir)
97	2x	if (!is.null(zip_path) && grepl("report_", filename)) {
98	2x	tryCatch(
99	2x	expr = zip::unzip(zip_path, exdir = output_dir, junkpaths = TRUE),
100	2x	warning = function(cond) {
101	!	print(cond)
102	!	shiny::showNotification(
103	!	ui = "Unzipping folder warning!",
104	!	action = "Please contact app developer",
105	!	type = "warning"
106		)
107		},
108	2x	error = function(cond) {
109	!	print(cond)
110	!	shiny::showNotification(
111	!	ui = "Unzipping folder error!",
112	!	action = "Please contact app developer",
113	!	type = "error"
114		)
115		}
116		)
117	2x	tryCatch(
118	2x	reporter$from_jsondir(output_dir),
119	2x	warning = function(cond) {
120	!	print(cond)
121	!	shiny::showNotification(
122	!	ui = "Loading reporter warning!",
123	!	action = "Please contact app developer",
124	!	type = "warning"
125		)
126		},
127	2x	error = function(cond) {
128	1x	print(cond)
129	1x	shiny::showNotification(
130	1x	ui = "Loading reporter error!",
131	1x	action = "Please contact app developer",
132	1x	type = "error"
133		)
134		}
135		)
136		} else {
137	!	shiny::showNotification("Failed to load the Reporter file.", type = "error")
138		}
139		}

1		#' @title `TableBlock`
2		#' @docType class
3		#' @description
4		#' Specialized `FileBlock` for managing table content in reports.
5		#' It's designed to handle various table formats, converting them into a consistent,
6		#' document-ready format (e.g., `flextable`) for inclusion in reports.
7		#'
8		#' @keywords internal
9		TableBlock <- R6::R6Class( # nolint: object_name_linter.
10		classname = "TableBlock",
11		inherit = FileBlock,
12		public = list(
13		#' @description Initialize a `TableBlock` object.
14		#'
15		#' @param table (`data.frame` or `rtables` or `TableTree` or `ElementaryTable` or `listing_df`) a table assigned to
16		#' this `TableBlock`
17		#'
18		#' @return Object of class `TableBlock`, invisibly.
19		initialize = function(table) {
20	26x	if (!missing(table)) {
21	4x	self$set_content(table)
22		}
23	26x	invisible(self)
24		},
25		#' @description Sets content of this `TableBlock`.
26		#'
27		#' @details Raises error if argument is not a table-like object.
28		#'
29		#' @param content (`data.frame` or `rtables` or `TableTree` or `ElementaryTable` or `listing_df`)
30		#' a table assigned to this `TableBlock`
31		#'
32		#' @return `self`, invisibly.
33		#' @examples
34		#' TableBlock <- getFromNamespace("TableBlock", "teal.reporter")
35		#' block <- TableBlock$new()
36		#' block$set_content(iris)
37		#'
38		set_content = function(content) {
39	13x	checkmate::assert_multi_class(content, private$supported_tables)
40	12x	content <- to_flextable(content)
41	12x	path <- tempfile(fileext = ".rds")
42	12x	saveRDS(content, file = path)
43	12x	super$set_content(path)
44	12x	invisible(self)
45		}
46		),
47		private = list(
48		supported_tables = c("data.frame", "rtables", "TableTree", "ElementaryTable", "listing_df")
49		),
50		lock_objects = TRUE,
51		lock_class = TRUE
52		)

1		#' Get bootstrap current version
2		#' @note will work properly mainly inside a tag `.renderHook`
3		#' @keywords internal
4		get_bs_version <- function() {
5	15x	theme <- bslib::bs_current_theme()
6	15x	if (bslib::is_bs_theme(theme)) {
7	!	bslib::theme_version(theme)
8		} else {
9	15x	"3"
10		}
11		}
12
13		#' Panel group widget
14		#'
15		#' `r lifecycle::badge("experimental")`
16		#'
17		#' @param title (`character`) title of panel
18		#' @param ... content of panel
19		#' @param collapsed (`logical`, optional)
20		#' whether to initially collapse panel
21		#' @param input_id (`character`, optional)
22		#' name of the panel item element. If supplied, this will register a shiny input variable that
23		#' indicates whether the panel item is open or collapsed and is accessed with `input$input_id`.
24		#'
25		#' @return `shiny.tag`.
26		#'
27		#' @keywords internal
28		panel_item <- function(title, ..., collapsed = TRUE, input_id = NULL) {
29	1x	stopifnot(checkmate::test_character(title, len = 1) \|\| inherits(title, c("shiny.tag", "shiny.tag.list", "html")))
30	1x	checkmate::assert_flag(collapsed)
31	1x	checkmate::assert_string(input_id, null.ok = TRUE)
32
33	1x	div_id <- paste0(input_id, "_div")
34	1x	panel_id <- paste0(input_id, "_panel_body_", sample(1:10000, 1))
35
36
37	1x	shiny::tags$div(.renderHook = function(res_tag) {
38	!	bs_version <- get_bs_version()
39
40		# alter tag structure
41	!	if (bs_version == "3") {
42	!	res_tag$children <- list(
43	!	shiny::tags$div(
44	!	class = "panel panel-default",
45	!	shiny::tags$div(
46	!	id = div_id,
47	!	class = paste("panel-heading", ifelse(collapsed, "collapsed", "")),
48	!	`data-toggle` = "collapse",
49	!	href = paste0("#", panel_id),
50	!	`aria-expanded` = ifelse(collapsed, "false", "true"),
51	!	shiny::icon("angle-down", class = "dropdown-icon"),
52	!	shiny::tags$label(
53	!	class = "panel-title inline",
54	!	title,
55		)
56		),
57	!	shiny::tags$div(
58	!	class = paste("panel-collapse collapse", ifelse(collapsed, "", "in")),
59	!	id = panel_id,
60	!	shiny::tags$div(
61	!	class = "panel-body",
62		...
63		)
64		)
65		)
66		)
67	!	} else if (bs_version %in% c("4", "5")) {
68	!	res_tag$children <- list(
69	!	shiny::tags$div(
70	!	class = "card my-2",
71	!	shiny::tags$div(
72	!	class = "card-header",
73	!	shiny::tags$div(
74	!	class = ifelse(collapsed, "collapsed", ""),
75		# bs4
76	!	`data-toggle` = "collapse",
77		# bs5
78	!	`data-bs-toggle` = "collapse",
79	!	href = paste0("#", panel_id),
80	!	`aria-expanded` = ifelse(collapsed, "false", "true"),
81	!	shiny::icon("angle-down", class = "dropdown-icon"),
82	!	shiny::tags$label(
83	!	class = "card-title inline",
84	!	title,
85		)
86		)
87		),
88	!	shiny::tags$div(
89	!	id = panel_id,
90	!	class = paste("collapse", ifelse(collapsed, "", "show")),
91	!	shiny::tags$div(
92	!	class = "card-body",
93		...
94		)
95		)
96		)
97		)
98		} else {
99	!	stop("Bootstrap 3, 4, and 5 are supported.")
100		}
101
102	!	shiny::tagList(
103	!	shiny::singleton(
104	!	shiny::tags$head(
105	!	shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter"))
106		)
107		),
108	!	res_tag
109		)
110		})
111		}
112
113		#' Convert content into a `flextable`
114		#'
115		#' Converts supported table formats into a `flextable` for enhanced formatting and presentation.
116		#'
117		#' Function merges cells with `colspan` > 1,
118		#' aligns columns to the center and row names to the left,
119		#' indents the row names by 10 times indentation.
120		#'
121		#' @param content Supported formats: `data.frame`, `rtables`, `TableTree`, `ElementaryTable`, `listing_df`
122		#'
123		#' @return `flextable`.
124		#'
125		#' @keywords internal
126		to_flextable <- function(content) {
127	16x	if (inherits(content, c("rtables", "TableTree", "ElementaryTable"))) {
128	3x	ft <- rtables.officer::tt_to_flextable(content)
129	13x	} else if (inherits(content, "listing_df")) {
130	1x	mf <- rlistings::matrix_form(content)
131	1x	nr_header <- attr(mf, "nrow_header")
132	1x	df <- as.data.frame(mf$strings[seq(nr_header + 1, nrow(mf$strings)), , drop = FALSE])
133	1x	header_df <- as.data.frame(mf$strings[seq_len(nr_header), , drop = FALSE])
134
135	1x	ft <- rtables::df_to_tt(df)
136	1x	if (length(mf$main_title) != 0) {
137	!	rtables::main_title(ft) <- mf$main_title
138		}
139	1x	rtables::subtitles(ft) <- mf$subtitles
140	1x	rtables::main_footer(ft) <- mf$main_footer
141	1x	rtables::prov_footer(ft) <- mf$prov_footer
142	1x	rtables::header_section_div(ft) <- mf$header_section_div
143	1x	ft <- rtables.officer::tt_to_flextable(ft, total_width = c(grDevices::pdf.options()$width - 1))
144	12x	} else if (inherits(content, "data.frame")) {
145	11x	ft <- rtables.officer::tt_to_flextable(
146	11x	rtables::df_to_tt(content)
147		)
148		} else {
149	1x	stop(paste0("Unsupported class `(", format(class(content)), ")` when exporting table"))
150		}
151
152	15x	ft
153		}
154
155		#' Get the merge index for a single span.
156		#' This function retrieves the merge index for a single span,
157		#' which is used in merging cells.
158		#' @noRd
159		#' @keywords internal
160		get_merge_index_single <- function(span) {
161	!	ret <- list()
162	!	j <- 1
163	!	while (j < length(span)) {
164	!	if (span[j] != 1) {
165	!	ret <- c(ret, list(seq(j, j + span[j] - 1)))
166		}
167	!	j <- j + span[j]
168		}
169	!	return(ret)
170		}
171
172		#' Divide text block into smaller blocks
173		#'
174		#' Split a text block into smaller blocks with a specified number of lines.
175		#'
176		#' A single character string containing a text block of multiple lines (separated by `\n`)
177		#' is split into multiple strings with n or less lines each.
178		#'
179		#' @param x (`character`) string containing the input block of text
180		#' @param n (`integer`) number of lines per block
181		#'
182		#' @return
183		#' List of character strings with up to `n` lines in each element.
184		#'
185		#' @keywords internal
186		split_text_block <- function(x, n) {
187	2x	checkmate::assert_string(x)
188	2x	checkmate::assert_integerish(n, lower = 1L, len = 1L)
189
190	2x	lines <- strsplit(x, "\n")[[1]]
191
192	2x	if (length(lines) <= n) {
193	1x	return(list(x))
194		}
195
196	1x	nblocks <- ceiling(length(lines) / n)
197	1x	ind <- rep(1:nblocks, each = n)[seq_along(lines)]
198	1x	unname(lapply(split(lines, ind), paste, collapse = "\n"))
199		}
200
201		#' Retrieve text details for global_knitr options
202		#' This function returns a character string describing the default settings for the global_knitr options.
203		#' @noRd
204		#' @keywords internal
205		global_knitr_details <- function() {
206	!	paste0(
207	!	c(
208	!	" To access the default values for the `global_knitr` parameter,",
209	!	" use `getOption('teal.reporter.global_knitr')`. These defaults include:",
210	!	" - `echo = TRUE`",
211	!	" - `tidy.opts = list(width.cutoff = 60)`",
212	!	" - `tidy = TRUE` if `formatR` package is installed, `FALSE` otherwise"
213		),
214	!	collapse = "\n"
215		)
216		}

1		#' @title `FileBlock`
2		#' @docType class
3		#' @description
4		#' `FileBlock` manages file-based content in a report,
5		#' ensuring appropriate handling of content files.
6		#'
7		#' @keywords internal
8		FileBlock <- R6::R6Class( # nolint: object_name_linter.
9		classname = "FileBlock",
10		inherit = ContentBlock,
11		public = list(
12		#' @description Finalize the `FileBlock`.
13		#'
14		#' @details Removes the temporary file created in the constructor.
15		finalize = function() {
16	86x	try(unlink(super$get_content()))
17		},
18		#' @description Create the `FileBlock` from a list.
19		#' The list should contain one named field, `"basename"`.
20		#'
21		#' @param x (`named list`) with one field `"basename"`, a name of the file.
22		#' @param output_dir (`character`) with a path to the directory where a file will be copied.
23		#'
24		#' @return `self`, invisibly.
25		#' @examples
26		#' FileBlock <- getFromNamespace("FileBlock", "teal.reporter")
27		#' block <- FileBlock$new()
28		#' file_path <- tempfile(fileext = ".png")
29		#' saveRDS(iris, file_path)
30		#' block$from_list(list(basename = basename(file_path)), dirname(file_path))
31		#'
32		from_list = function(x, output_dir) {
33	11x	checkmate::assert_list(x)
34	11x	checkmate::assert_names(names(x), must.include = "basename")
35	11x	path <- file.path(output_dir, x$basename)
36	11x	file_type <- paste0(".", tools::file_ext(path))
37	11x	checkmate::assert_file_exists(path, extension = file_type)
38	11x	new_file_path <- tempfile(fileext = file_type)
39	11x	file.copy(path, new_file_path)
40	11x	super$set_content(new_file_path)
41	11x	invisible(self)
42		},
43		#' @description Convert the `FileBlock` to a list.
44		#'
45		#' @param output_dir (`character`) with a path to the directory where a file will be copied.
46		#'
47		#' @return `named list` with a `basename` of the file.
48		#' @examples
49		#' FileBlock <- getFromNamespace("FileBlock", "teal.reporter")
50		#' block <- FileBlock$new()
51		#' block$to_list(tempdir())
52		#'
53		to_list = function(output_dir) {
54	21x	base_name <- basename(super$get_content())
55	21x	file.copy(super$get_content(), file.path(output_dir, base_name))
56	21x	list(basename = base_name)
57		}
58		),
59		private = list(
60		content = character(0)
61		),
62		lock_objects = TRUE,
63		lock_class = TRUE
64		)

1		.onLoad <- function(libname, pkgname) {
2	!	op <- options()
3	!	default_global_knitr <- list(teal.reporter.global_knitr = list(
4	!	echo = TRUE,
5	!	tidy.opts = list(width.cutoff = 60),
6	!	tidy = requireNamespace("formatR", quietly = TRUE)
7		))
8
9	!	if (!("teal.reporter.global_knitr" %in% names(op))) {
10	!	options(default_global_knitr)
11		}
12
13	!	invisible()
14		}
15
16		.onAttach <- function(libname, pkgname) {
17	2x	if (!requireNamespace("formatR", quietly = TRUE)) {
18	!	packageStartupMessage(
19	!	"For better code formatting, consider installing the formatR package."
20		)
21		}
22		}

1		#' @title `PictureBlock`
2		#' @docType class
3		#' @description
4		#' Specialized `FileBlock` for managing picture content in reports.
5		#' It's designed to handle plots from packages such as `ggplot2`, `grid`, or `lattice`.
6		#' It can save plots to files, set titles and specify dimensions.
7		#'
8		#' @keywords internal
9		PictureBlock <- R6::R6Class( # nolint: object_name_linter.
10		classname = "PictureBlock",
11		inherit = FileBlock,
12		public = list(
13		#' @description Initialize a `PictureBlock` object.
14		#'
15		#' @param plot (`ggplot` or `grid`) a picture in this `PictureBlock`
16		#'
17		#' @return Object of class `PictureBlock`, invisibly.
18		initialize = function(plot) {
19	51x	if (!missing(plot)) {
20	!	self$set_content(plot)
21		}
22	51x	invisible(self)
23		},
24		#' @description Sets the content of this `PictureBlock`.
25		#'
26		#' @details Raises error if argument is not a `ggplot`, `grob` or `trellis` plot.
27		#'
28		#' @param content (`ggplot` or `grob` or `trellis`) a picture in this `PictureBlock`
29		#'
30		#' @return `self`, invisibly.
31		#' @examplesIf require("ggplot2") && require("lattice")
32		#' library(ggplot2)
33		#' library(lattice)
34		#'
35		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
36		#' block <- PictureBlock$new()
37		#' block$set_content(ggplot(iris))
38		#'
39		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
40		#' block <- PictureBlock$new()
41		#' block$set_content(bwplot(1))
42		#'
43		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
44		#' block <- PictureBlock$new()
45		#' block$set_content(ggplotGrob(ggplot(iris)))
46		set_content = function(content) {
47	31x	checkmate::assert_multi_class(content, private$supported_plots)
48	29x	path <- tempfile(fileext = ".png")
49	29x	grDevices::png(filename = path, width = private$dim[1], height = private$dim[2])
50	29x	tryCatch(
51	29x	expr = {
52	29x	if (inherits(content, "grob")) {
53	1x	grid::grid.newpage()
54	1x	grid::grid.draw(content)
55	28x	} else if (inherits(content, c("gg", "Heatmap"))) { # "Heatmap" S4 from ComplexHeatmap
56	27x	print(content)
57	1x	} else if (inherits(content, "trellis")) {
58	1x	grid::grid.newpage()
59	1x	grid::grid.draw(grid::grid.grabExpr(print(content), warn = 0, wrap.grobs = TRUE))
60		}
61	29x	super$set_content(path)
62		},
63	29x	finally = grDevices::dev.off()
64		)
65	29x	invisible(self)
66		},
67		#' @description Sets the title of this `PictureBlock`.
68		#'
69		#' @details Raises error if argument is not `character(1)`.
70		#'
71		#' @param title (`character(1)`) a string assigned to this `PictureBlock`
72		#'
73		#' @return `self`, invisibly.
74		#' @examples
75		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
76		#' block <- PictureBlock$new()
77		#' block$set_title("Title")
78		#'
79		set_title = function(title) {
80	5x	checkmate::assert_string(title)
81	4x	private$title <- title
82	4x	invisible(self)
83		},
84		#' @description Get the title of this `PictureBlock`.
85		#'
86		#' @return The content of this `PictureBlock`.
87		#' @examples
88		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
89		#' block <- PictureBlock$new()
90		#' block$get_title()
91		#'
92		get_title = function() {
93	9x	private$title
94		},
95		#' @description Sets the dimensions of this `PictureBlock`.
96		#'
97		#' @param dim (`numeric(2)`) figure dimensions (width and height) in pixels.
98		#'
99		#' @return `self`, invisibly.
100		#' @examples
101		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
102		#' block <- PictureBlock$new()
103		#' block$set_dim(c(800, 600))
104		#'
105		set_dim = function(dim) {
106	6x	checkmate::assert_numeric(dim, len = 2)
107	4x	private$dim <- dim
108	4x	invisible(self)
109		},
110		#' @description Get `PictureBlock` dimensions as a numeric vector.
111		#'
112		#' @return `numeric` the array of 2 numeric values representing width and height in pixels.
113		#' @examples
114		#' PictureBlock <- getFromNamespace("PictureBlock", "teal.reporter")
115		#' block <- PictureBlock$new()
116		#' block$get_dim()
117		get_dim = function() {
118	!	private$dim
119		}
120		),
121		private = list(
122		supported_plots = c("ggplot", "grob", "trellis", "Heatmap"),
123		type = character(0),
124		title = "",
125		dim = c(800, 600)
126		),
127		lock_objects = TRUE,
128		lock_class = TRUE
129		)

1		#' Simple reporter module
2		#'
3		#' @description `r lifecycle::badge("experimental")`
4		#'
5		#' Module provides compact UI and server functions for managing a report in a `shiny` app.
6		#' This module combines functionalities for [adding cards to a report][add_card_button],
7		#' [downloading the report][download_report_button], and [resetting report content][reset_report_button].
8		#'
9		#' For more details see the vignette: `vignette("simpleReporter", "teal.reporter")`.
10		#'
11		#' @details `r global_knitr_details()`
12		#'
13		#' @name simple_reporter
14		#'
15		#' @param id (`character(1)`) `shiny` module instance id.
16		#' @param reporter (`Reporter`) instance.
17		#' @param card_fun (`function`) which returns a [`ReportCard`] instance,
18		#' the function has a `card` argument and an optional `comment` argument.
19		#' @param global_knitr (`list`) a global `knitr` parameters for customizing the rendering process.
20		#' @inheritParams reporter_download_inputs
21		#'
22		#' @return `NULL`.
23		#'
24		#' @examples
25		#' if (interactive()) {
26		#' library(shiny)
27		#'
28		#' shinyApp(
29		#' ui = fluidPage(simple_reporter_ui("simple")),
30		#' server = function(input, output, session) {
31		#' simple_reporter_srv("simple", Reporter$new(), function(card) card)
32		#' }
33		#' )
34		#' }
35		NULL
36
37		#' @rdname simple_reporter
38		#' @export
39		simple_reporter_ui <- function(id) {
40	1x	ns <- shiny::NS(id)
41	1x	shiny::tagList(
42	1x	shiny::singleton(
43	1x	shiny::tags$head(shiny::includeCSS(system.file("css/custom.css", package = "teal.reporter")))
44		),
45	1x	shiny::tags$div(
46	1x	class = "block mb-4 p-1",
47	1x	shiny::tags$label(class = "text-primary block -ml-1", shiny::tags$strong("Reporter")),
48	1x	shiny::tags$div(
49	1x	class = "simple_reporter_container",
50	1x	add_card_button_ui(ns("add_report_card_simple")),
51	1x	download_report_button_ui(ns("download_button_simple")),
52	1x	report_load_ui(ns("archive_load_simple")),
53	1x	reset_report_button_ui(ns("reset_button_simple"))
54		)
55		)
56		)
57		}
58
59		#' @rdname simple_reporter
60		#' @export
61		simple_reporter_srv <- function(
62		id,
63		reporter,
64		card_fun,
65		global_knitr = getOption("teal.reporter.global_knitr"),
66		rmd_output = c(
67		"html" = "html_document", "pdf" = "pdf_document",
68		"powerpoint" = "powerpoint_presentation", "word" = "word_document"
69		),
70		rmd_yaml_args = list(
71		author = "NEST", title = "Report",
72		date = as.character(Sys.Date()), output = "html_document",
73		toc = FALSE
74		)) {
75	3x	shiny::moduleServer(
76	3x	id,
77	3x	function(input, output, session) {
78	3x	add_card_button_srv("add_report_card_simple", reporter = reporter, card_fun = card_fun)
79	3x	download_report_button_srv(
80	3x	"download_button_simple",
81	3x	reporter = reporter,
82	3x	global_knitr = global_knitr,
83	3x	rmd_output = rmd_output,
84	3x	rmd_yaml_args = rmd_yaml_args
85		)
86	3x	report_load_srv("archive_load_simple", reporter = reporter)
87	3x	reset_report_button_srv("reset_button_simple", reporter = reporter)
88		}
89		)
90		}

1		#' @title `NewpageBlock`
2		#' @docType class
3		#' @description
4		#' A `ContentBlock` subclass that represents a page break in a report output.
5		#'
6		#' @keywords internal
7		NewpageBlock <- R6::R6Class( # nolint: object_name_linter.
8		classname = "NewpageBlock",
9		inherit = ContentBlock,
10		public = list(
11		#' @description Initialize a `NewpageBlock` object.
12		#'
13		#' @details Returns a `NewpageBlock` object with no content and the default style.
14		#'
15		#' @return Object of class `NewpageBlock`, invisibly.
16		#' @examples
17		#' NewpageBlock <- getFromNamespace("NewpageBlock", "teal.reporter")
18		#' block <- NewpageBlock$new()
19		#'
20		initialize = function() {
21	14x	super$set_content("\n\\newpage\n")
22	14x	invisible(self)
23		}
24		),
25		lock_objects = TRUE,
26		lock_class = TRUE
27		)