Bar Chart

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/bar-chart

import { cn } from "@/lib/utils";
import { BarChartContext, type BarChartProps, useBarChartModel } from "./bar-chart/context";
import { BarChartLegend } from "./bar-chart/legend";
import { BarChartPlot } from "./bar-chart/plot";
import { BarChartTooltip } from "./bar-chart/tooltip";
import { XYDataTable } from "./xy/data-table";

/** Compose Plot, Tooltip and Legend, or omit children for the complete chart. */
export function BarChart({
  series,
  categories,
  layout,
  orientation,
  sort,
  max,
  activeId,
  defaultActiveId,
  onActiveChange,
  hiddenSeries,
  defaultHiddenSeries,
  onHiddenSeriesChange,
  formatValue,
  formatTick,
  label,
  children,
  className,
  ...props
}: BarChartProps) {
  const model = useBarChartModel({
    series,
    categories,
    layout,
    orientation,
    sort,
    max,
    activeId,
    defaultActiveId,
    onActiveChange,
    hiddenSeries,
    defaultHiddenSeries,
    onHiddenSeriesChange,
    formatValue,
    formatTick,
    label,
  });
  return (
    <BarChartContext.Provider value={model}>
      <section
        aria-label={model.label}
        {...props}
        data-slot="bar-chart"
        className={cn("w-full min-w-0 space-y-3", className)}
      >
        {children === undefined ? (
          <>
            <BarChartPlot />
            <BarChartTooltip />
            {model.rows.length > 1 ? <BarChartLegend /> : null}
          </>
        ) : (
          children
        )}
        <XYDataTable
          label={model.label}
          rows={model.rows}
          categories={model.categories}
          formatValue={model.formatValue}
        />
      </section>
    </BarChartContext.Provider>
  );
}

export type { BarChartProps } from "./bar-chart/context";
export { useBarChart } from "./bar-chart/context";
export type { BarChartLegendProps } from "./bar-chart/legend";
export { BarChartLegend } from "./bar-chart/legend";
export type { BarChartPlotProps } from "./bar-chart/plot";
export { BarChartPlot } from "./bar-chart/plot";
export type { BarChartTooltipData, BarChartTooltipProps } from "./bar-chart/tooltip";
export { BarChartTooltip } from "./bar-chart/tooltip";
export type { XYSeries as BarChartSeries } from "./xy/model";

"use client";

import { useReducedMotion } from "motion/react";
import { type ComponentProps, createContext, type ReactNode, useContext, useMemo, useState } from "react";
import { useHoverCapable } from "@/lib/hooks/use-hover-capable";
import { normalizeXY, type XYSeries } from "../xy/model";
import { niceDomain } from "../xy/scale";
import { useControllable, useInspection } from "../xy/use-inspection";

export interface BarChartProps extends Omit<ComponentProps<"section">, "children"> {
  /** Nonnegative values aligned with categories. Missing or negative values leave a gap. */
  series: readonly XYSeries[];
  /** Unique category labels in display order. */
  categories: readonly string[];
  layout?: "grouped" | "stacked";
  orientation?: "vertical" | "horizontal";
  /** Order categories by their visible total. Bars glide to their new place when it changes. */
  sort?: "none" | "ascending" | "descending";
  /** Fixed top of the value axis. Defaults to a rounded value above the tallest bar. */
  max?: number;
  /** Inspected category, by label. */
  activeId?: string | null;
  defaultActiveId?: string | null;
  onActiveChange?: (id: string | null) => void;
  /** Series ids hidden through the legend. */
  hiddenSeries?: readonly string[];
  defaultHiddenSeries?: readonly string[];
  onHiddenSeriesChange?: (ids: readonly string[]) => void;
  formatValue?: (value: number) => string;
  /** Axis tick labels. Defaults to compact notation (1.2K). */
  formatTick?: (value: number) => string;
  label?: string;
  children?: ReactNode;
}

const number = new Intl.NumberFormat("en", { maximumFractionDigits: 2 });
const compact = new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 });
const NONE: readonly string[] = [];

export function useBarChartModel({
  series,
  categories,
  layout = "grouped",
  orientation = "vertical",
  sort = "none",
  max,
  activeId,
  defaultActiveId,
  onActiveChange,
  hiddenSeries,
  defaultHiddenSeries = NONE,
  onHiddenSeriesChange,
  formatValue = (value) => number.format(value),
  formatTick = (value) => compact.format(value),
  label = "Bar chart",
}: Omit<BarChartProps, "children">) {
  const data = useMemo(() => normalizeXY(series, categories, { nonnegative: true }), [series, categories]);
  const [hidden, setHidden] = useControllable(hiddenSeries, defaultHiddenSeries, onHiddenSeriesChange);
  const visibleRows = data.rows.filter((row) => !hidden.includes(row.id));
  const [hovered, setHovered] = useState<string | null>(null);
  const highlight = visibleRows.some((row) => row.id === hovered) ? hovered : null;
  const totals = data.categories.map((_, i) =>
    visibleRows.reduce((sum, row) => sum + (row.values[i] ?? 0), 0),
  );
  // Visual order. Ties keep their given order so equal bars never swap places.
  const order = data.categories.map((_, i) => i);
  if (sort !== "none")
    order.sort((a, b) => (sort === "ascending" ? totals[a] - totals[b] : totals[b] - totals[a]) || a - b);
  const domain = niceDomain(
    layout === "stacked"
      ? totals
      : visibleRows.flatMap((row) => row.values.filter((value): value is number => value !== null)),
    { includeZero: true, fixed: max !== undefined && max > 0 ? [0, max] : undefined },
  );
  const inspection = useInspection({
    ids: data.categories,
    activeId,
    defaultActiveId,
    onActiveChange,
  });
  return {
    ...data,
    ...inspection,
    visibleRows,
    totals,
    order,
    hidden,
    toggle: (id: string) =>
      setHidden(hidden.includes(id) ? hidden.filter((h) => h !== id) : [...hidden, id]),
    highlight,
    setHovered,
    domain,
    layout,
    orientation,
    formatValue,
    formatTick,
    label,
    reduce: useReducedMotion() ?? false,
    canHover: useHoverCapable(),
  };
}

export type BarChartModel = ReturnType<typeof useBarChartModel>;

export const BarChartContext = createContext<BarChartModel | null>(null);

export function useBarChart() {
  const context = useContext(BarChartContext);
  if (!context) throw new Error("Bar chart parts must be rendered inside BarChart.");
  return context;
}

"use client";

import { XYLegend } from "../xy/legend";
import { useBarChart } from "./context";

export interface BarChartLegendProps {
  className?: string;
}

/** Toggle a series to hide it; its bars collapse and the axis rescales. */
export function BarChartLegend({ className }: BarChartLegendProps) {
  const { rows, hidden, toggle, setHovered, canHover } = useBarChart();
  return (
    <XYLegend
      rows={rows}
      hidden={hidden}
      onToggle={toggle}
      onHover={setHovered}
      canHover={canHover}
      label="Series"
      className={className}
    />
  );
}

"use client";

/* Bars grow out of the baseline with a short stagger the first time the chart
 * scrolls into view. Each bar is a unit rect placed with translate and scale,
 * plus a rounded cap that only translates, so value changes animate
 * transforms alone and the corners never stretch. Categories glide to a new
 * rank when sorting reorders them; a hidden series collapses into the
 * baseline while the axis rescales. Reduced motion: no growth, glide or
 * stagger, values update in place. */

import { motion, type Transition, useInView } from "motion/react";
import { useEffect, useId, useState } from "react";
import { EASE_OUT, SPRING_LAYOUT } from "@/lib/ease";
import { cn } from "@/lib/utils";
import { XYGridLines, XYTickLabels } from "../xy/axis";
import { XYInspector } from "../xy/inspector";
import { labelStride } from "../xy/scale";
import { useElementWidth } from "../xy/use-width";
import { useBarChart } from "./context";

/** Gutter for value labels (vertical bars), in px. */
const VALUE_AXIS = 44;
const PAD = { top: 12, right: 12, bottom: 0 } as const;
/** Fraction of each category slot the bars occupy. */
const FILL = 0.7;
const GAP = 3;
const MAX_BAR = 32;
const MAX_STACK = 56;
const RADIUS = 4;
// Collapsing to an exact zero scale can leave a hairline in some browsers.
const NONE = 0.0001;

export interface BarChartPlotProps {
  /** Plot height in px. Horizontal charts default to 36px per category. */
  height?: number;
  /** Width of the category label gutter for horizontal bars, in px. */
  labelWidth?: number;
  showGrid?: boolean;
  className?: string;
}

export function BarChartPlot({
  height: heightProp,
  labelWidth = 96,
  showGrid = true,
  className,
}: BarChartPlotProps) {
  const {
    rows,
    categories,
    visibleRows,
    hidden,
    highlight,
    order,
    totals,
    domain,
    layout,
    orientation,
    formatValue,
    formatTick,
    label,
    activeIndex,
    setActive,
    open,
    setOpen,
    touching,
    setTouching,
    plotRef,
    tooltipId,
    reduce,
    canHover,
  } = useBarChart();
  const { ref, width } = useElementWidth<HTMLDivElement>();
  const inView = useInView(ref, { once: true, amount: 0.3 });
  const [intro, setIntro] = useState(true);
  useEffect(() => {
    if (!inView) return;
    const timer = setTimeout(() => setIntro(false), 900);
    return () => clearTimeout(timer);
  }, [inView]);
  const clipId = useId();
  const n = categories.length;
  const vertical = orientation === "vertical";
  const height = heightProp ?? (vertical ? 288 : Math.max(160, n * 36));

  if (!n || !rows.length)
    return (
      <p
        className={cn("flex items-center justify-center text-sm text-muted-foreground", className)}
        style={{ height }}
      >
        No data
      </p>
    );

  // Band axis runs along categories; value axis along magnitudes.
  const bandStart = vertical ? VALUE_AXIS : 0;
  const bandLength = vertical ? Math.max(0, width - VALUE_AXIS - PAD.right) : height;
  const valueStart = vertical ? height - PAD.bottom : labelWidth;
  const valueLength = vertical
    ? height - PAD.top - PAD.bottom
    : Math.max(0, width - labelWidth - PAD.right * 2);
  const slot = bandLength / n;
  const scale = (value: number) => (value / (domain.max || 1)) * valueLength;
  /** Value to px along the value axis, for gridlines and tick labels. */
  const valueAt = (value: number) => (vertical ? valueStart - scale(value) : valueStart + scale(value));

  const k = Math.max(1, visibleRows.length);
  const grouped = layout === "grouped";
  const thickness = grouped
    ? Math.max(1, Math.min(MAX_BAR, (slot * FILL - (k - 1) * GAP) / k))
    : Math.max(1, Math.min(MAX_STACK, slot * FILL));
  const groupThickness = grouped ? k * thickness + (k - 1) * GAP : thickness;
  const radius = Math.min(RADIUS, thickness / 2);
  const revealed = inView || reduce;
  const spring: Transition = reduce ? { duration: 0 } : SPRING_LAYOUT;
  const activeRank = activeIndex >= 0 ? order.indexOf(activeIndex) : -1;
  const stride = labelStride(n, bandLength, vertical ? 56 : 18);

  return (
    <div className={cn("min-w-0 select-none", className)}>
      <div ref={ref} className="relative w-full" style={{ height }}>
        {width > 0 ? (
          <>
            <svg
              aria-hidden="true"
              width={width}
              height={height}
              className="absolute inset-0 overflow-visible"
            >
              <defs>
                <clipPath id={clipId}>
                  {/* Caps of short bars would poke through the baseline. */}
                  {vertical ? (
                    <rect x={0} y={-16} width={width} height={valueStart + 16} />
                  ) : (
                    <rect x={valueStart} y={0} width={width} height={height} />
                  )}
                </clipPath>
              </defs>
              {showGrid ? (
                <XYGridLines
                  ticks={domain.ticks}
                  position={valueAt}
                  axis={vertical ? "y" : "x"}
                  from={vertical ? bandStart : 0}
                  to={vertical ? bandStart + bandLength : height}
                  reduce={reduce}
                />
              ) : null}
              {/* A soft band behind the inspected category, the full depth of
                  the plot, gliding between slots. Bars stay at full strength. */}
              <motion.rect
                x={0}
                y={0}
                width={vertical ? slot : valueLength + PAD.right}
                height={vertical ? valueLength : slot}
                rx={4}
                fill="currentColor"
                className="text-foreground"
                initial={false}
                animate={{
                  x: vertical ? bandStart + Math.max(activeRank, 0) * slot : valueStart,
                  y: vertical ? PAD.top : Math.max(activeRank, 0) * slot,
                  opacity: open && activeRank >= 0 ? 0.05 : 0,
                }}
                // The band tracks a finger directly; any glide under touch reads as lag.
                transition={{
                  default: touching ? { duration: 0 } : spring,
                  opacity: { duration: 0.1, ease: EASE_OUT },
                }}
              />
              <g clipPath={`url(#${clipId})`}>
                {order.map((categoryIndex, rank) => {
                  const category = categories[categoryIndex];
                  const delay = intro && !reduce ? Math.min(rank * 0.035, 0.4) : 0;
                  const position = bandStart + rank * slot;
                  let stack = 0;
                  let visibleSlot = 0;
                  const topRow = [...visibleRows].reverse().find((row) => (row.values[categoryIndex] ?? 0) > 0);
                  return (
                    <motion.g
                      key={category}
                      initial={false}
                      animate={{ [vertical ? "x" : "y"]: position }}
                      transition={spring}
                    >
                      {rows.map((row) => {
                        const isHidden = hidden.includes(row.id);
                        const value = isHidden ? 0 : (row.values[categoryIndex] ?? 0);
                        const length = revealed ? scale(value) : 0;
                        const start = grouped || !revealed ? 0 : scale(stack);
                        const offset =
                          (slot - groupThickness) / 2 +
                          (grouped
                            ? (isHidden ? (k - 1) / 2 : visibleSlot) * (thickness + GAP)
                            : 0);
                        if (!isHidden) {
                          stack += value;
                          visibleSlot++;
                        }
                        const capped = grouped || row.id === topRow?.id;
                        const inset = capped ? radius : 0;
                        const bodyLength = Math.max(NONE, length - inset);
                        const end = start + length;
                        const transition: Transition = {
                          default: { ...spring, delay },
                          opacity: { duration: 0.15, ease: EASE_OUT },
                        };
                        const shown = value > 0 && !isHidden;
                        const opacity = highlight !== null && highlight !== row.id ? 0.25 : 1;
                        return (
                          <g key={row.id} fill={row.color}>
                            <motion.rect
                              x={0}
                              y={0}
                              width={vertical ? thickness : 1}
                              height={vertical ? 1 : thickness}
                              style={{ originX: 0, originY: 0 }}
                              initial={false}
                              animate={
                                vertical
                                  ? {
                                      x: offset,
                                      y: valueStart - end + inset,
                                      scaleY: bodyLength,
                                      opacity: shown ? opacity : 0,
                                    }
                                  : {
                                      y: offset,
                                      x: valueStart + start,
                                      scaleX: bodyLength,
                                      opacity: shown ? opacity : 0,
                                    }
                              }
                              transition={transition}
                            />
                            {capped ? (
                              <motion.rect
                                x={0}
                                y={0}
                                width={vertical ? thickness : radius * 2}
                                height={vertical ? radius * 2 : thickness}
                                rx={radius}
                                initial={false}
                                animate={
                                  vertical
                                    ? { x: offset, y: valueStart - end, opacity: shown ? opacity : 0 }
                                    : {
                                        y: offset,
                                        x: valueStart + end - radius * 2,
                                        opacity: shown ? opacity : 0,
                                      }
                                }
                                transition={transition}
                              />
                            ) : null}
                          </g>
                        );
                      })}
                    </motion.g>
                  );
                })}
              </g>
            </svg>
            {vertical ? (
              <XYTickLabels
                ticks={domain.ticks}
                position={valueAt}
                axis="y"
                format={formatTick}
                reduce={reduce}
                offset={VALUE_AXIS}
              />
            ) : (
              order.map((categoryIndex, rank) => (
                <motion.span
                  key={categories[categoryIndex]}
                  aria-hidden="true"
                  className={cn(
                    "pointer-events-none absolute top-0 left-0 truncate pr-3 text-right text-xs text-muted-foreground",
                    rank % stride !== 0 && "invisible",
                  )}
                  style={{ width: labelWidth, lineHeight: `${slot}px` }}
                  initial={false}
                  animate={{ y: rank * slot }}
                  transition={spring}
                >
                  {categories[categoryIndex]}
                </motion.span>
              ))
            )}
          </>
        ) : null}
        <div
          ref={plotRef}
          className="absolute rounded-sm has-focus-visible:outline-2 has-focus-visible:outline-offset-4 has-focus-visible:outline-ring"
          style={
            vertical
              ? { left: bandStart, width: bandLength, top: PAD.top, bottom: PAD.bottom }
              : { left: valueStart, width: valueLength, top: 0, height: bandLength }
          }
        >
          <XYInspector
            count={n}
            activeIndex={activeRank}
            onActive={(rank) => setActive(categories[order[rank]])}
            label={`${label}: inspect categories`}
            valueText={(rank) => {
              const i = order[rank];
              return [
                categories[i],
                ...visibleRows.map((row) => {
                  const value = row.values[i];
                  return `${row.name} ${value === null ? "no data" : formatValue(value)}`;
                }),
                ...(layout === "stacked" && visibleRows.length > 1
                  ? [`Total ${formatValue(totals[i])}`]
                  : []),
              ].join(". ");
            }}
            mode="band"
            orientation={vertical ? "horizontal" : "vertical"}
            open={open}
            setOpen={setOpen}
            onTouchChange={setTouching}
            tooltipId={tooltipId}
            canHover={canHover}
            className="inset-0 size-full"
          />
        </div>
      </div>
      <div aria-hidden="true" className="relative mt-2 h-4">
        {width > 0
          ? vertical
            ? order.map((categoryIndex, rank) => (
                <motion.span
                  key={categories[categoryIndex]}
                  className={cn(
                    "absolute top-0 left-0 truncate px-0.5 text-center text-[11px] text-muted-foreground",
                    rank % stride !== 0 && "invisible",
                  )}
                  // Shown labels borrow the slots of the hidden ones around them.
                  style={{ width: slot * stride }}
                  initial={false}
                  animate={{ x: bandStart + (rank + 0.5) * slot - (slot * stride) / 2 }}
                  transition={spring}
                >
                  {categories[categoryIndex]}
                </motion.span>
              ))
            : (
              <XYTickLabels
                ticks={domain.ticks}
                position={valueAt}
                axis="x"
                format={formatTick}
                reduce={reduce}
                offset={0}
              />
            )
          : null}
      </div>
    </div>
  );
}

"use client";

import type { ReactNode } from "react";
import { Tooltip } from "@/components/motion/tooltip";
import { cn } from "@/lib/utils";
import { XYTooltipContent, type XYTooltipRow } from "../xy/tooltip-content";
import { useBarChart } from "./context";

export interface BarChartTooltipData {
  category: string;
  index: number;
  rows: XYTooltipRow[];
  total: number;
}

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

/**
 * Follows the pointer like the other beUI charts' readouts. Keyboard
 * inspection, which has no pointer, anchors at the end of the category's
 * longest bar instead.
 */
export function BarChartTooltip({ children, className, side = "top" }: BarChartTooltipProps) {
  const {
    categories,
    visibleRows,
    order,
    totals,
    domain,
    layout,
    orientation,
    activeIndex,
    open,
    setOpen,
    plotRef,
    tooltipId,
    formatValue,
  } = useBarChart();
  const category = categories[activeIndex];
  const rows: XYTooltipRow[] = visibleRows.map((row) => ({
    id: row.id,
    name: row.name,
    color: row.color,
    value: row.values[activeIndex] ?? null,
  }));
  const total = totals[activeIndex] ?? 0;
  const reach = layout === "stacked" ? total : Math.max(0, ...rows.map((row) => row.value ?? 0));
  const along = Math.min(1, reach / (domain.max || 1));
  const across = (Math.max(order.indexOf(activeIndex), 0) + 0.5) / Math.max(categories.length, 1);
  return (
    <Tooltip
      id={tooltipId}
      anchorRef={plotRef}
      followCursor
      anchorPoint={
        orientation === "vertical" ? { x: across, y: 1 - along } : { x: along, y: across }
      }
      open={open && category !== undefined}
      onOpenChange={setOpen}
      side={side}
      className={cn("max-w-64", className)}
      content={
        category === undefined ? null : typeof children === "function" ? (
          children({ category, index: activeIndex, rows, total })
        ) : (
          (children ?? (
            <XYTooltipContent
              title={category}
              rows={rows}
              formatValue={formatValue}
              total={layout === "stacked" && rows.length > 1 ? total : undefined}
              compact
            />
          ))
        )
      }
    />
  );
}

import type { XYRow } from "./model";

/** Every value stays readable by screen readers without a tab stop per mark. */
export function XYDataTable({
  label,
  rows,
  categories,
  formatValue,
}: {
  label: string;
  rows: readonly XYRow[];
  categories: readonly string[];
  formatValue: (value: number) => string;
}) {
  return (
    <div className="sr-only">
      <table>
        <caption>{label} data</caption>
        <thead>
          <tr>
            <th scope="col">Category</th>
            {rows.map((row) => (
              <th key={row.id} scope="col">
                {row.name}
              </th>
            ))}
          </tr>
        </thead>
        <tbody>
          {categories.map((category, i) => (
            <tr key={category}>
              <th scope="row">{category}</th>
              {rows.map((row) => {
                const value = row.values[i];
                return <td key={row.id}>{value === null ? "No data" : formatValue(value)}</td>;
              })}
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

export interface XYSeries {
  /** Stable, unique identity. Keep it when updating values so marks morph in place. */
  id: string;
  name: string;
  /** Any CSS color, including theme variables. */
  color: string;
  /** Values aligned with categories. Missing or non-finite values leave a gap. */
  values: readonly (number | null)[];
}

export type XYRow = Omit<XYSeries, "values"> & { values: (number | null)[] };

/** First of repeated series and category ids wins. Invalid values become gaps, never zeros. */
export function normalizeXY(
  series: readonly XYSeries[],
  categories: readonly string[],
  { nonnegative = false }: { nonnegative?: boolean } = {},
) {
  const columns: { id: string; source: number }[] = [];
  const seenColumns = new Set<string>();
  categories.forEach((id, source) => {
    if (seenColumns.has(id)) return;
    seenColumns.add(id);
    columns.push({ id, source });
  });
  const seenRows = new Set<string>();
  const rows: XYRow[] = [];
  for (const { values, ...row } of series) {
    if (seenRows.has(row.id)) continue;
    seenRows.add(row.id);
    rows.push({
      ...row,
      values: columns.map(({ source }) => {
        const value = values[source];
        return typeof value === "number" && Number.isFinite(value) && (!nonnegative || value >= 0)
          ? value
          : null;
      }),
    });
  }
  return { rows, categories: columns.map((column) => column.id) };
}

export interface XYDomain {
  min: number;
  max: number;
  ticks: number[];
}

const tidy = (value: number) => Number(value.toPrecision(12));

function niceStep(raw: number) {
  const power = 10 ** Math.floor(Math.log10(raw));
  const fraction = raw / power;
  return (fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10) * power;
}

/** Round a value range out to human tick steps (1, 2, 5 × 10ⁿ). */
export function niceDomain(
  values: readonly number[],
  { includeZero = false, count = 4, fixed }: {
    includeZero?: boolean;
    count?: number;
    fixed?: readonly [number, number];
  } = {},
): XYDomain {
  let min = fixed?.[0] ?? (values.length ? Math.min(...values) : 0);
  let max = fixed?.[1] ?? (values.length ? Math.max(...values) : 1);
  if (includeZero && !fixed) {
    min = Math.min(0, min);
    max = Math.max(0, max);
  }
  if (min === max) {
    if (min === 0) max = 1;
    else if (includeZero && min > 0) min = 0;
    else {
      const pad = Math.abs(min) * 0.1;
      min -= pad;
      max += pad;
    }
  }
  const step = niceStep((max - min) / count);
  const lo = fixed ? min : tidy(Math.floor(min / step) * step);
  const hi = fixed ? max : tidy(Math.ceil(max / step) * step);
  const ticks: number[] = [];
  for (let tick = Math.ceil(lo / step) * step; tick <= hi + step / 1e6; tick += step)
    ticks.push(tidy(tick));
  return { min: lo, max: hi, ticks };
}

/** Show every nth label so neighbours never overlap. */
export function labelStride(count: number, length: number, minGap = 64) {
  if (count <= 1 || length <= 0) return 1;
  return Math.max(1, Math.ceil((count * minGap) / length));
}

"use client";

import { useCallback, useId, useLayoutEffect, useRef, useState } from "react";

/** Controlled/uncontrolled value with a stable setter. */
export function useControllable<T>(value: T | undefined, defaultValue: T, onChange?: (next: T) => void) {
  const [internal, setInternal] = useState(defaultValue);
  const latest = useRef({ value, internal, onChange });
  useLayoutEffect(() => {
    latest.current = { value, internal, onChange };
  });
  const set = useCallback((next: T) => {
    const current = latest.current;
    if (current.value === undefined) setInternal(next);
    if ((current.value === undefined ? current.internal : current.value) !== next)
      current.onChange?.(next);
  }, []);
  return [value === undefined ? internal : value, set, setInternal] as const;
}

/**
 * The inspected category is held by id and resolved during render, so a
 * category that leaves the data clears the cursor instead of landing on a
 * neighbour, and one that comes back cannot revive it.
 */
export function useInspection({
  ids,
  activeId,
  defaultActiveId = null,
  onActiveChange,
}: {
  ids: readonly string[];
  activeId?: string | null;
  defaultActiveId?: string | null;
  onActiveChange?: (id: string | null) => void;
}) {
  const [requested, setActive, setInternal] = useControllable(
    activeId,
    defaultActiveId,
    onActiveChange,
  );
  if (activeId === undefined && requested !== null && !ids.includes(requested)) setInternal(null);
  const activeIndex = requested === null ? -1 : ids.indexOf(requested);
  const [open, setOpen] = useState(false);
  // A finger on the plot: inspection marks follow it directly instead of gliding.
  const [touching, setTouching] = useState(false);
  const plotRef = useRef<HTMLDivElement>(null);
  const tooltipId = useId();
  return {
    activeId: activeIndex >= 0 ? requested : null,
    activeIndex,
    setActive,
    open,
    setOpen,
    touching,
    setTouching,
    plotRef,
    tooltipId,
  };
}

"use client";

import { cn } from "@/lib/utils";
import type { XYRow } from "./model";

export interface XYLegendProps {
  rows: readonly XYRow[];
  hidden: readonly string[];
  onToggle: (id: string) => void;
  onHover: (id: string | null) => void;
  canHover: boolean;
  label: string;
  className?: string;
}

/** Each entry is a toggle: pressed means the series is drawn. */
export function XYLegend({
  rows,
  hidden,
  onToggle,
  onHover,
  canHover,
  label,
  className,
}: XYLegendProps) {
  return (
    <ul
      aria-label={label}
      className={cn("flex flex-wrap items-center gap-x-1 gap-y-1 text-xs", className)}
    >
      {rows.map((row) => {
        const shown = !hidden.includes(row.id);
        return (
          <li key={row.id}>
            <button
              type="button"
              aria-pressed={shown}
              onClick={() => onToggle(row.id)}
              onPointerEnter={() => {
                if (canHover && shown) onHover(row.id);
              }}
              onPointerLeave={() => onHover(null)}
              onFocus={() => {
                if (shown) onHover(row.id);
              }}
              onBlur={() => onHover(null)}
              className={cn(
                "flex min-h-9 items-center gap-2 rounded-md px-2 text-muted-foreground transition-[color,opacity] duration-150 hover:text-foreground focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring",
                !shown && "opacity-50",
              )}
            >
              <span
                aria-hidden="true"
                className={cn(
                  "size-2.5 shrink-0 rounded-full border-2 transition-colors duration-150",
                )}
                style={{ borderColor: row.color, backgroundColor: shown ? row.color : "transparent" }}
              />
              <span className={cn(!shown && "line-through decoration-muted-foreground/60")}>
                {row.name}
              </span>
            </button>
          </li>
        );
      })}
    </ul>
  );
}

"use client";

import { AnimatePresence, motion } from "motion/react";
import { EASE_OUT, SPRING_LAYOUT } from "@/lib/ease";

const FADE = { duration: 0.16, ease: EASE_OUT } as const;
const EXIT = { opacity: 0, transition: { duration: 0.1, ease: EASE_OUT } } as const;

/**
 * Value gridlines keyed by tick value: a tick that survives a rescale glides to
 * its new position, new ticks fade in where they belong, old ones fade out.
 */
export function XYGridLines({
  ticks,
  position,
  axis,
  from,
  to,
  reduce,
}: {
  ticks: readonly number[];
  position: (value: number) => number;
  /** `y` draws horizontal lines at y positions; `x` vertical lines at x positions. */
  axis: "x" | "y";
  from: number;
  to: number;
  reduce: boolean;
}) {
  return (
    <AnimatePresence initial={false}>
      {ticks.map((tick) => {
        const at = { [axis]: position(tick) };
        return (
          <motion.line
            key={tick}
            {...(axis === "y" ? { x1: from, x2: to, y1: 0, y2: 0 } : { y1: from, y2: to, x1: 0, x2: 0 })}
            // Border tokens are tuned for card edges and vanish as thin rules on a plot.
            stroke="currentColor"
            strokeOpacity={tick === 0 ? 0.3 : 0.12}
            className="text-muted-foreground"
            initial={{ opacity: 0, ...at }}
            animate={{ opacity: 1, ...at }}
            exit={EXIT}
            transition={{ opacity: FADE, default: reduce ? { duration: 0 } : SPRING_LAYOUT }}
          />
        );
      })}
    </AnimatePresence>
  );
}

export function XYTickLabels({
  ticks,
  position,
  axis,
  format,
  reduce,
  offset,
}: {
  ticks: readonly number[];
  position: (value: number) => number;
  /** `y` stacks labels in a left gutter; `x` lines them up under the plot. */
  axis: "x" | "y";
  format: (value: number) => string;
  reduce: boolean;
  /** Gutter width for `y`, or the top edge of the label row for `x`, in px. */
  offset: number;
}) {
  return (
    <AnimatePresence initial={false}>
      {ticks.map((tick) => {
        const at = { [axis]: position(tick) };
        return (
          <motion.span
            key={tick}
            aria-hidden="true"
            className="pointer-events-none absolute top-0 left-0 font-mono text-[11px] whitespace-nowrap text-muted-foreground tabular-nums"
            style={axis === "y" ? { width: offset - 8 } : { top: offset }}
            initial={{ opacity: 0, ...at }}
            animate={{ opacity: 1, ...at }}
            exit={EXIT}
            transition={{ opacity: FADE, default: reduce ? { duration: 0 } : SPRING_LAYOUT }}
          >
            <span
              className={
                axis === "y" ? "block -translate-y-1/2 text-right" : "block -translate-x-1/2"
              }
            >
              {format(tick)}
            </span>
          </motion.span>
        );
      })}
    </AnimatePresence>
  );
}