Liquidity Heatmap

// 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;

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

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

"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";

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;
}

"use client";
// beui.dev/charts/liquidity-heatmap

import { createContext, useContext, useId, useMemo, useRef, useState, type ReactNode } from "react";
import { motion, useReducedMotion } from "motion/react";
import { NumberTicker } from "@/components/motion/number-ticker";
import { Tooltip } from "@/components/motion/tooltip";
import { EASE_OUT } from "@/lib/ease";
import { cn } from "@/lib/utils";
import {
  buildLiquidityHeatmap,
  pricePosition,
  type LiquiditySnapshot,
} from "./liquidity-heatmap/model";

const formatPrice = (value: number) => value.toLocaleString("en-US", { maximumFractionDigits: 2 });
const formatSize = (value: number) =>
  value.toLocaleString("en-US", { notation: "compact", maximumFractionDigits: 1 });
const colors = ["#17233b", "#254f80", "#217c90", "#27af98", "#97d56b", "#f4df76"];
function heatColor(value: number, max: number) {
  return colors[
    Math.min(colors.length - 1, Math.floor((max > 0 ? value / max : 0) * colors.length))
  ];
}
interface LiquidityHeatmapProps {
  /** Time-ordered snapshots; use consistent price buckets and stable IDs. */
  snapshots: readonly LiquiditySnapshot[];
  /** Fixed intensity ceiling keeps colors comparable across live updates. */
  maxSize?: number;
  unit?: string;
  label?: string;
  formatPrice?: (price: number) => string;
  formatSize?: (size: number) => string;
  children?: ReactNode;
  className?: string;
}
const Context = createContext<
  | (ReturnType<typeof buildLiquidityHeatmap> & {
      ceiling: number;
      unit: string;
      formatPrice: (value: number) => string;
      formatSize: (value: number) => string;
    })
  | null
>(null);
export function useLiquidityHeatmap() {
  const value = useContext(Context);
  if (!value) throw new Error("Liquidity heatmap parts must be inside LiquidityHeatmap");
  return value;
}
export function LiquidityHeatmap({
  snapshots,
  maxSize,
  unit = "units",
  label = "Liquidity heatmap",
  formatPrice: priceFormatter = formatPrice,
  formatSize: sizeFormatter = formatSize,
  children,
  className,
}: LiquidityHeatmapProps) {
  const model = useMemo(() => buildLiquidityHeatmap(snapshots), [snapshots]);
  const ceiling =
    maxSize !== undefined && Number.isFinite(maxSize) && maxSize > 0 ? maxSize : model.maximum;
  return (
    <Context.Provider
      value={{ ...model, ceiling, unit, formatPrice: priceFormatter, formatSize: sizeFormatter }}
    >
      <section aria-label={label} className={cn("w-full space-y-4", className)}>
        {children ?? (
          <>
            <LiquidityHeatmapPlot />
            <LiquidityHeatmapLegend />
          </>
        )}
      </section>
    </Context.Provider>
  );
}

export function LiquidityHeatmapPlot({ className }: { className?: string }) {
  const { columns, prices, ceiling, unit, formatPrice, formatSize } = useLiquidityHeatmap();
  const reduced = useReducedMotion();
  const root = useRef<HTMLDivElement>(null);
  const anchor = useRef<HTMLButtonElement>(null);
  const tooltipId = useId();
  const [active, setActive] = useState<string | null>(null);
  const [cursor, setCursor] = useState<string | null>(null);
  const keys = prices.flatMap((price) =>
    columns.map((column) => JSON.stringify([column.id, price])),
  );
  const validCursor = cursor !== null && keys.includes(cursor) ? cursor : keys[0];
  if (cursor !== null && !keys.includes(cursor)) setCursor(null);
  if (active !== null && !keys.includes(active)) setActive(null);
  const activeIndex = active === null ? -1 : keys.indexOf(active);
  const row = Math.floor(activeIndex / columns.length);
  const col = activeIndex % columns.length;
  const selected = activeIndex >= 0 ? columns[col] : null;
  const size = selected?.levels.get(prices[row]);
  let connected = false;
  const path = columns
    .map((column, index) => {
      const y = column.price === undefined ? null : pricePosition(column.price, prices);
      if (y === null) {
        connected = false;
        return "";
      }
      const command = connected ? "L" : "M";
      connected = true;
      return `${command}${index + 0.5},${y}`;
    })
    .join(" ");
  if (!prices.length || !columns.length)
    return (
      <p className={cn("py-16 text-center text-sm text-muted-foreground", className)}>
        No liquidity data
      </p>
    );
  return (
    <div className={cn("overflow-x-auto", className)} ref={root}>
      <div
        className="relative"
        style={{ minWidth: Math.max(480, columns.length * 24), paddingRight: 72 }}
      >
        <div className="relative">
          <table
            aria-label="Liquidity by price and time"
            className="w-full table-fixed border-separate border-spacing-[2px]"
          >
            <thead className="sr-only">
              <tr>
                {columns.map((column) => (
                  <th key={column.id} scope="col">
                    {column.label}
                  </th>
                ))}
              </tr>
            </thead>
            <tbody>
              {prices.map((price, rowIndex) => (
                <tr key={price}>
                  {columns.map((column, columnIndex) => {
                    const value = column.levels.get(price);
                    const key = JSON.stringify([column.id, price]);
                    const index = rowIndex * columns.length + columnIndex;
                    return (
                      <td key={column.id} className="p-0">
                        <button
                          type="button"
                          data-cell={index}
                          tabIndex={key === validCursor ? 0 : -1}
                          aria-label={`${column.label}, ${formatPrice(price)}: ${value === undefined ? "No data" : `${formatSize(value)} ${unit}`}`}
                          aria-describedby={key === active ? tooltipId : undefined}
                          className="relative block h-6 w-full rounded-[2px] bg-muted/30 outline-none focus-visible:ring-2 focus-visible:ring-foreground focus-visible:z-10"
                          onPointerEnter={(event) => {
                            if (event.pointerType !== "touch") {
                              anchor.current = event.currentTarget;
                              setActive(key);
                            }
                          }}
                          onPointerLeave={() => setActive(null)}
                          onFocus={(event) => {
                            anchor.current = event.currentTarget;
                            setCursor(key);
                            setActive(key);
                          }}
                          onBlur={() => setActive(null)}
                          onClick={(event) => {
                            anchor.current = event.currentTarget;
                            setActive(key);
                          }}
                          onKeyDown={(event) => {
                            if (event.key === "Escape") {
                              setActive(null);
                              return;
                            }
                            const offsets: Record<string, number> = {
                              ArrowRight: 1,
                              ArrowLeft: -1,
                              ArrowDown: columns.length,
                              ArrowUp: -columns.length,
                              Home: -columnIndex,
                              End: columns.length - 1 - columnIndex,
                            };
                            if (!(event.key in offsets)) return;
                            event.preventDefault();
                            const next = Math.max(
                              0,
                              Math.min(keys.length - 1, index + offsets[event.key]),
                            );
                            root.current
                              ?.querySelector<HTMLButtonElement>(`[data-cell="${next}"]`)
                              ?.focus();
                          }}
                        >
                          <motion.span
                            aria-hidden="true"
                            className="pointer-events-none absolute inset-0 rounded-[2px]"
                            initial={false}
                            animate={{
                              opacity: value === undefined ? 0 : 1,
                              backgroundColor: heatColor(value ?? 0, ceiling),
                            }}
                            transition={{ duration: 0.28, ease: EASE_OUT }}
                          />
                          {key === active && (
                            <span
                              aria-hidden="true"
                              className="pointer-events-none absolute inset-0 rounded-[2px] ring-1 ring-inset ring-white"
                            />
                          )}
                        </button>
                      </td>
                    );
                  })}
                </tr>
              ))}
            </tbody>
          </table>
          <div
            aria-hidden="true"
            className="absolute -right-[72px] top-0 bottom-0 flex w-16 flex-col justify-around text-right font-mono text-[10px] tabular-nums text-muted-foreground"
          >
            {prices.map((price) => (
              <span key={price}>{formatPrice(price)}</span>
            ))}
          </div>
          {/* Remount only when trace topology changes; numeric coordinates otherwise interpolate together. */}
          <svg
            key={columns
              .map(
                (column) =>
                  `${column.id}:${column.price !== undefined && pricePosition(column.price, prices) !== null}`,
              )
              .join("|")}
            aria-hidden="true"
            className="pointer-events-none absolute inset-0 h-full w-full overflow-visible"
            viewBox={`0 0 ${columns.length} ${prices.length}`}
            preserveAspectRatio="none"
          >
            <motion.path
              initial={false}
              animate={{ d: path }}
              transition={{ duration: reduced ? 0 : 0.28, ease: EASE_OUT }}
              fill="none"
              stroke="black"
              strokeOpacity="0.35"
              strokeWidth="4"
              vectorEffect="non-scaling-stroke"
            />
            <motion.path
              initial={false}
              animate={{ d: path }}
              transition={{ duration: reduced ? 0 : 0.28, ease: EASE_OUT }}
              fill="none"
              stroke="white"
              strokeOpacity="0.9"
              strokeWidth="1.5"
              strokeLinejoin="round"
              vectorEffect="non-scaling-stroke"
            />
          </svg>
        </div>
        <div
          aria-hidden="true"
          className="mt-3 flex justify-between font-mono text-[10px] text-muted-foreground"
        >
          {columns
            .filter(
              (_, index) =>
                index % Math.max(1, Math.ceil(columns.length / 5)) === 0 ||
                index === columns.length - 1,
            )
            .map((column) => (
              <span key={column.id}>{column.label}</span>
            ))}
        </div>
      </div>
      <Tooltip
        key={active ?? "closed"}
        id={tooltipId}
        open={selected !== null}
        anchorRef={anchor}
        onOpenChange={(open) => {
          if (!open) setActive(null);
        }}
        content={
          selected && (
            <span className="flex flex-col gap-1 font-mono text-xs">
              <span className="text-muted-foreground">
                {selected.label} · {formatPrice(prices[row])}
              </span>
              <span className="inline-flex items-center tabular-nums">
                {size === undefined ? "No data" : (
                  <NumberTicker
                    value={size}
                    // Format the original amount so fractional liquidity is preserved.
                    format={() => formatSize(size)}
                    suffix={` ${unit}`}
                    duration={0.35}
                    startOnView={false}
                  />
                )}
              </span>
              {selected.price !== undefined && Number.isFinite(selected.price) && (
                <span className="text-muted-foreground">Market {formatPrice(selected.price)}</span>
              )}
            </span>
          )
        }
      />
    </div>
  );
}

export function LiquidityHeatmapLegend({ className }: { className?: string }) {
  const { ceiling, formatSize, unit } = useLiquidityHeatmap();
  return (
    <div
      className={cn(
        "flex flex-wrap items-center justify-between gap-3 text-[10px] text-muted-foreground",
        className,
      )}
    >
      <span>Resting liquidity · {unit}</span>
      <span className="flex items-center gap-2">
        <span>0</span>
        <span aria-hidden="true" className="flex gap-0.5">
          {colors.map((color) => (
            <span
              key={color}
              className="h-2 w-5 rounded-[1px]"
              style={{ backgroundColor: color }}
            />
          ))}
        </span>
        <span>{formatSize(ceiling)}+</span>
      </span>
    </div>
  );
}
export type { LiquiditySnapshot, LiquidityHeatmapProps };

export interface LiquiditySnapshot {
  /** Stable identity, usually an ISO timestamp. */
  id: string;
  label: string;
  levels: readonly { price: number; size: number }[];
  price?: number;
}

/** Invalid observations are omitted; zero size is distinct from missing data. */
export function buildLiquidityHeatmap(snapshots: readonly LiquiditySnapshot[]) {
  const seen = new Set<string>();
  const columns = snapshots
    .filter((snapshot) => {
      if (seen.has(snapshot.id)) return false;
      seen.add(snapshot.id);
      return true;
    })
    .map((snapshot) => {
      const levels = new Map<number, number>();
      for (const { price, size } of snapshot.levels) {
        if (!Number.isFinite(price) || price <= 0 || !Number.isFinite(size) || size < 0) continue;
        const total = (levels.get(price) ?? 0) + size;
        if (Number.isFinite(total)) levels.set(price, total);
      }
      return { ...snapshot, levels };
    });
  const prices = [...new Set(columns.flatMap((column) => [...column.levels.keys()]))].sort(
    (a, b) => b - a,
  );
  let maximum = 0;
  for (const column of columns)
    for (const size of column.levels.values()) maximum = Math.max(maximum, size);
  return { columns, prices, maximum };
}

/** Price levels are discrete bands; interpolate the trace between their centers. */
export function pricePosition(price: number, prices: readonly number[]) {
  if (
    !Number.isFinite(price) ||
    !prices.length ||
    price > prices[0] ||
    price < prices[prices.length - 1]
  )
    return null;
  for (let index = 0; index < prices.length - 1; index++) {
    if (price <= prices[index] && price >= prices[index + 1]) {
      return index + 0.5 + (prices[index] - price) / (prices[index] - prices[index + 1]);
    }
  }
  return prices.length - 0.5;
}

"use client";

import { animate, motion, useInView, useReducedMotion } from "motion/react";
import { useEffect, useMemo, useRef, useState } from "react";
import { EASE_OUT } from "@/lib/ease";
import { cn } from "@/lib/utils";

export interface NumberTickerProps {
  value: number;
  /** Digits to pad to (left). */
  pad?: number;
  /** Per-digit roll duration in seconds. */
  duration?: number;
  /** Stagger between digits. */
  stagger?: number;
  /** Render only after the element enters the viewport. */
  startOnView?: boolean;
  prefix?: string;
  suffix?: string;
  /** Add a small blur during digit rolls. */
  blur?: boolean;
  className?: string;
  digitClassName?: string;
  /** Insert locale group separators (commas). Server-component safe. */
  locale?: boolean;
  /** Custom formatter. Client-only — server components must use `locale` instead. */
  format?: (value: number) => string;
}

const DIGIT_HEIGHT_EM = 1.1;
const DIGITS = Array.from({ length: 10 }, (_, n) => n);

export function NumberTicker({
  value,
  pad,
  duration = 0.9,
  stagger = 0.04,
  startOnView = true,
  prefix,
  suffix,
  blur = false,
  className,
  digitClassName,
  locale,
  format,
}: NumberTickerProps) {
  const containerRef = useRef<HTMLSpanElement>(null);
  const inView = useInView(containerRef, { once: true, amount: 0.6 });
  const [armed, setArmed] = useState(!startOnView);

  useEffect(() => {
    if (startOnView && inView) setArmed(true);
  }, [startOnView, inView]);

  const text = useMemo(() => {
    const rounded = Math.round(value);
    const formatted = format
      ? format(rounded)
      : locale
        ? rounded.toLocaleString()
        : rounded.toString();
    return pad ? formatted.padStart(pad, "0") : formatted;
  }, [value, pad, format, locale]);
  const glyphs = useMemo(() => {
    const chars = text.split("");
    // Key by place value (position from the right): a changing digit keeps its
    // identity and rolls to the new value instead of remounting and replaying
    // from 0. Growing numbers add glyphs on the left without re-keying the
    // ones, tens, hundreds already on screen.
    return chars.map((char, i) => ({ char, id: `g-${chars.length - 1 - i}` }));
  }, [text]);
  const readableText = `${prefix ?? ""}${text}${suffix ?? ""}`;

  // Stagger is an entrance flourish. Once the reveal has played, value
  // changes roll every digit immediately — a per-digit delay on live updates
  // reads as lag.
  const [entered, setEntered] = useState(false);
  useEffect(() => {
    if (!armed || entered) return;
    const total = (duration + glyphs.length * stagger) * 1000;
    const t = window.setTimeout(() => setEntered(true), total);
    return () => window.clearTimeout(t);
  }, [armed, entered, duration, stagger, glyphs.length]);

  return (
    <span
      ref={containerRef}
      className={cn("inline-flex items-center tabular-nums", className)}
    >
      <span className="sr-only">{readableText}</span>
      <span aria-hidden="true" className="inline-flex items-center">
        {prefix ? <span>{prefix}</span> : null}
        {glyphs.map(({ char, id }, i) => {
          const isDigit = /\d/.test(char);
          if (!isDigit) {
            return (
              <span key={id} className="inline-block">
                {char}
              </span>
            );
          }
          const digit = Number(char);
          return (
            <Digit
              key={id}
              digit={armed ? digit : 0}
              delay={entered ? 0 : i * stagger}
              duration={duration}
              blur={blur}
              className={digitClassName}
            />
          );
        })}
        {suffix ? <span>{suffix}</span> : null}
      </span>
    </span>
  );
}

function Digit({
  digit,
  delay,
  duration,
  blur,
  className,
}: {
  digit: number;
  delay: number;
  duration: number;
  blur: boolean;
  className?: string;
}) {
  const reduce = useReducedMotion();
  const columnRef = useRef<HTMLSpanElement>(null);

  useEffect(() => {
    if (reduce || !blur || !columnRef.current || !Number.isFinite(digit)) {
      return;
    }

    const node = columnRef.current;
    const controls = animate(
      node,
      { filter: ["blur(10px)", "blur(0px)"] },
      {
        duration: Math.min(duration * 0.75, 0.32),
        delay,
        ease: EASE_OUT,
      },
    );

    return () => {
      controls.stop();
      node.style.filter = "blur(0px)";
    };
  }, [blur, delay, digit, duration, reduce]);

  return (
    <span
      className={cn("relative inline-block overflow-hidden", className)}
      style={{ height: `${DIGIT_HEIGHT_EM}em`, width: "1ch" }}
    >
      <motion.span
        ref={columnRef}
        initial={{ y: 0 }}
        animate={{ y: `-${digit * DIGIT_HEIGHT_EM}em` }}
        transition={
          reduce
            ? { duration: 0 }
            : { duration, delay, ease: EASE_OUT }
        }
        className="absolute inset-x-0 top-0 flex flex-col items-center will-change-[transform,filter]"
      >
        {DIGITS.map((n) => (
          <span
            key={n}
            className="flex h-[1.1em] items-center justify-center leading-none"
          >
            {n}
          </span>
        ))}
      </motion.span>
    </span>
  );
}