Status Bar

import { clsx, type ClassValue } from "clsx"
import { twMerge } from "tailwind-merge"

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}

"use client";

import { useEffect, useState } from "react";

/**
 * Returns true only on devices that have a true hover (mouse / trackpad).
 * Touch devices fire phantom `:hover` on tap that sticks until tap-elsewhere
 * — gate hover-only effects (scale lifts, magnetic pulls) behind this.
 */
export function useHoverCapable() {
  const [canHover, setCanHover] = useState(false);

  useEffect(() => {
    if (typeof window === "undefined" || !window.matchMedia) return;
    const mq = window.matchMedia("(hover: hover) and (pointer: fine)");
    const update = () => setCanHover(mq.matches);
    update();
    mq.addEventListener?.("change", update);
    return () => mq.removeEventListener?.("change", update);
  }, []);

  return canHover;
}

// Shared motion tokens. Easing curves mirror the CSS custom properties in
// globals.css; springs are the canonical physics used across components.
// Strong custom variants — defaults like `ease-in`/`ease-out` feel weak.

export const EASE_OUT = [0.16, 1, 0.3, 1] as const;
export const EASE_IN_OUT = [0.77, 0, 0.175, 1] as const;
export const EASE_DRAWER = [0.32, 0.72, 0, 1] as const;

/** CSS string form of EASE_OUT for inline style transitions. */
export const EASE_OUT_CSS = "cubic-bezier(0.16, 1, 0.3, 1)";

/** Press feedback on buttons and other tappable surfaces. */
export const SPRING_PRESS = {
  type: "spring",
  stiffness: 500,
  damping: 30,
  mass: 0.6,
} as const;

/** Content swaps — label/icon slots trading places inside a control. */
export const SPRING_SWAP = {
  type: "spring",
  stiffness: 460,
  damping: 30,
  mass: 0.55,
} as const;

/** Overlay panel entrances — modals and sheets summoned by pointer. */
export const SPRING_PANEL = {
  type: "spring",
  stiffness: 420,
  damping: 40,
  mass: 0.5,
} as const;

/** Shared-layout glides — pills, indicators and panels morphing between positions. */
export const SPRING_LAYOUT = {
  type: "spring",
  stiffness: 360,
  damping: 32,
  mass: 0.6,
} as const;

/** Cursor-follow physics for decorative mouse tracking (magnetic, tilt, dock). */
export const SPRING_MOUSE = {
  stiffness: 200,
  damping: 15,
  mass: 0.3,
} as const;

/** Dragged handles and fills (sliders) — critically damped `useSpring` config,
 * so the value follows the pointer butterily and never rebounds off an end. */
export const SPRING_GLIDE = {
  stiffness: 700,
  damping: 50,
  mass: 0.5,
} as const;

"use client";

import { type RefObject, useEffect } from "react";

/**
 * What the dismissing gesture does to the control it landed on.
 *
 * `"pass-through"` is the platform norm (native popover light-dismiss): the
 * tap closes the overlay *and* activates whatever was under it. Use
 * `"consume"` where the open overlay sits over or beside controls that would
 * be costly to trigger by accident — the dismissal then swallows the
 * activation too, so the gesture only closes.
 */
export type DismissBehavior = "pass-through" | "consume";

export interface DismissOptions {
  /** Default `"pass-through"`. */
  behavior?: DismissBehavior;
  /** Dismiss on Escape as well. Default true. */
  escape?: boolean;
  /** Return true for an outside target that should *not* dismiss. Must be stable. */
  ignore?: (target: Element) => boolean;
}

/**
 * What every currently open dismiss scope counts as inside itself. A consumed
 * dismissal reads this to tell a stray gesture from one that belongs to an
 * overlay in front of it: overlays have no shared z-order to consult, but the
 * one the gesture landed in has said as much by registering it.
 */
const openScopes = new Set<(target: Element) => boolean>();

function claimedByAnotherScope(
  self: (target: Element) => boolean,
  target: Element,
) {
  for (const scope of openScopes) {
    if (scope !== self && scope(target)) return true;
  }
  return false;
}

// preventDefault on pointerdown does not suppress the click that follows, so
// consuming a gesture means swallowing that click itself. The swallower
// deliberately outlives the effect that installed it — the dismissal it
// belongs to has already unmounted or re-rendered by the time the click lands.
// It releases on that click, or on the next gesture if the pointer is dragged
// away and no click ever arrives, so it can never eat a later one. A keydown
// releases it too: a gesture that ends with neither a click nor a cancel would
// otherwise leave it armed, and the click Enter synthesizes on some focused
// control is not the one this dismissal was owed.
function consumeActivation(source: Event) {
  const swallow = (event: MouseEvent) => {
    event.preventDefault();
    event.stopPropagation();
    release();
  };
  const restart = (event: Event) => {
    if (event !== source) release();
  };
  const release = () => {
    window.removeEventListener("click", swallow, true);
    window.removeEventListener("pointerdown", restart, true);
    window.removeEventListener("pointercancel", restart, true);
    window.removeEventListener("keydown", release, true);
  };
  window.addEventListener("click", swallow, true);
  window.addEventListener("pointerdown", restart, true);
  window.addEventListener("pointercancel", restart, true);
  window.addEventListener("keydown", release, true);
}

/**
 * Close an open overlay on Escape or a pointerdown outside `ref`. Pass `null`
 * for `ref` when what counts as inside isn't one element, and say so with
 * `ignore` instead.
 *
 * The pointerdown listener is capture-phase: a bubble-phase one is blinded by
 * any handler in between that stops propagation, and an overlay cannot know
 * what it is layered over. `onDismiss` and `ignore` must be stable (wrap in
 * useCallback) so the listeners aren't re-bound every render while open.
 */
export function useDismiss(
  open: boolean,
  onDismiss: () => void,
  ref: RefObject<HTMLElement | SVGElement | null> | null,
  {
    behavior = "pass-through",
    escape: dismissOnEscape = true,
    ignore,
  }: DismissOptions = {},
) {
  useEffect(() => {
    if (!open) return;
    const inside = (target: Element) =>
      Boolean(ref?.current?.contains(target)) || Boolean(ignore?.(target));
    const onKey = (event: KeyboardEvent) => {
      if (dismissOnEscape && event.key === "Escape") onDismiss();
    };
    const onPointer = (event: PointerEvent) => {
      const target = event.target as Element | null;
      if (!target || inside(target)) return;
      // Outside this overlay, but inside one that is also open: the gesture is
      // that overlay's to answer, and swallowing its click from behind would
      // cost the user the control they actually aimed at.
      if (behavior === "consume" && !claimedByAnotherScope(inside, target)) {
        consumeActivation(event);
      }
      onDismiss();
    };
    openScopes.add(inside);
    window.addEventListener("keydown", onKey);
    window.addEventListener("pointerdown", onPointer, true);
    return () => {
      openScopes.delete(inside);
      window.removeEventListener("keydown", onKey);
      window.removeEventListener("pointerdown", onPointer, true);
    };
  }, [open, onDismiss, ref, behavior, dismissOnEscape, ignore]);
}

"use client";

import { useMemo, useRef } from "react";
import { isHoveringPointer } from "@/lib/touch";

interface BoundaryEvent {
  pointerId: number;
  pointerType: string;
  buttons: number;
}

export interface HoverGesture {
  /** True when this enter starts a hover: the pointer arrived resting, not pressing. */
  enter: (event: BoundaryEvent) => boolean;
  /** True when this leave ends a hover that entered as one. */
  leave: (event: BoundaryEvent) => boolean;
}

/**
 * Pairs a surface's enter with its leave, per pointer.
 *
 * `isHoveringPointer` answers the question the *enter* asks — is this pointer
 * resting on the surface or pressing it — and both boundary cases go wrong if
 * the leave is asked the same question again:
 *
 * - A pen with no hover never rests. It arrives in contact, taps, and the spec
 *   then requires its boundary events after `pointerup`, so the leave carries
 *   `buttons: 0` and reads as a mouse gliding off. Hover teardown then undid
 *   the tap — the panel the pen had just opened closed under it.
 * - A mouse pressed on the surface and dragged off leaves with `buttons: 1`.
 *   Skipping teardown there strands the surface open: the release happens
 *   outside, and no second leave ever comes.
 *
 * So the state a hover holds is released by the pointer that took it, whatever
 * the buttons say at the boundary, and a pointer that arrived in contact never
 * took it in the first place. Contact is the exception tracked here, not
 * hover: a leave from a pointer this surface never saw enter — mounted under
 * the cursor, say — still counts, since the alternative is state with no way
 * out.
 */
export function useHoverGesture(): HoverGesture {
  const contact = useRef(new Set<number>());

  return useMemo(
    () => ({
      enter: (event) => {
        if (isHoveringPointer(event)) {
          contact.current.delete(event.pointerId);
          return true;
        }
        contact.current.add(event.pointerId);
        return false;
      },
      leave: (event) => {
        const arrivedInContact = contact.current.delete(event.pointerId);
        return !arrivedInContact && event.pointerType !== "touch";
      },
    }),
    [],
  );
}

"use client";

import { useMemo, useRef } from "react";

/** What a pointerdown recorded, read back by the click that ends its gesture. */
export interface TapRecord<S> {
  /** Which input started the gesture. */
  pointerType: string;
  /** What the surface was showing when it started. */
  state: S;
}

export interface TapGesture<S> {
  /** Record the gesture a pointerdown starts, with the state it starts in. */
  start: (event: { pointerType: string }, state: S) => void;
  /** Read the record and clear it. `null` when no pointer is behind this click. */
  take: () => TapRecord<S> | null;
  /** Drop the record: this gesture will never spend it on a click. */
  drop: () => void;
}

/**
 * The pointer gesture behind a click, recorded where the click cannot report
 * it. A `click` carries no `pointerType` in the engines that matter, so the
 * `pointerdown` before it is the only thing that says which input activated
 * the control — and whether one did at all, since keyboard activation
 * synthesizes a click with no pointer behind it.
 *
 * State goes in with the record because a click reports that no better: a
 * browser that focuses a control on contact can open the very panel the tap
 * was meant to open, and reading "is it open" at click time then undoes it.
 * What the gesture started against is what it acts on.
 *
 * The record is spent by one click and dropped by everything else, because a
 * record that outlives its gesture is worse than none:
 *
 * - A scroll or an OS gesture takes the touch away — `pointercancel`, no click
 *   ever — and the finger would sit in the record until some later click.
 * - That later click is often `Enter` on a keyboard, which arrives with no
 *   pointerdown of its own and would inherit the abandoned finger. A keydown
 *   is the start of a keyboard activation and never part of a tap, so it drops
 *   the record too.
 *
 * Both ends have to be wired by the surface: `drop` on `onPointerCancel` and
 * on `onKeyDown`.
 */
export function useTapGesture<S>(): TapGesture<S> {
  const record = useRef<TapRecord<S> | null>(null);

  return useMemo(
    () => ({
      start: (event, state) => {
        record.current = { pointerType: event.pointerType, state };
      },
      take: () => {
        const spent = record.current;
        record.current = null;
        return spent;
      },
      drop: () => {
        record.current = null;
      },
    }),
    [],
  );
}

// Shared touch primitives. iOS and iPadOS run their own gestures on top of the
// page — the long-press selection callout and the selection it drags in with
// it — and they win: once the platform claims a touch it cancels ours
// mid-gesture, so a press-and-hold or a drag simply dies. Surfaces that own
// their gesture have to opt out.
//
// What the two classes below cover, precisely:
// - `-webkit-touch-callout: none` stops iOS's long-press callout. WebKit-only:
//   it is not a property other engines have, so it is inert everywhere else.
// - `user-select: none` stops the long-press selection on every engine,
//   Android included, and stops a drag from painting a selection under the
//   cursor. It is inherited, so it reaches every descendant — which is why the
//   two classes differ only in whether they apply it unconditionally.
// What neither covers:
// - Chrome for Android's long-press menu on a link or an image. No CSS
//   suppresses it; a gesture surface that wraps one needs its own
//   `onContextMenu` with `preventDefault()`.
// - The native drag of an `<img>` or `<a>` descendant. `-webkit-user-drag` is
//   not inherited and plain divs and buttons are not drag sources, so setting
//   it on the surface does nothing — the child itself needs `draggable={false}`.

/**
 * Classes for a surface that *is* the control: a thumb, a drum, a stage, a
 * handle, a hold button. Selection is suppressed on every input, because a
 * drag that highlights the control's own label is wrong on a mouse too.
 * Compose with `touch-none` when the surface also owns the scroll axis — leave
 * it off when the page must still scroll from there.
 */
export const TOUCH_GESTURE_CLASS = "select-none [-webkit-touch-callout:none]";

/**
 * The same opt-out for a gesture surface that wraps content the consumer owns:
 * a scroller, a context-menu trigger, a sheet header, a list row. Selection is
 * suppressed only where the platform runs its own press gestures — a coarse
 * pointer — so a mouse user can still select and copy that content. If the
 * gesture itself would paint a selection under the cursor, add `select-none`
 * for the duration of the gesture rather than reaching for
 * `TOUCH_GESTURE_CLASS`.
 *
 * `pointer: coarse` describes the *primary* pointer and nothing else, so a
 * hybrid machine reads it wrong in both directions: a tablet with a mouse
 * plugged in keeps touch as primary and loses mouse selection, and a laptop
 * with a touchscreen keeps the mouse as primary and leaves selection live
 * under a finger. No media query can answer per interaction — the query is
 * about the device, and the question is about the gesture in progress. The
 * default stays here because it is right on the machines that are one thing or
 * the other, and losing a selection is a nuisance; where the miss costs a
 * *gesture* instead, the surface pairs it with `holdSelection` on the press.
 */
export const TOUCH_GESTURE_CONTENT_CLASS =
  "[-webkit-touch-callout:none] pointer-coarse:select-none";

/**
 * Suppress selection on `element` for as long as a gesture is running on it,
 * whatever the primary pointer of the machine happens to be. Returns the
 * release. Inline, so it wins over the class above and is gone again the
 * moment the gesture ends.
 *
 * For the press gestures a native selection would otherwise steal — a
 * long-press that opens a menu. Elsewhere prefer the classes: a surface that
 * takes selection away for the whole session is a surface whose text nobody
 * can copy.
 */
export function holdSelection(element: HTMLElement) {
  element.style.setProperty("user-select", "none");
  element.style.setProperty("-webkit-user-select", "none");
  return () => {
    element.style.removeProperty("user-select");
    element.style.removeProperty("-webkit-user-select");
  };
}

/**
 * Pointer capture, best effort. WebKit throws `NotFoundError` when the pointer
 * is already gone by the time the handler runs — routine on iOS, where the
 * system can claim the touch first — and an uncaught throw takes the rest of
 * the handler, the gesture included, down with it. Touch pointers carry
 * implicit capture anyway, so losing it is never fatal.
 */
export function capturePointer(element: Element, pointerId: number) {
  try {
    element.setPointerCapture(pointerId);
  } catch {
    // Pointer is no longer active — implicit capture still applies on touch.
  }
}

/** Release a capture taken with `capturePointer`, ignoring a stale pointer. */
export function releasePointer(element: Element, pointerId: number) {
  try {
    if (element.hasPointerCapture(pointerId)) {
      element.releasePointerCapture(pointerId);
    }
  } catch {
    // Capture was already dropped by the browser.
  }
}

/**
 * Whether this event came from a pointer that is *hovering*: not a touch, and
 * not currently pressed. Which input the user is holding right now is not
 * something a device capability can answer — a touchscreen laptop hovers and
 * taps, and iPadOS reports a fine hovering pointer for a finger — so both
 * paths stay live and each handler branches on the event it was given.
 *
 * A pen resting on the glass is making contact, not hovering: `buttons` is the
 * tell, and it sends a pen tap down the same route a finger takes.
 *
 * This answers what an *enter* asks. A leave is the other half of a pair and
 * has to be read against the enter that started it — `useHoverGesture` in
 * `lib/hooks/use-hover-gesture` does that, and hover surfaces should use it
 * rather than asking this question twice.
 */
export const isHoveringPointer = (event: {
  pointerType: string;
  buttons: number;
}) => event.pointerType !== "touch" && event.buttons === 0;

"use client";
// beui.dev/charts/status-bar

import { cn } from "@/lib/utils";
import { StatusBarContext, useStatusBarModel, type StatusBarProps } from "./status-bar/context";
import { StatusBarLegend } from "./status-bar/legend";
import { StatusBarPlot } from "./status-bar/plot";
import { StatusBarTooltip } from "./status-bar/tooltip";

/** Compose Plot, Tooltip, and Legend, or omit children for the complete chart. */
export function StatusBar({
  data,
  statuses,
  label,
  activeId,
  defaultActiveId,
  onActiveChange,
  children,
  className,
  ...props
}: StatusBarProps) {
  const model = useStatusBarModel({
    data,
    statuses,
    label,
    activeId,
    defaultActiveId,
    onActiveChange,
  });
  return (
    <StatusBarContext.Provider value={model}>
      <section
        aria-label={model.label}
        {...props}
        data-slot="status-bar"
        className={cn("min-w-0 w-full space-y-3", className)}
      >
        {children === undefined ? (
          <>
            <StatusBarPlot />
            <StatusBarTooltip />
            <StatusBarLegend />
          </>
        ) : (
          children
        )}
        {/* Color is never the only way to read the history. The complete data
            stays available to screen readers without dozens of tab stops. */}
        <div className="sr-only">
          <table>
            <caption>{model.label} data</caption>
            <thead>
              <tr>
                <th scope="col">Period</th>
                <th scope="col">Status</th>
                <th scope="col">Details</th>
              </tr>
            </thead>
            <tbody>
              {model.rows.map(({ datum, status }) => (
                <tr key={datum.id}>
                  <th scope="row">{datum.label}</th>
                  <td>{status.label}</td>
                  <td>{datum.description ?? ""}</td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      </section>
    </StatusBarContext.Provider>
  );
}

export { useStatusBar, STATUS_BAR_STATUSES } from "./status-bar/context";
export type { StatusBarProps, StatusBarDatum, StatusBarStatus } from "./status-bar/context";
export { StatusBarLegend } from "./status-bar/legend";
export type { StatusBarLegendProps } from "./status-bar/legend";
export { StatusBarPlot } from "./status-bar/plot";
export type { StatusBarPlotProps } from "./status-bar/plot";
export { StatusBarTooltip } from "./status-bar/tooltip";
export type { StatusBarTooltipProps, StatusBarTooltipData } from "./status-bar/tooltip";

"use client";

import { useReducedMotion } from "motion/react";
import {
  createContext,
  useCallback,
  useContext,
  useId,
  useLayoutEffect,
  useMemo,
  useRef,
  useState,
  type ComponentProps,
} from "react";
import { useHoverCapable } from "@/lib/hooks/use-hover-capable";

export interface StatusBarDatum {
  /** Stable, unique identity. Keep it when updating a period's status. */
  id: string;
  /** Consumer-formatted period, date, or event label. */
  label: string;
  /** Must match an ID in statuses. */
  status: string;
  description?: string;
}

export interface StatusBarStatus {
  id: string;
  label: string;
  /** Any CSS color, including theme variables. */
  color: string;
}

export const STATUS_BAR_STATUSES: readonly StatusBarStatus[] = [
  { id: "operational", label: "Operational", color: "#059669" },
  { id: "degraded", label: "Degraded", color: "#d97706" },
  { id: "outage", label: "Outage", color: "#e11d48" },
  { id: "maintenance", label: "Maintenance", color: "#2563eb" },
  { id: "unknown", label: "No data", color: "var(--muted-foreground)" },
];

export interface StatusBarProps extends ComponentProps<"section"> {
  /** Observations in display order. The chart never generates or aggregates data. */
  data: readonly StatusBarDatum[];
  /** Override the default status labels and colors, or define your own states. */
  statuses?: readonly StatusBarStatus[];
  label?: string;
  activeId?: string | null;
  defaultActiveId?: string | null;
  onActiveChange?: (id: string | null) => void;
}

export function useStatusBarModel({
  data,
  statuses = STATUS_BAR_STATUSES,
  label = "Status history",
  activeId,
  defaultActiveId = null,
  onActiveChange,
}: StatusBarProps) {
  const rows = useMemo(() => {
    const states = new Map<string, StatusBarStatus>();
    for (const status of statuses) {
      if (states.has(status.id)) throw new Error(`StatusBar: duplicate status ID "${status.id}".`);
      states.set(status.id, status);
    }
    const ids = new Set<string>();
    return data.map((datum) => {
      if (ids.has(datum.id)) throw new Error(`StatusBar: duplicate period ID "${datum.id}".`);
      ids.add(datum.id);
      const status = states.get(datum.status);
      if (!status) throw new Error(`StatusBar: define the status "${datum.status}" in statuses.`);
      return { datum, status };
    });
  }, [data, statuses]);
  const [internalId, setInternalId] = useState(defaultActiveId);
  // Resolve stale identities during render so returning periods never revive a cursor.
  if (internalId !== null && !rows.some(({ datum }) => datum.id === internalId))
    setInternalId(null);
  const requestedId = activeId === undefined ? internalId : activeId;
  const activeIndex = rows.findIndex(({ datum }) => datum.id === requestedId);
  const active = rows[activeIndex] ?? null;
  const [tooltipOpen, setTooltipOpen] = useState(false);
  const plotRef = useRef<HTMLDivElement>(null);
  const tooltipId = useId();
  const latest = useRef({ activeId, requestedId, onActiveChange });
  useLayoutEffect(() => {
    latest.current = { activeId, requestedId, onActiveChange };
  });
  const setActive = useCallback((id: string | null) => {
    const current = latest.current;
    if (current.activeId === undefined) setInternalId(id);
    if (current.requestedId !== id) current.onActiveChange?.(id);
  }, []);
  return {
    rows,
    statuses,
    label,
    active,
    activeIndex,
    setActive,
    plotRef,
    tooltipId,
    tooltipOpen,
    setTooltipOpen,
    reduce: useReducedMotion(),
    canHover: useHoverCapable(),
  };
}

export const StatusBarContext = createContext<ReturnType<typeof useStatusBarModel> | null>(null);

export function useStatusBar() {
  const context = useContext(StatusBarContext);
  if (!context) throw new Error("Status bar parts must be rendered inside StatusBar.");
  return context;
}

"use client";

import type { ComponentProps } from "react";
import { cn } from "@/lib/utils";
import { useStatusBar } from "./context";

export interface StatusBarLegendProps extends ComponentProps<"ul"> {
  showCounts?: boolean;
}

export function StatusBarLegend({
  className,
  showCounts = false,
  children,
  ...props
}: StatusBarLegendProps) {
  const { statuses, rows } = useStatusBar();
  return (
    <ul
      aria-label="Status legend"
      {...props}
      data-slot="status-bar-legend"
      className={cn(
        "flex flex-wrap items-center gap-x-4 gap-y-2 text-xs text-muted-foreground",
        className,
      )}
    >
      {children ??
        statuses.map((status) => (
          <li key={status.id} className="flex items-center gap-1.5">
            <span
              aria-hidden="true"
              className="h-3 w-1.5 rounded-full"
              style={{ backgroundColor: status.color }}
            />
            <span>{status.label}</span>
            {showCounts ? (
              <span className="tabular-nums">
                ({rows.filter((row) => row.status.id === status.id).length})
              </span>
            ) : null}
          </li>
        ))}
    </ul>
  );
}

"use client";

import { AnimatePresence, motion } from "motion/react";
import { useRef, type PointerEvent, type ReactNode } from "react";
import { EASE_OUT, SPRING_PRESS } from "@/lib/ease";
import { cn } from "@/lib/utils";
import { useStatusBar } from "./context";

// Spread a short entrance across the entire history, even with hundreds of periods.
const ENTRANCE_SPAN = 0.18;
const ENTRANCE_TRANSFORM = ["translateY(4px) scaleY(0.9)", "translateY(0px) scaleY(1)"];

export interface StatusBarPlotProps {
  className?: string;
  /** Customize segment height and roundness independently of the 44px hit area. */
  barClassName?: string;
  showLabels?: boolean;
  children?: ReactNode;
}

export function StatusBarPlot({
  className,
  barClassName,
  showLabels = true,
  children,
}: StatusBarPlotProps) {
  const {
    rows,
    label,
    activeIndex,
    setActive,
    plotRef,
    tooltipId,
    tooltipOpen,
    setTooltipOpen,
    reduce,
    canHover,
  } = useStatusBar();
  const pointerDriven = useRef(false);
  const focused = useRef(false);
  const lastPointerId = useRef<string | null>(null);
  const index = Math.max(activeIndex, 0);
  const row = rows[index];
  const inspectPointer = (event: PointerEvent<HTMLInputElement>) => {
    const bounds = event.currentTarget.getBoundingClientRect();
    if (!bounds.width) return;
    const fraction = Math.min(1, Math.max(0, (event.clientX - bounds.left) / bounds.width));
    const id = rows[Math.min(rows.length - 1, Math.floor(fraction * rows.length))].datum.id;
    setActive(id);
    if (lastPointerId.current !== id) setTooltipOpen(true);
    lastPointerId.current = id;
  };
  if (!rows.length)
    return <p className={cn("py-4 text-sm text-muted-foreground", className)}>No status data</p>;
  return (
    <div data-slot="status-bar-plot" className={cn("min-w-0 space-y-1.5", className)}>
      <div
        ref={plotRef}
        className="relative h-11 rounded-md has-focus-visible:outline-2 has-focus-visible:outline-offset-4 has-focus-visible:outline-ring"
      >
        <div aria-hidden="true" className="flex h-full items-center gap-0.5 sm:gap-1">
          {rows.map(({ datum, status }, i) => {
            const active = tooltipOpen && activeIndex === i;
            const delay = reduce ? 0 : (i / Math.max(rows.length - 1, 1)) * ENTRANCE_SPAN;
            return (
              <motion.span
                key={datum.id}
                data-status-period={datum.id}
                data-status={status.id}
                className={cn("relative block h-8 min-w-0 flex-1 rounded-full", barClassName)}
                initial={{ opacity: 0 }}
                whileInView={
                  reduce ? { opacity: 1 } : { opacity: 1, transform: ENTRANCE_TRANSFORM }
                }
                viewport={{ once: true }}
                transition={{
                  opacity: { duration: reduce ? 0.15 : 0.24, ease: EASE_OUT, delay },
                  transform: { ...SPRING_PRESS, delay },
                }}
              >
                {/* Stable period keys keep the history still. Only the changed
                    color layer crossfades when a new status arrives. */}
                <AnimatePresence initial={false}>
                  <motion.span
                    key={`${status.id}:${status.color}`}
                    className="pointer-events-none absolute inset-0 rounded-[inherit]"
                    style={{ backgroundColor: status.color }}
                    initial={{ opacity: 0 }}
                    animate={{ opacity: 1 }}
                    exit={{ opacity: 0, transition: { duration: 0.12, ease: EASE_OUT } }}
                    transition={{ duration: 0.16, ease: EASE_OUT }}
                  />
                </AnimatePresence>
                <motion.span
                  className="pointer-events-none absolute -inset-0.5 rounded-[inherit] ring-1 ring-foreground/60"
                  initial={false}
                  animate={{ opacity: active ? 1 : 0 }}
                  transition={{ duration: 0.1, ease: EASE_OUT }}
                />
              </motion.span>
            );
          })}
        </div>
        <input
          type="range"
          aria-label={`${label}: inspect period`}
          min={0}
          max={rows.length - 1}
          step={1}
          value={index}
          aria-valuetext={[row.datum.label, row.status.label, row.datum.description]
            .filter(Boolean)
            .join(". ")}
          aria-describedby={tooltipOpen && activeIndex >= 0 ? tooltipId : undefined}
          className="absolute inset-0 m-0 h-full w-full cursor-crosshair opacity-0"
          onFocus={() => {
            focused.current = true;
            if (!pointerDriven.current) {
              setActive(row.datum.id);
              setTooltipOpen(true);
            }
          }}
          onBlur={() => {
            focused.current = false;
            pointerDriven.current = false;
            setTooltipOpen(false);
          }}
          onPointerEnter={(event) => {
            if (canHover && event.pointerType !== "touch") inspectPointer(event);
          }}
          onPointerMove={(event) => {
            if (
              event.pointerType === "touch" ? event.buttons === 1 : canHover || event.buttons === 1
            )
              inspectPointer(event);
          }}
          onPointerLeave={() => {
            lastPointerId.current = null;
            if (!focused.current || pointerDriven.current) setTooltipOpen(false);
          }}
          onPointerDown={(event) => {
            pointerDriven.current = true;
            lastPointerId.current = null;
            inspectPointer(event);
          }}
          onPointerCancel={() => {
            pointerDriven.current = false;
            setTooltipOpen(false);
          }}
          onClick={() => {
            // Native range changes finish before click. Release the pointer
            // guard so subsequent assistive-technology changes are accepted.
            pointerDriven.current = false;
          }}
          onKeyDown={(event) => {
            pointerDriven.current = false;
            if (event.key === "Escape") setTooltipOpen(false);
            else if (
              ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(event.key)
            )
              setTooltipOpen(true);
          }}
          onChange={(event) => {
            // Native thumb travel differs from equal-width bars. Pointer hit
            // testing owns pointer gestures; the range owns keyboard and AT input.
            if (pointerDriven.current) return;
            const next = rows[Number(event.target.value)];
            if (next) {
              setActive(next.datum.id);
              setTooltipOpen(true);
            }
          }}
        />
      </div>
      {showLabels ? (
        <div className="flex justify-between gap-4 text-xs text-muted-foreground">
          <span>{rows[0].datum.label}</span>
          <span>{rows.at(-1)?.datum.label}</span>
        </div>
      ) : null}
      {children}
    </div>
  );
}

"use client";

import type { ReactNode } from "react";
import { Tooltip } from "@/components/motion/tooltip";
import { cn } from "@/lib/utils";
import { useStatusBar, type StatusBarDatum, type StatusBarStatus } from "./context";

export interface StatusBarTooltipData {
  datum: StatusBarDatum;
  status: StatusBarStatus;
  index: number;
}

export interface StatusBarTooltipProps {
  children?: ReactNode | ((data: StatusBarTooltipData) => ReactNode);
  className?: string;
  side?: "top" | "right" | "bottom" | "left";
}

export function StatusBarTooltip({ children, className, side = "top" }: StatusBarTooltipProps) {
  const { active, activeIndex, rows, plotRef, tooltipId, tooltipOpen, setTooltipOpen } =
    useStatusBar();
  return (
    <Tooltip
      id={tooltipId}
      anchorRef={plotRef}
      anchorPoint={{ x: (Math.max(activeIndex, 0) + 0.5) / Math.max(rows.length, 1), y: 0.1 }}
      open={tooltipOpen && active !== null}
      onOpenChange={setTooltipOpen}
      side={side}
      className={cn("max-w-64", className)}
      content={
        active
          ? typeof children === "function"
            ? children({ ...active, index: activeIndex })
            : (children ?? (
                <span className="flex flex-col gap-1">
                  <span className="text-muted-foreground">{active.datum.label}</span>
                  <span className="flex items-center gap-2 font-medium">
                    <span
                      aria-hidden="true"
                      className="size-1.5 shrink-0 rounded-full"
                      style={{ backgroundColor: active.status.color }}
                    />
                    {active.status.label}
                  </span>
                  {active.datum.description ? (
                    <span className="text-muted-foreground">{active.datum.description}</span>
                  ) : null}
                </span>
              ))
          : null
      }
    />
  );
}

"use client";

import { AnimatePresence } from "motion/react";
import { TooltipPositioner } from "./tooltip/positioner";
import { useTooltipPointer } from "./tooltip/use-position";
import {
  cloneElement,
  isValidElement,
  type PointerEvent,
  type ReactElement,
  type ReactNode,
  type RefObject,
  useCallback,
  useEffect,
  useId,
  useRef,
  useState,
} from "react";
import { createPortal } from "react-dom";
import { TooltipSurface } from "@/components/motion/tooltip-surface";
import { useDismiss } from "@/lib/hooks/use-dismiss";
import { useHoverGesture } from "@/lib/hooks/use-hover-gesture";
import { useTapGesture } from "@/lib/hooks/use-tap-gesture";
import { cn } from "@/lib/utils";

type Side = "top" | "right" | "bottom" | "left";

export interface TooltipProps {
  content: ReactNode;
  children?: ReactElement;
  /** Existing trigger for controlled integrations such as chart cells. */
  anchorRef?: RefObject<HTMLElement | SVGElement | null>;
  /** Point within the anchor, as fractions of its rendered width and height. */
  anchorPoint?: { x: number; y: number };
  /** Follow real pointer coordinates; keyboard focus still uses the anchor. */
  followCursor?: boolean;
  open?: boolean;
  onOpenChange?: (open: boolean) => void;
  id?: string;
  side?: Side;
  /** Delay before showing (ms). Default 120. */
  delay?: number;
  className?: string;
  /** Classes for the outer wrapper span. Use to fix baseline / fill parent. */
  wrapperClassName?: string;
}

// Once any tooltip has just closed, neighbouring tooltips open without the
// initial delay — moving along a toolbar feels instant after the first one.
const WARM_WINDOW_MS = 300;
let lastHiddenAt = 0;

export function Tooltip({
  content,
  children,
  side = "top",
  delay = 120,
  className,
  wrapperClassName,
  anchorRef: externalAnchorRef,
  anchorPoint,
  followCursor = false,
  open: controlledOpen,
  onOpenChange,
  id: providedId,
}: TooltipProps) {
  const [internalOpen, setInternalOpen] = useState(false);
  const open = controlledOpen ?? internalOpen;
  const setOpen = useCallback(
    (next: boolean) => {
      if (controlledOpen === undefined) setInternalOpen(next);
      onOpenChange?.(next);
    },
    [controlledOpen, onOpenChange],
  );
  const generatedId = useId();
  const id = providedId ?? generatedId;
  const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
  const wrapperRef = useRef<HTMLSpanElement>(null);
  const anchorRef = externalAnchorRef ?? wrapperRef;
  const hover = useHoverGesture();
  const floatingRef = useRef<HTMLSpanElement | null>(null);
  const pointer = useTooltipPointer(anchorRef, followCursor);
  const focused = useRef(false);

  const show = useCallback(() => {
    if (timer.current) clearTimeout(timer.current);
    if (open) return;
    const warm = Date.now() - lastHiddenAt < WARM_WINDOW_MS;
    if (warm) {
      setOpen(true);
      return;
    }
    timer.current = setTimeout(() => {
      setOpen(true);
    }, delay);
  }, [delay, setOpen, open]);

  const hide = useCallback(() => {
    if (timer.current) {
      clearTimeout(timer.current);
      timer.current = null;
    }
    if (open) lastHiddenAt = Date.now();
    setOpen(false);
  }, [open, setOpen]);

  const leave = useCallback(() => {
    if (focused.current) return;
    if (timer.current) clearTimeout(timer.current);
    // Bridge the small physical gap to a stationary, readable tooltip.
    if (followCursor) hide();
    else timer.current = setTimeout(hide, 100);
  }, [followCursor, hide]);
  const insideTooltip = useCallback(
    (target: Element) => Boolean(floatingRef.current?.contains(target)),
    [],
  );

  // A finger never hovers, and Safari does not focus a button on tap either, so
  // the label is only reachable if the tap itself opens the tooltip. A click
  // carries no pointerType, so the pointerdown that preceded it is what says
  // whether this was a tap; keyboard activation arrives with no pointerdown at
  // all, and focus has already shown the label there.
  const tap = useTapGesture<boolean>();

  const toggleOnTap = useCallback(() => {
    const gesture = tap.take();
    if (!gesture || gesture.pointerType === "mouse") return;
    if (gesture.state) {
      hide();
      return;
    }
    if (timer.current) clearTimeout(timer.current);
    setOpen(true);
  }, [hide, tap, setOpen]);

  // ...and closed again by the next tap that lands somewhere else. The label
  // covers nothing interactive, so that tap passes through to what it hit.
  useDismiss(open, hide, anchorRef, { ignore: insideTooltip });

  useEffect(
    () => () => {
      if (timer.current) clearTimeout(timer.current);
    },
    [],
  );

  if (!externalAnchorRef && !isValidElement(children)) return children;

  // The label describes the trigger, so it has to name the trigger itself.
  // Everything else the tooltip needs is read off the anchor below instead of
  // cloned on: a handler written onto the child is the child's handler as far
  // as that child can tell, and a component that owns its activation —
  // hard-wiring onClick and spreading the rest of its props over it, as
  // ThemeToggle does — then runs the tooltip's instead of its own. Composing
  // with `props.onClick` cannot save it either, because a component element's
  // props hold nothing the component does internally.
  const trigger = isValidElement(children)
    ? cloneElement(children as ReactElement<Record<string, unknown>>, {
        "aria-describedby":
          [(children.props as Record<string, unknown>)["aria-describedby"], open ? id : undefined]
            .filter(Boolean)
            .join(" ") || undefined,
      })
    : null;

  return (
    <>
      {!externalAnchorRef ? (
        // biome-ignore lint/a11y/noStaticElementInteractions: This wrapper observes bubbling trigger events without replacing the control's handlers.
        <span
          ref={wrapperRef}
          className={cn("relative inline-flex align-middle", wrapperClassName)}
          // Pointer events, not the mouse pair: a tap fires compatibility
          // mouseenter/mouseleave that carry no pointerType, which raced the tap
          // path into opening and closing the same label.
          onPointerEnter={(event: PointerEvent) => {
            if (hover.enter(event)) show();
          }}
          onPointerLeave={(event: PointerEvent) => {
            if (hover.leave(event)) leave();
          }}
          onFocus={() => {
            focused.current = true;
            show();
          }}
          onBlur={() => {
            focused.current = false;
            hide();
          }}
          onPointerDown={(event: PointerEvent) => tap.start(event, open)}
          // A gesture the platform took away sends no click, and a key press
          // starts an activation that never had a pointer behind it. Either way
          // the record has to go, or the next click reads a finger that has long
          // since lifted.
          onPointerCancel={tap.drop}
          onKeyDown={(event) => {
            tap.drop();
            if (event.key === "Escape") hide();
          }}
          onClick={toggleOnTap}
        >
          {trigger}
        </span>
      ) : null}
      {typeof document !== "undefined"
        ? createPortal(
            <AnimatePresence>
              {open ? (
                <TooltipPositioner
                  key="tooltip"
                  anchorRef={anchorRef}
                  floatingRef={floatingRef}
                  anchorPoint={anchorPoint}
                  followCursor={followCursor}
                  side={side}
                  onDismiss={hide}
                  pointer={pointer}
                >
                  {(positioned, isPresent) => (
                    <TooltipSurface
                      id={id}
                      ready={positioned}
                      side={side}
                      onPointerEnter={() => {
                        if (timer.current) clearTimeout(timer.current);
                      }}
                      onPointerLeave={leave}
                      style={{
                        maxWidth: "calc(100vw - 16px)",
                        whiteSpace: "normal",
                        pointerEvents: isPresent && !followCursor ? "auto" : "none",
                      }}
                      className={cn("overflow-hidden", className)}
                    >
                      {content}
                    </TooltipSurface>
                  )}
                </TooltipPositioner>
              ) : null}
            </AnimatePresence>,
            document.body,
          )
        : null}
    </>
  );
}

"use client";

import { useIsPresent } from "motion/react";
import { useCallback, useState, type ReactNode } from "react";
import { useTooltipPosition } from "./use-position";

type PositionProps = Parameters<typeof useTooltipPosition>[0];

/** Readiness lives with the mounted overlay, not a trigger ref's attach/detach cycle. */
export function TooltipPositioner({
  children,
  ...position
}: Omit<PositionProps, "open" | "onPosition"> & {
  children: (ready: boolean, present: boolean) => ReactNode;
}) {
  const present = useIsPresent();
  const [ready, setReady] = useState(false);
  const onPosition = useCallback(() => setReady(true), []);
  useTooltipPosition({ ...position, open: present, onPosition });
  return (
    <span
      ref={position.floatingRef}
      inert={!present}
      aria-hidden={!present || undefined}
      className="pointer-events-none fixed left-0 top-0 z-[9999] w-max"
      style={{ visibility: "hidden", maxWidth: "calc(100vw - 16px)" }}
    >
      {children(ready, present)}
    </span>
  );
}

"use client";

import {
  autoUpdate,
  computePosition,
  flip,
  offset,
  shift,
  type Placement,
  type VirtualElement,
} from "@floating-ui/dom";
import { useCallback, useLayoutEffect, useRef, type RefObject } from "react";

export type TooltipSide = "top" | "right" | "bottom" | "left";
export type TooltipPoint = { x: number; y: number };

/** Position is geometry, not animation. One write per frame, never a spring chasing a pointer. */
export function useTooltipPosition({
  open,
  anchorRef,
  floatingRef,
  anchorPoint,
  followCursor,
  side,
  onDismiss,
  onPosition,
  pointer,
}: {
  open: boolean;
  anchorRef: RefObject<HTMLElement | SVGElement | null>;
  floatingRef: RefObject<HTMLSpanElement | null>;
  anchorPoint?: TooltipPoint;
  followCursor: boolean;
  side: TooltipSide;
  onDismiss: () => void;
  onPosition: () => void;
  pointer: ReturnType<typeof useTooltipPointer>;
}) {
  const { cursor, onMove } = pointer;
  const cursorSide = useRef<Placement | null>(null);
  useLayoutEffect(() => {
    cursorSide.current = open ? side : null;
  }, [open, side]);
  const frame = useRef<number | null>(null);
  const version = useRef(0);
  const update = useRef<() => void>(() => {});
  const schedule = useCallback(() => {
    // Invalidate older async calculations as soon as new geometry is requested.
    version.current++;
    if (frame.current !== null) return;
    frame.current = requestAnimationFrame(() => {
      frame.current = null;
      update.current();
    });
  }, []);
  useLayoutEffect(() => {
    onMove.current = schedule;
    return () => {
      onMove.current = null;
    };
  }, [onMove, schedule]);
  const pointX = anchorPoint?.x;
  const pointY = anchorPoint?.y;

  // Latest committed inputs are read without recreating observers for every period/content update.
  useLayoutEffect(() => {
    update.current = () => {
      const anchor = anchorRef.current;
      const floating = floatingRef.current;
      if (!open || !anchor || !floating) return;
      const revision = ++version.current;
      const currentCursor = followCursor ? cursor.current : null;
      const reference: Element | VirtualElement =
        currentCursor || pointX !== undefined || pointY !== undefined
          ? {
              contextElement: anchor,
              getBoundingClientRect: () => {
                const rect = anchor.getBoundingClientRect();
                const x = currentCursor?.x ?? rect.left + rect.width * (pointX ?? 0.5);
                const y = currentCursor?.y ?? rect.top + rect.height * (pointY ?? 0.5);
                return { x, y, left: x, right: x, top: y, bottom: y, width: 0, height: 0 };
              },
            }
          : anchor;
      void computePosition(reference, floating, {
        strategy: "fixed",
        placement: currentCursor ? (cursorSide.current ?? side) : side,
        middleware: [offset(currentCursor ? 12 : 8), flip({ padding: 8 }), shift({ padding: 8 })],
      }).then(({ x, y, placement }) => {
        if (version.current !== revision || !floating.isConnected) return;
        // Hold the chosen side for this hover session. Crossing a flip threshold
        // repeatedly must not bounce the surface above and below the pointer.
        if (currentCursor) cursorSide.current = placement;
        else cursorSide.current = null;
        const dpr = window.devicePixelRatio || 1;
        floating.style.transform = `translate3d(${Math.round(x * dpr) / dpr}px, ${Math.round(y * dpr) / dpr}px, 0)`;
        const origin = {
          top: "center bottom",
          bottom: "center top",
          left: "right center",
          right: "left center",
        };
        floating.style.setProperty(
          "--tooltip-origin",
          origin[placement.split("-")[0] as TooltipSide],
        );
        floating.style.visibility = "visible";
        floating.dataset.placement = placement;
        onPosition();
      });
    };
    if (open) schedule();
  }, [
    open,
    anchorRef,
    floatingRef,
    followCursor,
    pointX,
    pointY,
    side,
    schedule,
    onPosition,
    cursor,
  ]);

  useLayoutEffect(() => {
    const anchor = anchorRef.current;
    const floating = floatingRef.current;
    if (!open || !anchor || !floating) return;
    const stop = autoUpdate(anchor, floating, schedule);
    const onScroll = () => {
      // A stationary pointer no longer describes the same chart point after scrolling.
      if (followCursor && cursor.current) onDismiss();
    };
    window.addEventListener("scroll", onScroll, true);
    return () => {
      stop();
      window.removeEventListener("scroll", onScroll, true);
      version.current++;
      if (frame.current !== null) cancelAnimationFrame(frame.current);
      frame.current = null;
    };
  }, [open, anchorRef, floatingRef, followCursor, onDismiss, schedule, cursor]);

  useLayoutEffect(
    () => () => {
      version.current++;
      if (frame.current !== null) cancelAnimationFrame(frame.current);
    },
    [],
  );
}

/** Pointer lifetime belongs to the trigger, including the opening delay. */
export function useTooltipPointer(
  anchorRef: RefObject<HTMLElement | SVGElement | null>,
  followCursor: boolean,
) {
  const cursor = useRef<TooltipPoint | null>(null);
  const onMove = useRef<(() => void) | null>(null);
  const pointerFocus = useRef(false);
  useLayoutEffect(() => {
    const anchor = anchorRef.current;
    if (!anchor || !followCursor) return;
    const point = (event: PointerEvent) => {
      if (event.type === "pointermove" && event.pointerType === "touch" && !event.buttons) return;
      cursor.current = { x: event.clientX, y: event.clientY };
      if (event.type === "pointerdown") pointerFocus.current = true;
      onMove.current?.();
    };
    const keyboard = () => {
      cursor.current = null;
      pointerFocus.current = false;
      onMove.current?.();
    };
    const focus = () => {
      if (!pointerFocus.current) cursor.current = null;
      pointerFocus.current = false;
      onMove.current?.();
    };
    const leave = () => {
      cursor.current = null;
    };
    anchor.addEventListener("pointerenter", point as EventListener, { passive: true });
    anchor.addEventListener("pointermove", point as EventListener, { passive: true });
    anchor.addEventListener("pointerdown", point as EventListener, { passive: true });
    anchor.addEventListener("pointerleave", leave);
    anchor.addEventListener("pointercancel", leave);
    anchor.addEventListener("keydown", keyboard);
    anchor.addEventListener("focusin", focus);
    return () => {
      cursor.current = null;
      anchor.removeEventListener("pointerenter", point as EventListener);
      anchor.removeEventListener("pointermove", point as EventListener);
      anchor.removeEventListener("pointerdown", point as EventListener);
      anchor.removeEventListener("pointerleave", leave);
      anchor.removeEventListener("pointercancel", leave);
      anchor.removeEventListener("keydown", keyboard);
      anchor.removeEventListener("focusin", focus);
    };
  }, [anchorRef, followCursor]);

  return { cursor, onMove };
}