# Defaults and Hiding Controls

Two closely related arguments — `defaults` and `hide.inputs`/`hide.tabs` — let you control what users see and what the module starts with. This vignette covers both in depth.

## `defaults`: pre-filling inputs

Pass a named list to the `defaults` argument of any `*InputsUI()` call. Each name is an input ID (matching the underlying plot function argument), and its value is what the control initialises to.

    library(VizModules)

    ui <- fluidPage(
        sidebarLayout(
            sidebarPanel(
                dittoViz_scatterPlotInputsUI(
                    "p", mtcars,
                    defaults = list(
                        x.by        = "wt",
                        y.by        = "mpg",
                        color.by    = "cyl",
                        size        = 3,
                        best.fit    = TRUE
                    )
                )
            ),
            mainPanel(dittoViz_scatterPlotOutputUI("p"))
        )
    )

    server <- function(input, output, session) {
        dittoViz_scatterPlotServer("p", data = reactive(mtcars))
    }

    shinyApp(ui, server)

### Finding valid keys

Defaults keys map directly to the argument names of the underlying plot function. The quickest way to find them is the module’s `*InputsUI()` help page, e.g. `?dittoViz_scatterPlotInputsUI`. The Plot parameters and defaults section lists every wired argument, its UI label, and its built-in default.

For inputs that come from the uniform tab helpers (Axes, Legend, Lines, Plotly), see `?uniform_axes_inputs_ui`, `?uniform_legend_inputs_ui`, `?uniform_lines_inputs_ui`, and `?uniform_plotly_inputs_ui` respectively.

### Validation

`get_default()` (used internally by every module) accepts an optional `validator` predicate. If the value you supply fails validation — e.g. passing a string where a logical is expected — the module silently falls back to its built-in default rather than erroring. This means a typo in a key is silent; double-check key names against the help page if a default appears to have no effect.

### Passing defaults through `createModuleApp()` and `*App()`

`defaults` is forwarded all the way through the app factory:

    plotthis_BoxPlotApp(
        defaults = list(
            x.by     = "Species",
            y.by     = "Sepal.Length",
            pt.size  = 0
        )
    )

The same `defaults` list is accepted by `createModuleApp()` directly:

    app <- createModuleApp(
        inputs_ui_fn = plotthis_BoxPlotInputsUI,
        output_ui_fn = plotthis_BoxPlotOutputUI,
        server_fn    = plotthis_BoxPlotServer,
        data_list    = list("iris" = iris),
        defaults     = list(x.by = "Species", y.by = "Sepal.Length")
    )
    if (interactive()) runApp(app)

## `hide.inputs`: hiding individual controls

Pass a character vector of input IDs to `hide.inputs` on the server function. Those controls are hidden from the UI while their values are still initialised (from `defaults` if supplied, otherwise the built-in default) and passed to the plot on every render.

    server <- function(input, output, session) {
        dittoViz_scatterPlotServer(
            "p",
            data        = reactive(mtcars),
            hide.inputs = c("shape.by", "plot.order", "opacity")
        )
    }

Hidden inputs reflow: the surrounding controls close the gap rather than leaving an empty space. This is handled automatically by the flexbox grid that `organize_inputs()` creates.

### Use case: app-level fixed parameters

A common pattern is to fix a column mapping or aesthetic so that app users cannot change it, while still applying it to every plot:

    server <- function(input, output, session) {
        dittoViz_scatterPlotServer(
            "p",
            data        = reactive(mtcars),
            defaults    = list(color.by = "cyl"),
            hide.inputs = "color.by"
        )
    }

The colour mapping is always `cyl`, and the control for it never appears.

## `hide.tabs`: hiding entire tab panels

Modules organise their inputs into named tabs (e.g. `"Data"`, `"Points"`, `"Lines"`, `"Axes"`, `"Legend"`, `"Plotly"`). Pass a character vector of tab names to `hide.tabs` to remove whole groups at once.

    server <- function(input, output, session) {
        dittoViz_scatterPlotServer(
            "p",
            data      = reactive(mtcars),
            hide.tabs = c("Plotly", "Lines", "Trajectory")
        )
    }

All inputs in a hidden tab are still initialised and active — they just aren’t shown. This is useful when you want to keep the defaults for an entire feature group (e.g. plotly export settings) without exposing the controls to users.

### Available tab names

Tab names are module-specific. Inspect the `inputs` list inside the relevant `*InputsUI()` source, or open `?<module>InputsUI` and look for the tab headings described there. Common tabs across most modules include:

Tab | Contents
--- | ---
`"Data"` | Column selectors (x, y, color, split, etc.)
`"Axes"` | Title font, gridlines, tick styling
`"Legend"` | Legend title and text sizes
`"Lines"` | Reference lines (h/v/ablines)
`"Plotly"` | Download format, margins, drawn shape styling
`"Facet"` | Facet rows/columns, scales, subplot spacing

## Combining `defaults`, `hide.inputs`, and `hide.tabs`

These three arguments compose freely. A typical production pattern is to set defaults for everything the user shouldn’t touch, hide the individual controls that need fine-grained locking, and hide any whole tabs that are irrelevant for your use case:

    ui <- fluidPage(
        sidebarLayout(
            sidebarPanel(
                plotthis_ViolinPlotInputsUI(
                    "v", example_rnaseq,
                    defaults = list(
                        x.by     = "condition",
                        y.by     = "expression",
                        color.by = "condition"
                    )
                )
            ),
            mainPanel(plotthis_ViolinPlotOutputUI("v"))
        )
    )

    server <- function(input, output, session) {
        plotthis_ViolinPlotServer(
            "v",
            data        = reactive(example_rnaseq),
            hide.inputs = c("color.by"),
            hide.tabs   = c("Plotly", "Lines")
        )
    }

    shinyApp(ui, server)

Here `color.by` is fixed to `"condition"` and hidden. The entire `"Plotly"` and `"Lines"` tabs are removed because they aren’t relevant to this app.

## Using `hide.inputs` in `createModuleApp()` and `*App()`

Both accept `hide.inputs` and `hide.tabs`, forwarding them to the server if it supports those arguments:

    plotthis_ViolinPlotApp(
        defaults    = list(x.by = "Species", y.by = "Sepal.Length"),
        hide.inputs = "color.by",
        hide.tabs   = "Plotly"
    )

## Hiding inputs dynamically in a custom module

When building a wrapper module (see `vignette("custom-modules", package = "VizModules")`), you can hide and show inputs at runtime in response to other inputs using `shinyjs`:

    library(shinyjs)

    myModuleServer <- function(id, data_reactive) {
        moduleServer(id, function(input, output, session) {
            # Hide the 'size' input whenever a size.by column is chosen
            observe({
                if (nzchar(input$size.by)) {
                    shinyjs::hide(id = "size")
                } else {
                    shinyjs::show(id = "size")
                }
            })
        })

        dittoViz_scatterPlotServer(id, data_reactive)
    }

Note that `shinyjs::hide()` / `shinyjs::show()` act on the input element itself. For the reflow behaviour (no empty gap), use the internal `.hide_input()` / `.show_input()` helpers instead, which target the wrapping cell in the flexbox grid:

    myModuleServer <- function(id, data_reactive) {
        moduleServer(id, function(input, output, session) {
            observe({
                if (nzchar(input$size.by)) {
                    VizModules:::.hide_input(session, "size")
                } else {
                    VizModules:::.show_input(session, "size")
                }
            })
        })

        dittoViz_scatterPlotServer(id, data_reactive)
    }