---
title: "Reactivity Patterns in shinyds"
output: html
vignette: >
  %\VignetteIndexEntry{Reactivity Patterns in shinyds}
  %\VignetteEngine{quarto::html}
  %\VignetteEncoding{UTF-8}
---

```{r}
#| label: setup
#| include: false
library(shinyds)
```

## Two kinds of components

`shinyds` components fall into two categories that require different approaches to Shiny
reactivity.

### Standard input bindings

Most components use a `Shiny.InputBinding` registered in `ds-bindings.js`. You use them
exactly like native Shiny inputs:

| Component | Function(s) | `input$id` value |
|---|---|---|
| Button | `ds_button(inputId=)` | click count (integer) |
| Text input | `ds_input()` | character string |
| Textarea | `ds_textarea()` | character string |
| Checkbox | `ds_checkbox()` | `TRUE` / `FALSE` |
| Radio group | `ds_radio_group()` | selected value string |
| Select | `ds_select()` | selected value string |
| Search | `ds_search()` | character string |
| Suggestion | `ds_suggestion()` | selected value string |
| Tabs | `ds_tabs()` | selected tab value string |
| Pagination | `ds_pagination()` | current page integer |

A single `ds_radio()` is not reactive on its own — one `<input type="radio">` means nothing in
isolation, only the group has a value. `ds_radio_group()` binds the *container*
(`<fieldset class="ds-shiny-input">`), not the individual radios, and reports whichever child is
checked as one value — the same way Shiny's own `radioButtons()` works:

```{r}
#| eval: false
# UI
ds_radio_group("plan",
  label    = "Choose a plan",
  choices  = c("Free" = "free", "Pro" = "pro", "Team" = "team"),
  selected = "free"
)

# Server
observeEvent(input$plan, {
  # input$plan is "free", "pro", or "team"
})
```

### Behaviour-only module components

The Designsystemet JavaScript bundle also includes modules that **enhance native HTML elements**
rather than defining custom elements. The affected components are:

| Component | Function(s) | HTML element |
|---|---|---|
| Toggle group | `ds_toggle_group()` | `<div>` with buttons |
| Fieldset | `ds_fieldset()` | `<fieldset>` |
| Details | `ds_details()` | `<details>` |
| Dialog | `ds_dialog()` | `<dialog>` |
| Popover | `ds_popover()` | `<div popover>` |

These modules take over the element's behaviour for accessibility purposes (focus management,
ARIA attributes, keyboard navigation). Registering a `Shiny.InputBinding` on the same element
creates a conflict — the binding and the module fight over the element's state.

**Do not use `Shiny.InputBinding` for these components.** Use `Shiny.setInputValue()` from a
plain JavaScript event listener instead.

## The `Shiny.setInputValue()` pattern

`Shiny.setInputValue(id, value)` pushes a value directly to the Shiny server without needing a
binding on the element. The server receives it via `input$id` and you react to it with
`observeEvent()`.

`ds_toggle_group()` uses this pattern out of the box — it generates the script block for you:

```{r}
#| eval: false
# UI
ds_toggle_group(
  "view_mode",
  tags$button(class = "ds-button", `data-variant` = "secondary",
              `aria-pressed` = "true",  value = "list", "List"),
  tags$button(class = "ds-button", `data-variant` = "secondary",
              `aria-pressed` = "false", value = "grid", "Grid"),
  tags$button(class = "ds-button", `data-variant` = "secondary",
              `aria-pressed` = "false", value = "map",  "Map")
)

# Server
observeEvent(input$view_mode, {
  # input$view_mode is "list", "grid", or "map"
})
```

`ds_chip_group()` uses the same approach for selecting multiple values from a set of
toggle-style chips — it also generates its own script block, so no manual JavaScript is needed:

```{r}
#| eval: false
# UI
ds_chip_group("languages",
  ds_chip("R",      value = "r", selected = TRUE),
  ds_chip("Python", value = "python"),
  ds_chip("Julia",  value = "julia")
)

# Server
observeEvent(input$languages, {
  # input$languages is a character vector of selected values, e.g. "r"
})
```

For the other behaviour-only components you attach your own listener.

## Details / accordion

React to open/close events:

```{r}
#| eval: false
# UI
ds_details(
  id      = "my_details",
  summary = "Click to expand",
  ds_paragraph("Hidden content revealed on open.")
)

tags$script(HTML("
  document.getElementById('my_details').addEventListener('toggle', function(e) {
    Shiny.setInputValue('my_details_open', e.target.open, {priority: 'event'});
  });
"))

# Server
observeEvent(input$my_details_open, {
  if (isTRUE(input$my_details_open)) {
    # user expanded the panel
  }
})
```

`{priority: 'event'}` ensures the value fires even when it hasn't changed (e.g. opening,
closing, and reopening without navigating away).

## Dialog

`ds_dialog()` must be present in the UI. Open and close it from the server using
`show_ds_dialog()` and `hide_ds_dialog()` — no JavaScript required:

```{r}
#| eval: false
# UI
ds_button("Delete item", inputId = "open_confirm", variant = "primary")

ds_dialog(
  id = "confirm-dialog",
  ds_heading("Confirm deletion", level = 2, size = "md"),
  ds_paragraph("This action cannot be undone."),
  tags$div(
    style = "display:flex; gap:0.75rem; margin-top:1rem;",
    ds_button("Delete", inputId = "btn_confirm", variant = "primary"),
    ds_button("Cancel", inputId = "btn_cancel",  variant = "secondary")
  )
)

# Server
observeEvent(input$open_confirm, {
  show_ds_dialog("confirm-dialog")
})

observeEvent(input$btn_cancel, {
  hide_ds_dialog("confirm-dialog")
})

observeEvent(input$btn_confirm, {
  hide_ds_dialog("confirm-dialog")
  # perform deletion
})
```

### Reacting to close events from within the dialog

If you need to detect which button closed the dialog (e.g. Escape key vs Cancel vs Confirm),
attach a `close` event listener and use `returnValue`:

```{r}
#| eval: false
tags$script(HTML("
  document.getElementById('confirm-dialog').addEventListener('close', function(e) {
    Shiny.setInputValue('confirm_result', e.target.returnValue, {priority: 'event'});
  });
"))
```

Pass a return value when closing: `this.closest('dialog').close('confirm')`. `returnValue`
will be `"confirm"`, `"cancel"`, or `""` (Escape key).

## Popover

Detect when a popover is shown or hidden:

```{r}
#| eval: false
# UI
ds_button("Info", inputId = "info-btn", `popovertarget` = "info-pop")

ds_popover(
  id      = "info-pop",
  popover = NA,
  ds_paragraph("Contextual help text.")
)

tags$script(HTML("
  var pop = document.getElementById('info-pop');
  pop.addEventListener('toggle', function(e) {
    Shiny.setInputValue('info_pop_open', e.newState === 'open', {priority: 'event'});
  });
"))

# Server
observeEvent(input$info_pop_open, {
  if (isTRUE(input$info_pop_open)) {
    # log that user opened the popover, lazy-load content, etc.
  }
})
```

## Fieldset

React when a checkbox or radio inside a fieldset changes, reporting the full set of checked
values:

```{r}
#| eval: false
# UI
ds_fieldset(
  id     = "notif-fieldset",
  legend = "Notification preferences",
  ds_checkbox("notif_email", label = "Email"),
  ds_checkbox("notif_sms",   label = "SMS"),
  ds_checkbox("notif_push",  label = "Push")
)

tags$script(HTML("
  document.getElementById('notif-fieldset').addEventListener('change', function(e) {
    var checked = Array.from(
      e.currentTarget.querySelectorAll('input[type=checkbox]:checked')
    ).map(function(el) { return el.id; });
    Shiny.setInputValue('notif_prefs', checked);
  });
"))

# Server
observeEvent(input$notif_prefs, {
  # input$notif_prefs is a character vector of checked checkbox IDs
})
```

## Dropdown

`ds_dropdown()` combines a trigger element and a content panel but has no built-in Shiny
reactivity. To react to the dropdown opening or closing, listen for a `click` on the trigger
and track state yourself:

```{r}
#| eval: false
# UI
ds_dropdown(
  trigger = ds_button("Options", inputId = "btn_options", variant = "secondary"),
  ds_list(
    ds_list_item(ds_link("Edit",   href = "#")),
    ds_list_item(ds_link("Delete", href = "#"))
  )
)

tags$script(HTML("
  (function() {
    var open = false;
    document.getElementById('btn_options').addEventListener('click', function() {
      open = !open;
      Shiny.setInputValue('options_open', open, {priority: 'event'});
    });
  })();
"))

# Server
observeEvent(input$options_open, {
  if (isTRUE(input$options_open)) {
    # dropdown was opened — lazy-load data, log analytics, etc.
  }
})
```

If you only need to react to which menu item was chosen, it is often simpler to give each
item a `ds_button()` with its own `inputId` and handle them individually with
`observeEvent()`, without tracking open/close state at all.

## Phantom input suppression

The Designsystemet JavaScript bundle's `useId` utility auto-generates IDs like `:ds:1`,
`:ds:2`, … for child elements that have no `id` attribute (e.g. `<legend>` inside
`<fieldset>`). Shiny picks these up as phantom input names and produces errors:

```
No handler registered for type :ds:1
key must not be "" or NA
```

Two guards prevent this:

1. **`R/zzz.R`** — registers a pass-through handler for the `"ds"` input type so Shiny does not
   error on type lookup.
2. **`inst/www/js/ds-bindings.js`** — a `shiny:inputchanged` listener that calls
   `preventDefault()` on any input whose name starts with `:`, blocking phantom inputs before
   they reach the server.

Both guards are always active. You do not need to add anything to your app. If you add a new
behaviour-only module component and see this error, check whether the module assigns `:ds:*` IDs
to elements that an existing binding might pick up.

## Summary

| Component | Approach | Notes |
|---|---|---|
| `ds_toggle_group()` | `Shiny.setInputValue()` built in | script generated by the R function |
| `ds_chip_group()` | `Shiny.setInputValue()` built in | script generated by the R function; reports a character vector |
| `ds_details()` | `toggle` event → `setInputValue` | use `{priority:'event'}` |
| `ds_dialog()` | `show_ds_dialog()` / `hide_ds_dialog()` | preferred; JS listener only needed for `returnValue` |
| `ds_popover()` | `toggle` event → `setInputValue` | `e.newState === 'open'` |
| `ds_fieldset()` | `change` event → `setInputValue` | collect checked inputs manually |
| `ds_dropdown()` | `click` on trigger → `setInputValue` | track open/close state manually |
