/**
 * dialog.css — Dialog ([data-ui~="dialog"] on native <dialog>; slots
 *             data-dialog-slot="content | header | body | footer | close")
 *
 * @layer      variables, reset, components
 * @requires   _layers.css, _variables.css, _properties.css (--_*-resolved)
 * @uses       <dialog>, ::backdrop — native modal + backdrop
 * @uses       :root:has(dialog:modal) — overflow: hidden + scrollbar-gutter: stable while a modal
 *             is open (WebKit ignores overscroll-behavior on boxes that do not overflow)
 * @uses       @starting-style + allow-discrete — open/close opacity, transform, overlay
 * @uses       anchor-name, container-type — layout hooks for sized variants
 * @uses       corner-shape — superellipse corners; unsupported browsers keep plain
 *             rounded corners
 * @tokens     --ui-dialog-* (@layer variables; --ui-dialog-h defaults to a keyword, so the hook
 *             is read raw and takes a length or keyword; a --h utility or tier takes a scale
 *             number or a length; a keyword tier needs a base --h, or it renders as auto)
 * @presets    data-dialog-size="sm | md | lg | xl | 2xl | full | bleed" (the layout bands; sm when absent)
 * @uses       @media (width < 40rem) and (not (hover: hover)) + @container style(--ui-dialog-mobile-size)
 *             — below the sm band on a touch screen every dialog takes the hook's size (layout-bleed
 *             by default) over its preset; a narrow window with a mouse keeps the preset; style
 *             queries are Firefox 151+, Chrome 111+, Safari 18+, an older engine keeps the preset
 * @uses       env(safe-area-inset-bottom) — the full-height content slot clears the home indicator
 * @uses       translate, scale — in the transition list for consumers that move a dialog with
 *             them (drawer.js drags with an inline translate and releases into these
 *             transitions; a drawer behind another is scaled back)
 * @consumedby alert-dialog.css, command.css, drawer.css, lightbox.css, mobile-menu.css
 */

@layer variables {
  :root {
    --ui-dialog-backdrop-color: var(--color-shade-900);
    --ui-dialog-transition-duration: var(--default-transition-duration);
    --ui-dialog-transition-timing-function: var(--default-transition-timing-function);
    --ui-dialog-backdrop-transition-duration: calc(var(--ui-dialog-transition-duration) / 2);
    --ui-dialog-backdrop-transition-timing-function: var(--bezier-easing);
    --ui-dialog-backdrop-filter: none;
    --ui-dialog-shadow: var(--shadow-lg);
    --ui-dialog-border-width: 1px;
    --ui-dialog-border-style: solid;
    --ui-dialog-border-color: var(--color-border);
    /* the sm band, the default size */
    --ui-dialog-w: min(var(--layout-sm), 100% - var(--gutters) * 2);
    /* below the sm band, the size every dialog takes: layout-bleed (edge to edge, no page
       behind it), layout-full (inside the gutters), or none (its own preset) */
    --ui-dialog-mobile-size: layout-bleed;

    /* Reveal transitions/animations */
    --ui-dialog-opacity--start: 0;
    --ui-dialog-opacity--end: 1;
    --ui-dialog-scale--start: 0.98;
    --ui-dialog-scale--end: 1;
    --ui-dialog-translate--start: 0, 0, 0;
    --ui-dialog-translate--end: 0, 0, 0;
    --ui-dialog-transition-delay--start: 0ms;
    --ui-dialog-transition-delay--end: 0ms;
  }
}

@layer variables {
  :root {
    --ui-dialog-h: fit-content;
    --ui-dialog-bg: var(--color-card);
    --ui-dialog-text: var(--color-card-foreground);
    --ui-dialog-radius: var(--radius-lg);
    --ui-dialog-corner-shape: var(--radius-corner-shape);
  }
}

@layer reset {
  /* ===========================================================================
  DIALOG — native <dialog> open/close animation, sizing, backdrop fade
  - In the reset layer so the dialog component styling below wins.
  =========================================================================== */

  /* Spring-eased open/close */
  :where(dialog) {
    isolation: isolate;
    margin: auto;
    max-inline-size: calc(100% - var(--space-md));
    max-block-size: calc(100% - var(--space-md));
    border: var(--ui-dialog-border-width) var(--ui-dialog-border-style)
      var(--ui-dialog-border-color);
    contain: layout style;
    opacity: var(--ui-dialog-opacity--start);
    box-shadow: var(--ui-dialog-shadow);
    overscroll-behavior: contain;
    overflow: hidden;
    transform: translate3d(var(--ui-dialog-translate--start)) scale(var(--ui-dialog-scale--start));
    transition:
      opacity var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      transform var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      translate var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      scale var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      padding var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      block-size var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      inline-size var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function),
      overlay var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function)
        allow-discrete,
      display var(--ui-dialog-transition-duration) var(--ui-dialog-transition-timing-function)
        allow-discrete;
    transition-delay: var(--ui-dialog-transition-delay--start);
  }

  :where(dialog[open]) {
    transform: translate3d(var(--ui-dialog-translate--end)) scale(var(--ui-dialog-scale--end));
    opacity: var(--ui-dialog-opacity--end);
    transition-delay: var(--ui-dialog-transition-delay--end);

    @starting-style {
      transition-delay: var(--ui-dialog-transition-delay--start);
      transform: translate3d(var(--ui-dialog-translate--start)) scale(var(--ui-dialog-scale--start));
      opacity: var(--ui-dialog-opacity--start);
    }
  }

  /* Backdrop fades via a discrete transition. Twice the viewport tall: with the
     software keyboard up, iOS shows the page below the rect fixed boxes fill, and a
     fixed box past the viewport edge creates no scroll. */
  :where(dialog)::backdrop {
    position: fixed;
    inline-size: 100%;
    block-size: 100%;
    inset: 0;
    opacity: 0;
    overscroll-behavior: contain;
    overflow: clip;
    background-color: var(--ui-dialog-backdrop-color);
    backdrop-filter: var(--ui-dialog-backdrop-filter);
    transition: opacity var(--ui-dialog-backdrop-transition-duration)
      var(--ui-dialog-backdrop-transition-timing-function);
  }

  :where(dialog[open])::backdrop {
    opacity: 1;

    @starting-style {
      opacity: 0;
    }
  }

  /* Chromium and Firefox contain page scroll through overscroll-behavior above; WebKit
     ignores it on a box that does not overflow (the backdrop, a short dialog), so the root
     locks while a modal is open. The gutter stays the width of the scrollbar it replaces,
     so neither the page nor the centred dialog shifts on open or on close; the scroll
     position survives. At rest no gutter is reserved. */
  :root:has(dialog:modal) {
    overflow: hidden;
    scrollbar-gutter: stable;
  }
}

/* Size privates: written by data-dialog-size, non-inheriting. */
@property --_dialog-w {
  syntax: "*";
  inherits: false;
}

@property --_dialog-h-typed {
  syntax: "*";
  inherits: false;
}
@property --_dialog-h {
  syntax: "*";
  inherits: false;
}

@property --_dialog-radius {
  syntax: "*";
  inherits: false;
}

@property --_dialog-shadow {
  syntax: "*";
  inherits: false;
}

@layer ui.components {
  :where([data-ui~="dialog"]) {
    /* Set the hook on the element (not :root) so a later consumer (alert-dialog)
       or a subtree hook still wins; --_dialog-shadow is written only by the
       bleed preset. */
    --ui-dialog-shadow: var(--shadow-md);

    --_w-len: var(--_w-resolved, var(--_dialog-w, var(--ui-dialog-w)));
    --_w-num: var(--_w-resolved, var(--_dialog-w, var(--ui-dialog-w)));
    inline-size: calc(var(--_w-len) + var(--_w-num) * var(--spacing));
    /* The typed pair can't carry the hook's keyword. sign() adds nothing to the sum:
       its var() leaves --_dialog-h-typed unset without a --h, so the chain reaches the hook */
    --_h-len: var(--_h-resolved);
    --_h-num: var(--_h-resolved);
    --_dialog-h-typed: calc(
      var(--_h-len) + var(--_h-num) * var(--spacing) + 0px * sign(var(--_h-resolved))
    );
    block-size: var(--_dialog-h-typed, var(--_dialog-h, var(--ui-dialog-h)));
    background-color: var(--_bg-resolved, var(--ui-dialog-bg));
    color: var(--_text-resolved, var(--ui-dialog-text));
    box-shadow: var(--_shadow-resolved, var(--_dialog-shadow, var(--ui-dialog-shadow)));
    --_radius-len: var(--_radius-resolved, var(--_dialog-radius, var(--ui-dialog-radius)));
    --_radius-num: var(--_radius-resolved, var(--_dialog-radius, var(--ui-dialog-radius)));
    border-radius: calc(
      var(--_radius-len) + var(--_radius-num) * var(--spacing) * var(--radius-multiplier)
    );
    corner-shape: var(--_corner-shape-resolved, var(--ui-dialog-corner-shape));

    anchor-name: --ui-dialog-root;
    container-type: inline-size;
    container-name: dialog;
    font-size: var(--font-size-md);
    isolation: isolate;
    overflow: auto;
    overscroll-behavior: contain;
  }

  /* A one-row grid, so the content slot is capped by the dialog's height rather than
     sizing it (display went missing with the --ui-dialog-display token in 0.2). */
  :where([data-ui~="dialog"][open]) {
    display: grid;
    grid-template-rows: minmax(0, 1fr);
    min-block-size: 0;
  }

  :where([data-ui~="dialog"]) [data-dialog-slot~="close"] {
    position: absolute;
    inset-block-start: var(--space-xs);
    inset-inline-end: var(--space-xs);
    z-index: 50;
  }

  :where([data-ui~="dialog"]) [data-dialog-slot~="close"] > svg {
    inline-size: calc(var(--spacing) * 4);
    block-size: calc(var(--spacing) * 4);
    pointer-events: none;
    justify-content: center;
    align-items: center;
    display: flex;
    padding: 0;
  }

  /* Each slot owns a row, whatever the order and whichever are present: a body on its
     own still takes the flexible row, so it is the part that scrolls, never the dialog,
     and the close button keeps its corner. */
  :where([data-ui~="dialog"]) [data-dialog-slot~="content"] {
    display: grid;
    align-self: center;
    grid-template-rows: auto minmax(0, 1fr) auto;
    position: relative;
    min-block-size: 0;
    max-block-size: 100%;
    overscroll-behavior: contain;
  }

  :where([data-ui~="dialog"]) [data-dialog-slot~="header"] {
    grid-row: 1;
    display: flex;
    flex-direction: column;
    padding-inline: var(--space-sm);
    padding-block-start: var(--space-sm);
  }

  :where([data-ui~="dialog"]) [data-dialog-slot~="body"] {
    --_scroll-fade-gradient: linear-gradient(
      to bottom,
      transparent 0,
      #000 var(--_scroll-fade-start),
      #000 calc(100% - var(--_scroll-fade-end)),
      transparent 100%
    );

    grid-row: 2;
    display: grid;
    /* a full-height body keeps its rows at the top rather than spreading them */
    align-content: start;
    padding-inline: var(--space-sm);
    padding-block: var(--space-md);
    min-block-size: fit-content;
    max-block-size: 100%;
    overscroll-behavior: contain;
    overflow-y: auto;

    -webkit-mask-image: var(--ui-scroll-fade-mask, var(--_scroll-fade-gradient));
    mask-image: var(--ui-scroll-fade-mask, var(--_scroll-fade-gradient));
    -webkit-mask-composite: source-in;
    mask-composite: intersect;
    -webkit-mask-repeat: no-repeat;
    mask-repeat: no-repeat;

    @supports (animation-timeline: scroll()) {
      animation:
        ui-scroll-fade-reveal-start 1ms ease-in-out,
        ui-scroll-fade-reveal-end 1ms ease-in-out;
    }

    @supports not (animation-timeline: scroll()) {
      --_scroll-fade-start: var(--ui-scroll-fade-size);
      --_scroll-fade-end: var(--ui-scroll-fade-size);
    }
  }

  :where([data-ui~="dialog"]) [data-dialog-slot~="footer"] {
    grid-row: 3;
    block-size: fit-content;
    inset-block-end: 0;
    display: flex;
    justify-content: flex-end;
    align-self: end;
    flex-shrink: 0;
    gap: var(--space-xs);
    padding: var(--space-sm);
    border-block-start: 1px solid var(--color-border);
    background-color: var(--ui-dialog-bg);
  }

  /* Sizes follow the layout bands: sm … 2xl cap the width at the band (sm is the
     default), full spans the viewport inside the gutters, bleed fills it edge to edge. */
  :where([data-ui~="dialog"][data-dialog-size="sm"]) {
    --_dialog-w: min(var(--layout-sm), 100% - var(--gutters) * 2);
  }

  :where([data-ui~="dialog"][data-dialog-size="md"]) {
    --_dialog-w: min(var(--layout-md), 100% - var(--gutters) * 2);
  }

  :where([data-ui~="dialog"][data-dialog-size="lg"]) {
    --_dialog-w: min(var(--layout-lg), 100% - var(--gutters) * 2);
  }

  :where([data-ui~="dialog"][data-dialog-size="xl"]) {
    --_dialog-w: min(var(--layout-xl), 100% - var(--gutters) * 2);
  }

  :where([data-ui~="dialog"][data-dialog-size="2xl"]) {
    --_dialog-w: min(var(--layout-2xl), 100% - var(--gutters) * 2);
  }

  :where([data-ui~="dialog"][data-dialog-size="full"]) {
    --_dialog-w: calc(100% - var(--gutters) * 2);
  }

  :where([data-ui~="dialog"][data-dialog-size="bleed"]) {
    --_dialog-w: 100dvi;
    --_dialog-h: 100dvb;
    --_dialog-radius: 0;
    --_dialog-shadow: none;
    max-inline-size: 100dvi;
    max-block-size: 100dvb;
  }

  /* Below the sm band the viewport is a phone, and every dialog takes --ui-dialog-mobile-size
     over its preset: layout-bleed by default, so there is no page to see behind it. A style
     query reads the hook on the dialog's parent, never on the dialog itself: set it on :root
     for the site, or on one dialog's parent for that dialog alone. A viewport query, not a
     container one, because a top-layer dialog is sized by the viewport. Style queries are
     Firefox 151+; an older engine keeps the preset. A drawer (drawer.css) is a bottom sheet
     here instead, so every rule steps aside for it. */
  @media (width < 40rem) and (not (hover: hover)) {
    @container style(--ui-dialog-mobile-size: layout-bleed) {
      /* Not :where(): the viewport decides the height here, over a consumer's own cap
         on the same element (command's list max-block-size loads later at equal
         specificity). Utilities still win through the layer order. */
      [data-ui~="dialog"]:where(:not([data-ui~="drawer"])) [data-dialog-slot~="content"] {
        place-content: start stretch;
        block-size: 100%;
        padding-block-end: env(safe-area-inset-bottom, 0px);
      }

      [data-ui~="dialog"]:where(:not([data-ui~="drawer"])) [data-dialog-slot~="body"] {
        block-size: 100%;
        max-block-size: 100%;
        margin-block-end: auto;
      }

      :where([data-ui~="dialog"]:not([data-ui~="drawer"])) {
        --ui-dialog-border-color: transparent;

        --_dialog-w: 100dvi;
        --_dialog-h: 100dvb;
        --_dialog-radius: 0;

        margin: 0;
        max-inline-size: 100dvi;
        max-block-size: 100dvb;
        overflow: scroll;
        overscroll-behavior: contain;
        container: none;
      }

      :where(dialog:not([data-ui~="drawer"]))::backdrop {
        inline-size: 100dvi;
        block-size: 100dvb;
        inset: 0;
        opacity: 0;
        overscroll-behavior: contain;
        overflow: clip;
      }
    }

    @container style(--ui-dialog-mobile-size: layout-full) {
      :where([data-ui~="dialog"]:not([data-ui~="drawer"])) {
        --_dialog-w: calc(100dvi - var(--gutters) * 2);
      }
    }
  }
}
