{
  "version": 3,
  "sources": ["../../srcts/src/components/_utils.ts", "../../srcts/src/components/_shinyResizeObserver.ts", "../../srcts/src/components/card.ts"],
  "sourcesContent": ["import type { HtmlDep } from \"rstudio-shiny/srcts/types/src/shiny/render\";\n\nimport type { InputBinding as InputBindingType } from \"rstudio-shiny/srcts/types/src/bindings/input\";\n\n// Exclude undefined from T\ntype NotUndefined<T> = T extends undefined ? never : T;\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst InputBinding = (\n  window.Shiny ? Shiny.InputBinding : class {}\n) as typeof InputBindingType;\n\nfunction registerBinding(\n  inputBindingClass: new () => InputBindingType,\n  name: string\n): void {\n  if (window.Shiny) {\n    Shiny.inputBindings.register(new inputBindingClass(), \"bslib.\" + name);\n  }\n}\n\n// Return true if the key exists on the object and the value is not undefined.\n//\n// This method is mainly used in input bindings' `receiveMessage` method.\n// Since we know that the values are sent by Shiny via `{jsonlite}`,\n// then we know that there are no `undefined` values. `null` is possible, but not `undefined`.\nfunction hasDefinedProperty<\n  Prop extends keyof X,\n  X extends { [key: string]: any }\n>(\n  obj: X,\n  prop: Prop\n): obj is X & { [key in NonNullable<Prop>]: NotUndefined<X[key]> } {\n  return (\n    Object.prototype.hasOwnProperty.call(obj, prop) && obj[prop] !== undefined\n  );\n}\n\n// TODO: Shiny should trigger resize events when the output\n// https://github.com/rstudio/shiny/pull/3682\nfunction doWindowResizeOnElementResize(el: HTMLElement): void {\n  if ($(el).data(\"window-resize-observer\")) {\n    return;\n  }\n  const resizeEvent = new Event(\"resize\");\n  const ro = new ResizeObserver(() => {\n    window.dispatchEvent(resizeEvent);\n  });\n  ro.observe(el);\n  $(el).data(\"window-resize-observer\", ro);\n}\n\nfunction getAllFocusableChildren(el: HTMLElement): HTMLElement[] {\n  // Cross-referenced with https://allyjs.io/data-tables/focusable.html\n  const base = [\n    \"a[href]\",\n    \"area[href]\",\n    \"button\",\n    \"details summary\",\n    \"input\",\n    \"iframe\",\n    \"select\",\n    \"textarea\",\n    '[contentEditable=\"\"]',\n    '[contentEditable=\"true\"]',\n    '[contentEditable=\"TRUE\"]',\n    \"[tabindex]\",\n  ];\n  const modifiers = [':not([tabindex=\"-1\"])', \":not([disabled])\"];\n  const selectors = base.map((b) => b + modifiers.join(\"\"));\n  const focusable = el.querySelectorAll(selectors.join(\", \"));\n  return Array.from(focusable) as HTMLElement[];\n}\n\nexport {\n  InputBinding,\n  registerBinding,\n  hasDefinedProperty,\n  doWindowResizeOnElementResize,\n  getAllFocusableChildren,\n};\nexport type { HtmlDep };\n", "/**\n * A resize observer that ensures Shiny outputs resize during or just after\n * their parent container size changes. Useful, in particular, for sidebar\n * transitions or for full-screen card transitions.\n *\n * @class ShinyResizeObserver\n * @typedef {ShinyResizeObserver}\n */\nclass ShinyResizeObserver {\n  /**\n   * The actual ResizeObserver instance.\n   * @private\n   * @type {ResizeObserver}\n   */\n  private resizeObserver: ResizeObserver;\n  /**\n   * An array of elements that are currently being watched by the Resize\n   * Observer.\n   *\n   * @details\n   * We don't currently have lifecycle hooks that allow us to unobserve elements\n   * when they are removed from the DOM. As a result, we need to manually check\n   * that the elements we're watching still exist in the DOM. This array keeps\n   * track of the elements we're watching so that we can check them later.\n   * @private\n   * @type {HTMLElement[]}\n   */\n  private resizeObserverEntries: HTMLElement[];\n\n  /**\n   * Watch containers for size changes and ensure that Shiny outputs and\n   * htmlwidgets within resize appropriately.\n   *\n   * @details\n   * The ShinyResizeObserver is used to watch the containers, such as Sidebars\n   * and Cards for size changes, in particular when the sidebar state is toggled\n   * or the card body is expanded full screen. It performs two primary tasks:\n   *\n   * 1. Dispatches a `resize` event on the window object. This is necessary to\n   *    ensure that Shiny outputs resize appropriately. In general, the window\n   *    resizing is throttled and the output update occurs when the transition\n   *    is complete.\n   * 2. If an output with a resize method on the output binding is detected, we\n   *    directly call the `.onResize()` method of the binding. This ensures that\n   *    htmlwidgets transition smoothly. In static mode, htmlwidgets does this\n   *    already.\n   *\n   * @note\n   * This resize observer also handles race conditions in some complex\n   * fill-based layouts with multiple outputs (e.g., plotly), where shiny\n   * initializes with the correct sizing, but in-between the 1st and last\n   * renderValue(), the size of the output containers can change, meaning every\n   * output but the 1st gets initialized with the wrong size during their\n   * renderValue(). Then, after the render phase, shiny won't know to trigger a\n   * resize since all the widgets will return to their original size (and thus,\n   * Shiny thinks there isn't any resizing to do). The resize observer works\n   * around this by ensuring that the output is resized whenever its container\n   * size changes.\n   * @constructor\n   */\n  constructor() {\n    this.resizeObserverEntries = [];\n    this.resizeObserver = new ResizeObserver((entries) => {\n      const resizeEvent = new Event(\"resize\");\n      window.dispatchEvent(resizeEvent);\n\n      // the rest of this callback is only relevant in Shiny apps\n      if (!window.Shiny) return;\n\n      const resized = [] as HTMLElement[];\n\n      for (const entry of entries) {\n        if (!(entry.target instanceof HTMLElement)) continue;\n        if (!entry.target.querySelector(\".shiny-bound-output\")) continue;\n\n        entry.target\n          .querySelectorAll<HTMLElement>(\".shiny-bound-output\")\n          .forEach((el) => {\n            if (resized.includes(el)) return;\n\n            const { binding, onResize } = $(el).data(\"shinyOutputBinding\");\n            if (!binding || !binding.resize) return;\n\n            // if this output is owned by another observer, skip it\n            const owner = (el as any).shinyResizeObserver;\n            if (owner && owner !== this) return;\n            // mark this output as owned by this shinyResizeObserver instance\n            if (!owner) (el as any).shinyResizeObserver = this;\n\n            // trigger immediate resizing of outputs with a resize method\n            onResize(el);\n            // only once per output and resize event\n            resized.push(el);\n\n            // set plot images to 100% width temporarily during the transition\n            if (!el.classList.contains(\"shiny-plot-output\")) return;\n            const img = el.querySelector<HTMLImageElement>(\n              'img:not([width=\"100%\"])'\n            );\n            if (img) img.setAttribute(\"width\", \"100%\");\n          });\n      }\n    });\n  }\n\n  /**\n   * Observe an element for size changes.\n   * @param {HTMLElement} el - The element to observe.\n   */\n  observe(el: HTMLElement): void {\n    this.resizeObserver.observe(el);\n    this.resizeObserverEntries.push(el);\n  }\n\n  /**\n   * Stop observing an element for size changes.\n   * @param {HTMLElement} el - The element to stop observing.\n   */\n  unobserve(el: HTMLElement): void {\n    const idxEl = this.resizeObserverEntries.indexOf(el);\n    if (idxEl < 0) return;\n\n    this.resizeObserver.unobserve(el);\n    this.resizeObserverEntries.splice(idxEl, 1);\n  }\n\n  /**\n   * This method checks that we're not continuing to watch elements that no\n   * longer exist in the DOM. If any are found, we stop observing them and\n   * remove them from our array of observed elements.\n   *\n   * @private\n   * @static\n   */\n  flush(): void {\n    this.resizeObserverEntries.forEach((el) => {\n      if (!document.body.contains(el)) this.unobserve(el);\n    });\n  }\n}\n\nexport { ShinyResizeObserver };\n", "import type { Tooltip as TooltipType } from \"bootstrap\";\nimport { getAllFocusableChildren } from \"./_utils\";\nimport { ShinyResizeObserver } from \"./_shinyResizeObserver\";\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst Tooltip = (\n  window.bootstrap ? window.bootstrap.Tooltip : class {}\n) as typeof TooltipType;\n\n/**\n * The overlay element that is placed behind the card when expanded full screen.\n *\n * @interface CardFullScreenOverlay\n * @typedef {CardFullScreenOverlay}\n */\ninterface CardFullScreenOverlay {\n  /**\n   * The full screen overlay container.\n   * @type {HTMLDivElement}\n   */\n  container: HTMLDivElement;\n  /**\n   * The anchor element used to close the full screen overlay.\n   * @type {HTMLAnchorElement}\n   */\n  anchor: HTMLAnchorElement;\n}\n\n/**\n * The bslib card component class.\n *\n * @class Card\n * @typedef {Card}\n */\nclass Card {\n  /**\n   * The card container element.\n   * @private\n   * @type {HTMLElement}\n   */\n  private card: HTMLElement;\n  /**\n   * The card's full screen overlay element. We create this element once and add\n   * and remove it from the DOM as needed (this simplifies focus management\n   * while in full screen mode).\n   * @private\n   * @type {CardFullScreenOverlay}\n   */\n  private overlay: CardFullScreenOverlay;\n\n  /**\n   * Key bslib-specific classes and attributes used by the card component.\n   * @private\n   * @static\n   * @type {{ ATTR_INIT: string; CLASS_CARD: string; CLASS_FULL_SCREEN: string; CLASS_HAS_FULL_SCREEN: string; CLASS_FULL_SCREEN_ENTER: string; CLASS_FULL_SCREEN_EXIT: string; ID_FULL_SCREEN_OVERLAY: string; }}\n   */\n  private static attr = {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    ATTR_INIT: \"data-bslib-card-init\",\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    CLASS_CARD: \"bslib-card\",\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    CLASS_FULL_SCREEN: \"bslib-full-screen\",\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    CLASS_HAS_FULL_SCREEN: \"bslib-has-full-screen\",\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    CLASS_FULL_SCREEN_ENTER: \"bslib-full-screen-enter\",\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    CLASS_FULL_SCREEN_EXIT: \"bslib-full-screen-exit\",\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    ID_FULL_SCREEN_OVERLAY: \"bslib-full-screen-overlay\",\n  };\n\n  /**\n   * A Shiny-specific resize observer that ensures Shiny outputs in within the\n   * card resize appropriately.\n   * @private\n   * @type {ShinyResizeObserver}\n   * @static\n   */\n  private static shinyResizeObserver = new ShinyResizeObserver();\n\n  /**\n   * Creates an instance of a bslib Card component.\n   *\n   * @constructor\n   * @param {HTMLElement} card\n   */\n  constructor(card: HTMLElement) {\n    // remove initialization attribute and script\n    card.removeAttribute(Card.attr.ATTR_INIT);\n    card\n      .querySelector<HTMLScriptElement>(`script[${Card.attr.ATTR_INIT}]`)\n      ?.remove();\n\n    this.card = card;\n    Card.instanceMap.set(card, this);\n\n    // Let Shiny know to trigger resize when the card size changes\n    // TODO: shiny could/should do this itself (rstudio/shiny#3682)\n    Card.shinyResizeObserver.observe(this.card);\n\n    this._addEventListeners();\n    this._enableTooltips();\n    this.overlay = this._createOverlay();\n\n    // bind event handler methods to this card instance\n    this._exitFullScreenOnEscape = this._exitFullScreenOnEscape.bind(this);\n    this._trapFocusExit = this._trapFocusExit.bind(this);\n  }\n\n  /**\n   * Enter the card's full screen mode, either programmatically or via an event\n   * handler. Full screen mode is activated by adding a class to the card that\n   * positions it absolutely and expands it to fill the viewport. In addition,\n   * we add a full screen overlay element behind the card and we trap focus in\n   * the expanded card while in full screen mode.\n   *\n   * @param {?Event} [event]\n   */\n  enterFullScreen(event?: Event): void {\n    if (event) event.preventDefault();\n\n    document.addEventListener(\"keydown\", this._exitFullScreenOnEscape, false);\n\n    // trap focus in the fullscreen container, listening for Tab key on the\n    // capture phase so we have the best chance of preventing other handlers\n    document.addEventListener(\"keydown\", this._trapFocusExit, true);\n\n    // Set initial focus on the card, if not already\n    if (!this.card.contains(document.activeElement)) {\n      this.card.setAttribute(\"tabindex\", \"-1\");\n      this.card.focus();\n    }\n\n    this.card.classList.add(Card.attr.CLASS_FULL_SCREEN);\n    document.body.classList.add(Card.attr.CLASS_HAS_FULL_SCREEN);\n    this.card.insertAdjacentElement(\"beforebegin\", this.overlay.container);\n  }\n\n  /**\n   * Exit full screen mode. This removes the full screen overlay element,\n   * removes the full screen class from the card, and removes the keyboard event\n   * listeners that were added when entering full screen mode.\n   */\n  exitFullScreen(): void {\n    document.removeEventListener(\n      \"keydown\",\n      this._exitFullScreenOnEscape,\n      false\n    );\n    document.removeEventListener(\"keydown\", this._trapFocusExit, true);\n\n    // Remove overlay and remove full screen classes from card\n    this.overlay.container.remove();\n    this.card.classList.remove(Card.attr.CLASS_FULL_SCREEN);\n    this.card.removeAttribute(\"tabindex\");\n    document.body.classList.remove(Card.attr.CLASS_HAS_FULL_SCREEN);\n  }\n\n  /**\n   * Adds general card-specific event listeners.\n   * @private\n   */\n  private _addEventListeners(): void {\n    const btnFullScreen = this.card.querySelector(\n      `:scope > .${Card.attr.CLASS_FULL_SCREEN_ENTER}`\n    );\n    if (!btnFullScreen) return;\n    btnFullScreen.addEventListener(\"click\", (ev) => this.enterFullScreen(ev));\n  }\n\n  /**\n   * Enable tooltips used by the card component.\n   * @private\n   */\n  private _enableTooltips(): void {\n    const selector = `.${Card.attr.CLASS_FULL_SCREEN_ENTER}[data-bs-toggle='tooltip']`;\n    if (!this.card.querySelector(selector)) {\n      return;\n    }\n    const tooltipList = this.card.querySelectorAll(selector);\n    tooltipList.forEach((tt) => new Tooltip(tt));\n  }\n\n  /**\n   * An event handler to exit full screen mode when the Escape key is pressed.\n   * @private\n   * @param {KeyboardEvent} event\n   */\n  private _exitFullScreenOnEscape(event: KeyboardEvent): void {\n    if (!(event.target instanceof HTMLElement)) return;\n    // If the user is in the middle of a select input choice, don't exit\n    const selOpenSelectInput = [\"select[open]\", \"input[aria-expanded='true']\"];\n    if (event.target.matches(selOpenSelectInput.join(\", \"))) return;\n\n    if (event.key === \"Escape\") {\n      this.exitFullScreen();\n    }\n  }\n\n  /**\n   * An event handler to trap focus within the card when in full screen mode.\n   *\n   * @description\n   * This keyboard event handler ensures that tab focus stays within the card\n   * when in full screen mode. When the card is first expanded,\n   * we move focus to the card element itself. If focus somehow leaves the card,\n   * we returns focus to the card container.\n   *\n   * Within the card, we handle only tabbing from the close anchor or the last\n   * focusable element and only when tab focus would have otherwise left the\n   * card. In those cases, we cycle focus to the last focusable element or back\n   * to the anchor. If the card doesn't have any focusable elements, we move\n   * focus to the close anchor.\n   *\n   * @note\n   * Because the card contents may change, we check for focusable elements\n   * every time the handler is called.\n   *\n   * @private\n   * @param {KeyboardEvent} event\n   */\n  private _trapFocusExit(event: KeyboardEvent): void {\n    if (!(event instanceof KeyboardEvent)) return;\n    if (event.key !== \"Tab\") return;\n\n    const isFocusedContainer = event.target === this.card;\n    const isFocusedAnchor = event.target === this.overlay.anchor;\n    const isFocusedWithin = this.card.contains(event.target as Node);\n\n    const stopEvent = () => {\n      event.preventDefault();\n      event.stopImmediatePropagation();\n    };\n\n    if (!(isFocusedWithin || isFocusedContainer || isFocusedAnchor)) {\n      // If focus is outside the card, return to the card\n      stopEvent();\n      this.card.focus();\n      return;\n    }\n\n    // Check focusables every time because the card contents may have changed\n    const focusableElements = getAllFocusableChildren(this.card);\n    const hasFocusableElements = focusableElements.length > 0;\n\n    // We need to handle five cases:\n    // 1. The card has no focusable elements --> focus the anchor\n    // 2. Focus is on the card container (do nothing, natural tab order)\n    // 3. Focus is on the anchor and the user pressed Tab + Shift (backwards)\n    //    -> Move to the last focusable element (end of card)\n    // 4. Focus is on the last focusable element and the user pressed Tab\n    //    (forwards) -> Move to the anchor (top of card)\n    // 5. otherwise we don't interfere\n\n    if (!hasFocusableElements) {\n      // case 1\n      stopEvent();\n      this.overlay.anchor.focus();\n      return;\n    }\n\n    // case 2\n    if (isFocusedContainer) return;\n\n    const lastFocusable = focusableElements[focusableElements.length - 1];\n    const isFocusedLast = event.target === lastFocusable;\n\n    if (isFocusedAnchor && event.shiftKey) {\n      stopEvent();\n      lastFocusable.focus();\n      return;\n    }\n\n    if (isFocusedLast && !event.shiftKey) {\n      stopEvent();\n      this.overlay.anchor.focus();\n      return;\n    }\n  }\n\n  /**\n   * Creates the full screen overlay.\n   * @private\n   * @returns {CardFullScreenOverlay}\n   */\n  private _createOverlay(): CardFullScreenOverlay {\n    const container = document.createElement(\"div\");\n    container.id = Card.attr.ID_FULL_SCREEN_OVERLAY;\n    container.onclick = this.exitFullScreen.bind(this);\n\n    const anchor = this._createOverlayCloseAnchor();\n    container.appendChild(anchor);\n\n    return { container, anchor };\n  }\n\n  /**\n   * Creates the anchor element used to exit the full screen mode.\n   * @private\n   * @returns {HTMLAnchorElement}\n   */\n  private _createOverlayCloseAnchor(): HTMLAnchorElement {\n    const anchor = document.createElement(\"a\");\n    anchor.classList.add(Card.attr.CLASS_FULL_SCREEN_EXIT);\n    anchor.tabIndex = 0;\n    anchor.onclick = () => this.exitFullScreen();\n    anchor.onkeydown = (ev) => {\n      if (ev.key === \"Enter\" || ev.key === \" \") {\n        this.exitFullScreen();\n      }\n    };\n    anchor.innerHTML = this._overlayCloseHtml();\n\n    return anchor;\n  }\n\n  /**\n   * Returns the HTML for the close icon.\n   * @private\n   * @returns {string}\n   */\n  private _overlayCloseHtml(): string {\n    return (\n      \"Close \" +\n      \"<svg width='20' height='20' fill='currentColor' class='bi bi-x-lg' \" +\n      \"viewBox='0 0 16 16'>\" +\n      \"<path d='M2.146 2.854a.5.5 0 1 1 .708-.708L8 7.293l5.146-5.147a.5.5 \" +\n      \"0 0 1 .708.708L8.707 8l5.147 5.146a.5.5 0 0 1-.708.708L8 8.707l-5.146 \" +\n      \"5.147a.5.5 0 0 1-.708-.708L7.293 8 2.146 2.854Z'/></svg>\"\n    );\n  }\n\n  /**\n   * The registry of card instances and their associated DOM elements.\n   * @private\n   * @static\n   * @type {WeakMap<HTMLElement, Card>}\n   */\n  private static instanceMap: WeakMap<HTMLElement, Card> = new WeakMap();\n\n  /**\n   * Returns the card instance associated with the given element, if any.\n   * @public\n   * @static\n   * @param {HTMLElement} el\n   * @returns {(Card | undefined)}\n   */\n  public static getInstance(el: HTMLElement): Card | undefined {\n    return Card.instanceMap.get(el);\n  }\n\n  /**\n   * If cards are initialized before the DOM is ready, we re-schedule the\n   * initialization to occur on DOMContentLoaded.\n   * @private\n   * @static\n   * @type {boolean}\n   */\n  private static onReadyScheduled = false;\n\n  /**\n   * Initializes all cards that require initialization on the page, or schedules\n   * initialization if the DOM is not yet ready.\n   * @public\n   * @static\n   * @param {boolean} [flushResizeObserver=true]\n   */\n  public static initializeAllCards(flushResizeObserver = true): void {\n    if (document.readyState === \"loading\") {\n      if (!Card.onReadyScheduled) {\n        Card.onReadyScheduled = true;\n        document.addEventListener(\"DOMContentLoaded\", () => {\n          Card.initializeAllCards(false);\n        });\n      }\n      return;\n    }\n\n    if (flushResizeObserver) {\n      // Trigger a recheck of observed cards to unobserve non-existent cards\n      Card.shinyResizeObserver.flush();\n    }\n\n    const initSelector = `.${Card.attr.CLASS_CARD}[${Card.attr.ATTR_INIT}]`;\n    if (!document.querySelector(initSelector)) {\n      // no cards to initialize\n      return;\n    }\n\n    const cards = document.querySelectorAll(initSelector);\n    cards.forEach((card) => new Card(card as HTMLElement));\n  }\n}\n\n// attach Sidebar class to window for global usage\n(window as any).bslib = (window as any).bslib || {};\n(window as any).bslib.Card = Card;\n\nexport { Card };\n"],
  "mappings": "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",
  "names": ["InputBinding", "getAllFocusableChildren", "el", "base", "modifiers", "selectors", "b", "focusable", "ShinyResizeObserver", "entries", "resizeEvent", "resized", "entry", "el", "binding", "onResize", "owner", "img", "idxEl", "Tooltip", "_Card", "card", "_a", "event", "btnFullScreen", "ev", "selector", "tt", "selOpenSelectInput", "isFocusedContainer", "isFocusedAnchor", "isFocusedWithin", "stopEvent", "focusableElements", "getAllFocusableChildren", "lastFocusable", "isFocusedLast", "container", "anchor", "el", "flushResizeObserver", "initSelector", "Card", "ShinyResizeObserver"]
}