/* motion.css: the shared motion layer. Every duration, easing, distance and scale comes from tokens.css.
   Part 1 is the guide's "essentials" (README §12.6), kept as written. Part 2 extends them to every component
   and moment of the motion catalog. components.css never declares transition or animation: it all lives here.
   Only opacity, translate, scale, stroke-dashoffset and colours animate, apart from the two contained
   exceptions (.collapsible's grid-template-rows, and one panel's height inside motion.swap). */
@layer motion {
  /* ============================ Part 1: essentials (README §12.6) =================================== */
  /* Feedback: colour changes and presses */
  .btn,
  .tile,
  .segmented__option,
  .nav__item,
  .row,
  .input {
    transition-property: background-color, border-color, color, outline-color, scale;
    transition-duration: var(--duration-fast);
    transition-timing-function: var(--ease-out);
  }
  .btn:is(:active, [data-force~='active']):not(:disabled),
  .tile:is(:active, [data-force~='active']),
  .nav__item:is(:active, [data-force~='active']) {
    scale: var(--press-scale);
    transition-duration: var(--duration-instant);
  }

  /* Dialogs pop in. Below 768 px, dialog.js adds .dialog--sheet and they slide up. Exits are short and accelerate. */
  dialog {
    opacity: 0;
    scale: var(--pop-scale);
    transition:
      opacity var(--duration-fast) var(--ease-in),
      scale var(--duration-fast) var(--ease-in),
      translate var(--duration-fast) var(--ease-in),
      display var(--duration-fast) allow-discrete,
      overlay var(--duration-fast) allow-discrete;
  }
  dialog[open] {
    opacity: 1;
    scale: 1;
    transition-duration: var(--duration-base);
    transition-timing-function: var(--ease-out);
  }
  @starting-style {
    dialog[open] {
      opacity: 0;
      scale: var(--pop-scale);
    }
  }
  dialog.dialog--sheet {
    scale: 1;
    translate: 0 calc(100% * var(--motion));
  }
  dialog.dialog--sheet[open] {
    translate: 0 0;
    transition-duration: var(--duration-slow);
    transition-timing-function: var(--ease-out-strong);
  }
  @starting-style {
    dialog.dialog--sheet[open] {
      translate: 0 calc(100% * var(--motion));
      scale: 1;
    }
  }
  dialog::backdrop {
    background: var(--color-scrim);
    opacity: 0;
    transition:
      opacity var(--duration-base) var(--ease-out),
      display var(--duration-base) allow-discrete,
      overlay var(--duration-base) allow-discrete;
  }
  dialog[open]::backdrop {
    opacity: 1;
  }
  @starting-style {
    dialog[open]::backdrop {
      opacity: 0;
    }
  }

  /* Menus and tooltips (Popover API) drop in from their trigger */
  .menu,
  .tooltip {
    opacity: 0;
    translate: 0 calc(-1 * var(--motion-distance-sm));
    transition:
      opacity var(--duration-fast) var(--ease-in),
      translate var(--duration-fast) var(--ease-in),
      display var(--duration-fast) allow-discrete,
      overlay var(--duration-fast) allow-discrete;
  }
  .menu:popover-open,
  .tooltip:popover-open {
    opacity: 1;
    translate: 0 0;
    transition-duration: var(--duration-base);
    transition-timing-function: var(--ease-out);
  }
  @starting-style {
    .menu:popover-open,
    .tooltip:popover-open {
      opacity: 0;
      translate: 0 calc(-1 * var(--motion-distance-sm));
    }
  }

  /* Toasts drop in, time out visibly, and slide away. toast.js removes a toast on the timer's animationend. */
  .toast {
    transition:
      opacity var(--duration-base) var(--ease-out),
      translate var(--duration-base) var(--ease-out);
  }
  @starting-style {
    .toast {
      opacity: 0;
      translate: 0 calc(-1 * var(--motion-distance-md));
    }
  }
  .toast[data-leaving] {
    opacity: 0;
    translate: var(--motion-distance-md) 0;
    transition-duration: var(--duration-fast);
    transition-timing-function: var(--ease-in);
  }
  .toast__timer {
    transform-origin: left;
    animation: toast-timer var(--duration-toast) linear forwards;
  }
  .toast:hover .toast__timer,
  .toast:focus-within .toast__timer {
    animation-play-state: paused;
  }

  /* Expand and collapse (banners, errors, the Settlement section) */
  .collapsible {
    display: grid;
    grid-template-rows: 0fr;
    opacity: 0;
    transition:
      grid-template-rows var(--duration-moderate) var(--ease-out),
      opacity var(--duration-moderate) var(--ease-out);
  }
  .collapsible[data-open] {
    grid-template-rows: 1fr;
    opacity: 1;
  }
  .collapsible > * {
    min-height: 0;
    overflow: hidden;
  }

  /* Progress: the track stays still, only the fill moves */
  .rail__fill,
  .upload__bar {
    transform-origin: left;
    scale: var(--progress, 0) 1;
    transition: scale var(--duration-slow) var(--ease-out);
  }

  /* State: status colour, the one-shot ring, drawn ticks */
  .status__dot {
    transition: background-color var(--duration-moderate) var(--ease-out);
  }
  .status__dot[data-changed]::after {
    content: '';
    position: absolute;
    inset: 0;
    border: var(--border-hairline) solid var(--dot-color);
    border-radius: var(--radius-round);
    animation: ring var(--duration-emphasis) var(--ease-out) both;
  }
  .checkbox__tick {
    stroke-dasharray: 1;
    stroke-dashoffset: 1;
    transition: stroke-dashoffset var(--duration-fast) var(--ease-out);
  }
  .checkbox input:checked + .checkbox__box .checkbox__tick {
    stroke-dashoffset: 0;
  }

  /* Loading */
  .skeleton {
    animation: skeleton-pulse var(--duration-pulse) var(--ease-in-out) infinite alternate;
  }
  .spinner {
    animation: spin var(--duration-spin) linear infinite;
  }

  /* Route changes: the shell stays still and only <main> moves (motion.viewTransition sets the direction). */
  main {
    view-transition-name: main;
  }
  ::view-transition-old(main) {
    animation: vt-out var(--duration-fast) var(--ease-in) both;
  }
  ::view-transition-new(main) {
    animation: vt-in var(--duration-moderate) var(--ease-out) both;
  }
  :root[data-nav-direction='back']::view-transition-new(main) {
    animation-name: vt-in-back;
  }
  ::view-transition-group(*) {
    animation-duration: var(--duration-moderate);
    animation-timing-function: var(--ease-in-out);
  }

  @keyframes vt-out {
    to {
      opacity: 0;
    }
  }
  @keyframes vt-in {
    from {
      opacity: 0;
      translate: 0 var(--motion-distance-md);
    }
  }
  @keyframes vt-in-back {
    from {
      opacity: 0;
      translate: 0 calc(-1 * var(--motion-distance-md));
    }
  }
  @keyframes toast-timer {
    from {
      scale: 1 1;
    }
    to {
      scale: 0 1;
    }
  }
  @keyframes ring {
    from {
      opacity: 1;
      scale: 1;
    }
    to {
      opacity: 0;
      scale: calc(1 + 1.2 * var(--motion));
    }
  }
  @keyframes skeleton-pulse {
    to {
      background: var(--color-skeleton-sheen);
    }
  }
  @keyframes spin {
    to {
      rotate: 1turn;
    }
  }

  /* Reduced motion: --motion is already 0 (tokens.css), which removes every distance and scale. These stop the rest. */
  @media (prefers-reduced-motion: reduce) {
    .collapsible {
      transition-property: opacity;
    }
    .skeleton {
      animation: none;
    }
  }
  :root[data-motion='reduced'] .collapsible {
    transition-property: opacity;
  }
  :root[data-motion='reduced'] .skeleton {
    animation: none;
  }
  @media (prefers-reduced-motion: no-preference) {
    :root:not([data-motion='reduced']) {
      scroll-behavior: smooth;
    }
  }

  /* ============================ Part 2: every other component ====================================== */
  /* Feedback (§12.1: every tap shows its pressed state within 100 ms): the same recipe for every control. */
  .link,
  .chip,
  .kpi,
  .menu__item,
  .palette__option,
  .bottomnav__item,
  .bottomnav__new,
  .topbar__back,
  .input-group,
  .checkbox__box,
  .radio__box,
  .dropzone,
  .file-tile,
  .file-tile__remove > span,
  .rail__node,
  .rail__label,
  .checklist__item,
  .checklist__mark,
  .table td,
  .tile__icon {
    transition-property: background-color, border-color, color, outline-color, scale;
    transition-duration: var(--duration-fast);
    transition-timing-function: var(--ease-out);
  }
  .chip:is(:active, [data-force~='active']):not(:disabled),
  a.kpi:is(:active, [data-force~='active']),
  .bottomnav__item:is(:active, [data-force~='active']) .bottomnav__new,
  .file-tile__remove:is(:active, [data-force~='active']) > span {
    scale: var(--press-scale);
    transition-duration: var(--duration-instant);
  }
  .btn[aria-disabled='true']:is(:active, [data-force~='active']),
  .tile:has(> input:disabled):is(:active, [data-force~='active']) {
    scale: 1;
  }
  /* List rows press on touch only: with a mouse the hover colour is the feedback. */
  @media (hover: none) {
    .rows > .row:is(:active, [data-force~='active']) {
      scale: var(--press-scale);
      transition-duration: var(--duration-instant);
    }
  }

  /* The focus ring fades in on fields and choice controls: a transparent outline is already in place.
     Forced-colours mode paints every outline, so the idle outline exists only outside it. */
  @media (forced-colors: none) {
    .input:not(:focus-visible, [data-force~='focus']),
    .input-group:not(:has(> .input:is(:focus-visible, [data-force~='focus']))),
    .checkbox__box,
    .radio__box {
      outline: var(--focus-ring) solid transparent;
      outline-offset: var(--focus-offset);
    }
    .checkbox > input:is(:focus-visible, [data-force~='focus']) + .checkbox__box,
    .radio > input:is(:focus-visible, [data-force~='focus']) + .radio__box {
      outline-color: var(--color-accent-text);
    }
  }

  /* Choice controls: a radio's inner square grows from 0 with no overshoot; ticks draw. */
  .radio__dot {
    transition:
      opacity var(--duration-fast) var(--ease-out),
      scale var(--duration-fast) var(--ease-out);
  }
  .tile__check {
    transition: opacity var(--duration-fast) var(--ease-out);
  }
  .tile__tick {
    stroke-dasharray: 1;
    stroke-dashoffset: 1;
    transition: stroke-dashoffset var(--duration-moderate) var(--ease-out);
  }
  .tile:has(> input:checked) .tile__tick {
    stroke-dashoffset: 0;
  }
  .checklist__mark > .drawn {
    transition: opacity var(--duration-fast) var(--ease-out);
  }

  /* Buttons: the spinner (shown by button.js after --delay-spinner) fades in. */
  .btn > .spinner {
    animation:
      spin var(--duration-spin) linear infinite,
      fade-in var(--duration-fast) var(--ease-out) both;
  }

  /* Skip link slides in when focused. */
  .skip-link {
    transition: translate var(--duration-fast) var(--ease-out);
  }

  /* A closed .collapsible is out of the tab order and the accessibility tree, not just invisible:
     visibility flips after the collapse has finished, and at once when it opens. */
  .collapsible > * {
    visibility: hidden;
    transition: visibility 0s linear var(--duration-moderate);
  }
  .collapsible[data-open] > * {
    visibility: visible;
    transition-delay: 0s;
  }

  /* An overlay that opens inside a view transition (the viewer growing out of a bill tile) appears at once:
     the view transition is the animation. */
  dialog[data-instant],
  dialog[data-instant]::backdrop {
    transition: none;
  }

  /* Dropzone: the icon lifts 4 px while a file is dragged over it (the distance is in components.css). */
  .dropzone__icon {
    transition:
      translate var(--duration-fast) var(--ease-out),
      color var(--duration-fast) var(--ease-out);
  }

  /* Uploads: the bar fades when it is done; the password strength bar and meters fill like any other progress. */
  .upload {
    transition: opacity var(--duration-base) var(--ease-out);
  }
  .strength__bar {
    transform-origin: left;
    scale: var(--progress, 0) 1;
    transition:
      scale var(--duration-slow) var(--ease-out),
      background-color var(--duration-fast) var(--ease-out);
  }
  .meter__fill {
    transition:
      scale var(--duration-slow) var(--ease-out),
      background-color var(--duration-fast) var(--ease-out);
  }
  /* A password rule that passes: its "not yet" dash fades as the square fills and the tick draws. */
  .checklist__mark::before {
    transition: opacity var(--duration-fast) var(--ease-out);
  }

  /* Browsers without the Popover API: menu.js shows menus and tooltips with [data-open] (components.css gives
     them display: block); they appear the same way as a popover does. */
  .menu[data-open],
  .tooltip[data-open] {
    opacity: 1;
    translate: 0 0;
    transition-duration: var(--duration-base);
    transition-timing-function: var(--ease-out);
  }
  @starting-style {
    .menu[data-open],
    .tooltip[data-open] {
      opacity: 0;
      translate: 0 calc(-1 * var(--motion-distance-sm));
    }
  }

  /* Bottom sheets follow the finger exactly while they are dragged (dialog.js sets data-dragging). */
  dialog[data-dragging] {
    transition: none;
  }

  /* Viewer: zoom and the snap after a pan; nothing eases while the image is being dragged. */
  .lightbox__image {
    transition:
      scale var(--duration-base) var(--ease-out),
      translate var(--duration-base) var(--ease-out);
  }
  .lightbox__image[data-panning] {
    transition: none;
  }

  /* Overlay transitions (the viewer opening out of a bill tile): the page underneath stays put. */
  :root[data-nav-direction='overlay']::view-transition-old(main) {
    display: none;
  }
  :root[data-nav-direction='overlay']::view-transition-new(main) {
    animation: none;
    mix-blend-mode: normal;
  }

  /* Boot splash (index.html): the mark and name fade in; a slow load gets an indeterminate line. */
  .boot__mark,
  .boot__name {
    animation: fade-in var(--duration-base) var(--ease-out) both;
  }
  .boot__bar {
    animation: fade-in var(--duration-base) var(--ease-out) var(--delay-boot-bar) both;
  }
  .boot__bar::after {
    animation: indeterminate var(--duration-indeterminate) var(--ease-in-out) infinite;
  }

  @keyframes fade-in {
    from {
      opacity: 0;
    }
  }
  @keyframes indeterminate {
    from {
      translate: -100% 0;
    }
    to {
      translate: 250% 0;
    }
  }
  /* Under reduced motion the toast timer fades instead of shrinking; it still ends the toast. */
  @keyframes toast-timer-fade {
    from {
      opacity: 1;
    }
    to {
      opacity: 0.4;
    }
  }

  /* Reduced motion, continued: progress still shows (it carries information) but jumps instead of gliding,
     ticks appear drawn, and nothing translates or scales. Spinners keep turning. */
  @media (prefers-reduced-motion: reduce) {
    .rail__fill,
    .upload__bar,
    .strength__bar,
    .meter__fill,
    .checkbox__tick,
    .tile__tick,
    .skip-link,
    .lightbox__image {
      transition: none;
    }
    .toast__timer {
      animation-name: toast-timer-fade;
    }
    .boot__bar::after {
      animation: none; /* its full width is set in pages.css */
    }
  }
  /* The same for "Reduce animations" on <html>, and for any subtree that carries data-motion="reduced"
     (the /dev/motion page shows full and reduced motion side by side). */
  [data-motion='reduced'] :is(.rail__fill, .upload__bar, .strength__bar, .meter__fill, .checkbox__tick, .tile__tick),
  [data-motion='reduced'] :is(.skip-link, .lightbox__image) {
    transition: none;
  }
  [data-motion='reduced'] .toast__timer {
    animation-name: toast-timer-fade;
  }
  [data-motion='reduced'] .boot__bar::after {
    animation: none;
  }
  [data-motion='reduced'] .collapsible {
    transition-property: opacity;
  }
  [data-motion='reduced'] .skeleton {
    animation: none;
  }

  /* Reduced motion, last part: toasts, overlays and presses only fade or change colour. --motion: 0 has already
     zeroed their distances and scales, but a transition between `none` and a zero translate (or a scale of 1)
     would still run, and count as a moving animation. */
  @media (prefers-reduced-motion: reduce) {
    .toast {
      transition-property: opacity;
    }
    dialog,
    .menu,
    .tooltip {
      transition-property: opacity, display, overlay;
      transition-behavior: normal, allow-discrete, allow-discrete;
    }
    .btn,
    .tile,
    .nav__item,
    .row,
    .chip,
    .kpi,
    .bottomnav__new,
    .file-tile__remove > span {
      transition-property: background-color, border-color, color, outline-color;
    }
    .dropzone__icon {
      transition-property: color;
    }
  }
  [data-motion='reduced'] .toast {
    transition-property: opacity;
  }
  [data-motion='reduced'] :is(dialog, .menu, .tooltip) {
    transition-property: opacity, display, overlay;
    transition-behavior: normal, allow-discrete, allow-discrete;
  }
  [data-motion='reduced'] :is(.btn, .tile, .nav__item, .row, .chip, .kpi, .bottomnav__new, .file-tile__remove > span) {
    transition-property: background-color, border-color, color, outline-color;
  }
  [data-motion='reduced'] .dropzone__icon {
    transition-property: color;
  }

  /* Touch screens keep :hover on the last spot tapped, which can be where a new toast appears: there, only
     focus pauses a toast's timer. */
  @media (hover: none) {
    .toast:hover:not(:focus-within) .toast__timer {
      animation-play-state: running;
    }
  }
}
