Prediction Market

// 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 { 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/components/blocks/prediction-market

import { Banknote, ChevronDown } from "lucide-react";
import {
  AnimatePresence,
  animate,
  motion,
  useReducedMotion,
} from "motion/react";
import {
  useCallback,
  useEffect,
  useId,
  useMemo,
  useRef,
  useState,
  type CSSProperties,
} from "react";
import { EASE_OUT } from "@/lib/ease";
import { cn } from "@/lib/utils";
import { StatefulButton, type ButtonState } from "./button/stateful";
import { NumberTicker } from "./number-ticker";
import { Tabs, TabsList, TabsTrigger } from "./tabs";

export type PredictionMarketMode = "buy" | "sell";

export type PredictionMarketOutcome = {
  id: string;
  label: string;
  price: number;
};

export type PredictionMarketOrderValue = {
  mode: PredictionMarketMode;
  outcomeId: string;
  amount: string;
};

export type PredictionMarketQuote = {
  valid: boolean;
  amount: number;
  price: number;
  shares: number;
  payout: number;
  error?: string;
};

export type PredictionMarketClassNames = {
  root?: string;
  header?: string;
  tabs?: string;
  outcomes?: string;
  amount?: string;
  chips?: string;
  footer?: string;
  action?: string;
};

export interface PredictionMarketProps {
  outcomes?: PredictionMarketOutcome[];
  value?: PredictionMarketOrderValue;
  defaultValue?: Partial<PredictionMarketOrderValue>;
  onValueChange?: (value: PredictionMarketOrderValue) => void;
  onTrade?: (
    order: PredictionMarketOrderValue,
    quote: PredictionMarketQuote,
  ) => void;
  onSignIn?: () => void;
  authenticated?: boolean;
  orderTypeLabel?: string;
  balance?: number;
  positions?: Record<string, number>;
  quickAmounts?: number[];
  minTrade?: number;
  className?: string;
  classNames?: PredictionMarketClassNames;
}

const DEFAULT_OUTCOMES: PredictionMarketOutcome[] = [
  { id: "up", label: "Up", price: 0.09 },
  { id: "down", label: "Down", price: 0.91 },
];

const MODES: { id: PredictionMarketMode; label: string }[] = [
  { id: "buy", label: "Buy" },
  { id: "sell", label: "Sell" },
];

const DEFAULT_QUICK_AMOUNTS = [10, 50, 100, 500];
const DIGIT_TRANSITION = { duration: 0.18, ease: EASE_OUT } as const;
type AmountInputStyle = CSSProperties & { "--amount-chars": string };

function useControllableOrder({
  value,
  defaultValue,
  outcomes,
  onValueChange,
}: {
  value?: PredictionMarketOrderValue;
  defaultValue?: Partial<PredictionMarketOrderValue>;
  outcomes: PredictionMarketOutcome[];
  onValueChange?: (value: PredictionMarketOrderValue) => void;
}) {
  const initialValue: PredictionMarketOrderValue = {
    mode: defaultValue?.mode ?? "buy",
    outcomeId: defaultValue?.outcomeId ?? outcomes[0]?.id ?? "",
    amount: defaultValue?.amount ?? "",
  };

  const [internalValue, setInternalValue] = useState(initialValue);
  const controlled = value !== undefined;
  const order = value ?? internalValue;

  const setOrder = useCallback(
    (next: PredictionMarketOrderValue) => {
      if (!controlled) {
        setInternalValue(next);
      }

      onValueChange?.(next);
    },
    [controlled, onValueChange],
  );

  return [order, setOrder] as const;
}

function sanitizeAmount(value: string) {
  const normalized = value.replace(/[^\d.]/g, "");
  const [whole, ...decimalParts] = normalized.split(".");
  const decimal = decimalParts.join("");
  if (decimalParts.length === 0) return whole;
  return `${whole}.${decimal.slice(0, 2)}`;
}

function parseAmount(value: string) {
  return Number(value) || 0;
}

function formatCurrency(value: number, maximumFractionDigits = 2) {
  return new Intl.NumberFormat("en-US", {
    style: "currency",
    currency: "USD",
    maximumFractionDigits,
  }).format(value);
}

function formatCompactCurrency(value: number) {
  return value >= 100
    ? formatCurrency(value, 0)
    : formatCurrency(value, value % 1 === 0 ? 0 : 2);
}

function formatCents(value: number) {
  const cents = value * 100;
  const precision = Number.isInteger(cents) ? 0 : 1;
  return `${cents.toFixed(precision)}¢`;
}

function buildQuote({
  order,
  outcome,
  balance,
  position,
  minTrade,
}: {
  order: PredictionMarketOrderValue;
  outcome: PredictionMarketOutcome;
  balance: number;
  position: number;
  minTrade: number;
}): PredictionMarketQuote {
  const amount = parseAmount(order.amount);
  const price = Math.max(0.01, Math.min(0.99, outcome.price));
  const shares = order.mode === "buy" ? amount / price : amount;
  const payout = order.mode === "buy" ? shares : amount * price;

  if (amount <= 0) {
    return {
      valid: false,
      amount,
      price,
      shares: 0,
      payout: 0,
      error: "Enter an amount",
    };
  }

  if (order.mode === "buy" && amount < minTrade) {
    return {
      valid: false,
      amount,
      price,
      shares,
      payout,
      error: `Minimum ${formatCompactCurrency(minTrade)}`,
    };
  }

  if (order.mode === "buy" && amount > balance) {
    return {
      valid: false,
      amount,
      price,
      shares,
      payout,
      error: "Insufficient balance",
    };
  }

  if (order.mode === "sell" && amount > position) {
    return {
      valid: false,
      amount,
      price,
      shares,
      payout,
      error: "Not enough shares",
    };
  }

  return {
    valid: true,
    amount,
    price,
    shares,
    payout,
  };
}

function keyedAmountChars(value: string) {
  const seen = new Map<string, number>();
  return value.split("").map((char) => {
    const count = seen.get(char) ?? 0;
    seen.set(char, count + 1);
    return { id: `${char}-${count}`, char };
  });
}

function amountInputSize(value: string) {
  const length = value.replace(/\D/g, "").length;
  if (length >= 10) return "text-3xl sm:text-4xl";
  if (length >= 8) return "text-4xl sm:text-5xl";
  if (length >= 6) return "text-[44px] sm:text-[56px]";
  return "text-5xl sm:text-6xl";
}

function payoutTickerSize(value: number) {
  const length = formatCurrency(value).length;
  if (length >= 16) return "text-xl sm:text-2xl";
  if (length >= 13) return "text-2xl";
  if (length >= 10) return "text-3xl";
  return "text-4xl";
}

function AnimatedAmountInput({
  id,
  value,
  mode,
  inputSize,
  disabled,
  reduce,
  onChange,
}: {
  id: string;
  value: string;
  mode: PredictionMarketMode;
  inputSize: string;
  disabled: boolean;
  reduce: boolean;
  onChange: (value: string) => void;
}) {
  const displayValue = value || "0";
  const chars = keyedAmountChars(displayValue);
  const inputStyle = {
    "--amount-chars": String(chars.length),
  } as AmountInputStyle;
  const label = mode === "buy" ? "Amount" : "Shares";

  return (
    <div className="flex min-w-0 items-center justify-center overflow-hidden">
      {mode === "buy" ? (
        <span
          aria-hidden
          className={cn(
            "shrink-0 font-semibold leading-none tracking-normal text-muted-foreground/65 tabular-nums transition-[font-size] duration-200",
            inputSize,
          )}
        >
          $
        </span>
      ) : null}

      <div className="relative min-w-0 shrink">
        <input
          id={id}
          value={value}
          disabled={disabled}
          onChange={(event) => onChange(sanitizeAmount(event.target.value))}
          placeholder="0"
          inputMode="decimal"
          aria-label={label}
          autoComplete="off"
          className={cn(
            "w-[calc((var(--amount-chars)+1)*0.62em)] min-w-[0.8em] max-w-[260px] bg-transparent text-left font-semibold leading-none tracking-normal text-transparent outline-none tabular-nums",
            "caret-foreground transition-[font-size] duration-200 placeholder:text-transparent selection:bg-foreground/10 disabled:cursor-not-allowed",
            inputSize,
          )}
          style={inputStyle}
        />
        <div
          aria-hidden
          className={cn(
            "pointer-events-none absolute inset-0 flex min-w-0 items-center justify-start overflow-hidden font-semibold leading-none tracking-normal text-foreground tabular-nums transition-[font-size] duration-200",
            !value && "text-muted-foreground/55",
            inputSize,
          )}
          style={inputStyle}
        >
          <AnimatePresence initial={false} mode="popLayout">
            {chars.map(({ id: charId, char }) => (
              <motion.span
                key={charId}
                layout={reduce ? false : "position"}
                initial={
                  reduce
                    ? { opacity: 0 }
                    : { opacity: 0, y: 18, filter: "blur(10px)" }
                }
                animate={
                  reduce
                    ? { opacity: 1 }
                    : { opacity: 1, y: 0, filter: "blur(0px)" }
                }
                exit={
                  reduce
                    ? { opacity: 0 }
                    : { opacity: 0, y: -14, filter: "blur(10px)" }
                }
                transition={DIGIT_TRANSITION}
                className="inline-block min-w-[0.55em] text-center will-change-[transform,opacity,filter]"
              >
                {char}
              </motion.span>
            ))}
          </AnimatePresence>
        </div>
      </div>
    </div>
  );
}

export function PredictionMarket({
  outcomes = DEFAULT_OUTCOMES,
  value,
  defaultValue,
  onValueChange,
  onTrade,
  onSignIn,
  authenticated = true,
  orderTypeLabel = "Market",
  balance = 500,
  positions = { up: 24, down: 16 },
  quickAmounts = DEFAULT_QUICK_AMOUNTS,
  minTrade = 1,
  className,
  classNames,
}: PredictionMarketProps) {
  const inputId = useId();
  const reduce = useReducedMotion() ?? false;
  const amountRef = useRef<HTMLDivElement>(null);
  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const [status, setStatus] = useState<"idle" | "placing" | "filled">("idle");
  const [shakeKey, setShakeKey] = useState(0);
  const [order, setOrder] = useControllableOrder({
    value,
    defaultValue,
    outcomes,
    onValueChange,
  });

  const selectedOutcome =
    outcomes.find((outcome) => outcome.id === order.outcomeId) ?? outcomes[0];
  const position = positions[selectedOutcome.id] ?? 0;
  const quote = useMemo(
    () =>
      buildQuote({
        order,
        outcome: selectedOutcome,
        balance,
        position,
        minTrade,
      }),
    [balance, minTrade, order, position, selectedOutcome],
  );

  const setOrderValue = useCallback(
    (next: Partial<PredictionMarketOrderValue>) => {
      if (timeoutRef.current) {
        clearTimeout(timeoutRef.current);
        timeoutRef.current = null;
      }

      setStatus("idle");
      setOrder({ ...order, ...next });
    },
    [order, setOrder],
  );

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

  useEffect(() => {
    if (shakeKey === 0 || reduce || !amountRef.current) return;
    animate(
      amountRef.current,
      { x: [0, -5, 5, -3, 3, -1, 0] },
      { duration: 0.38, ease: EASE_OUT },
    );
  }, [reduce, shakeKey]);

  const addAmount = (increment: number) => {
    const next = parseAmount(order.amount) + increment;
    setOrderValue({ amount: String(next) });
  };

  const setMax = () => {
    if (order.mode === "buy") {
      setOrderValue({ amount: String(Math.floor(balance)) });
      return;
    }

    setOrderValue({ amount: position.toFixed(position % 1 === 0 ? 0 : 2) });
  };

  const submit = () => {
    if (!authenticated) {
      onSignIn?.();
      return;
    }

    if (!quote.valid) {
      setShakeKey((key) => key + 1);
      return;
    }

    setStatus("placing");
    timeoutRef.current = setTimeout(() => {
      setStatus("filled");
      onTrade?.(order, quote);
    }, 650);
  };

  const inputSize = amountInputSize(order.amount);
  const payoutSize = payoutTickerSize(quote.payout);
  const actionState: ButtonState =
    status === "placing"
      ? "loading"
      : status === "filled"
        ? "success"
        : quote.valid
          ? "idle"
          : "error";
  const showFooter = authenticated;

  return (
    <div
      className={cn(
        "w-full max-w-[400px] overflow-hidden rounded-3xl border border-border bg-background",
        className,
        classNames?.root,
      )}
    >
      <div
        className={cn(
          "border-b border-border/80 px-4 pt-4",
          classNames?.header,
        )}
      >
        <div className="flex items-end justify-between gap-4">
          <Tabs
            value={order.mode}
            onValueChange={(mode) =>
              setOrderValue({
                mode: mode as PredictionMarketMode,
                amount: "",
              })
            }
            variant="underline"
            className={cn("shrink-0", classNames?.tabs)}
          >
            <TabsList className="gap-5 border-b-0 bg-transparent p-0">
              {MODES.map((mode) => (
                <TabsTrigger
                  key={mode.id}
                  value={mode.id}
                  className="px-0 pb-3 pt-0 text-2xl font-semibold"
                  indicatorClassName="h-0.5 bg-foreground"
                >
                  {mode.label}
                </TabsTrigger>
              ))}
            </TabsList>
          </Tabs>

          <button
            type="button"
            disabled={status === "placing"}
            className="mb-3 inline-flex items-center gap-2 text-xl font-semibold text-foreground transition-opacity disabled:opacity-50"
          >
            {orderTypeLabel}
            <ChevronDown className="h-5 w-5" />
          </button>
        </div>
      </div>

      <div className="space-y-4 p-3">
        <Tabs
          value={selectedOutcome.id}
          onValueChange={(outcomeId) => setOrderValue({ outcomeId })}
          variant="pill"
          className={classNames?.outcomes}
        >
          <TabsList className="grid w-full grid-cols-2 gap-2 p-1.5">
            {outcomes.map((outcome) => {
              const selected = outcome.id === selectedOutcome.id;
              const isNo =
                outcome.label.toLowerCase() === "no" ||
                outcome.label.toLowerCase() === "down";

              return (
                <TabsTrigger
                  key={outcome.id}
                  value={outcome.id}
                  indicatorClassName={
                    isNo
                      ? "bg-red-500/10 dark:bg-red-500/15"
                      : "bg-emerald-500/20"
                  }
                  className={cn(
                    "h-14 w-full rounded-[1.35rem] px-0 py-0 text-base font-semibold active:scale-[0.99]",
                    isNo
                      ? selected
                        ? "text-red-300 dark:text-red-300"
                        : "text-red-300/55 dark:text-red-300/50"
                      : selected
                        ? "text-emerald-400 dark:text-emerald-300"
                        : "text-muted-foreground",
                  )}
                >
                  {outcome.label} {formatCents(outcome.price)}
                </TabsTrigger>
              );
            })}
          </TabsList>
        </Tabs>

        <div
          ref={amountRef}
          className={cn("rounded-3xl bg-card p-4", classNames?.amount)}
        >
          <div className="flex min-h-24 flex-col items-center justify-center gap-5 text-center">
            <label
              htmlFor={inputId}
              className="text-xl font-medium text-foreground mr-6"
            >
              {order.mode === "buy" ? "Amount" : "Shares"}
            </label>

            <div className="w-full min-w-0">
              <AnimatedAmountInput
                id={inputId}
                mode={order.mode}
                value={order.amount}
                disabled={status === "placing"}
                inputSize={inputSize}
                reduce={reduce}
                onChange={(amount) => setOrderValue({ amount })}
              />
            </div>
          </div>

          <div
            className={cn(
              "mt-8 flex flex-wrap justify-center gap-2",
              classNames?.chips,
            )}
          >
            {quickAmounts.map((amount) => (
              <button
                key={amount}
                type="button"
                disabled={status === "placing"}
                onClick={() => addAmount(amount)}
                className="h-9 rounded-xl bg-background px-3.5 text-sm font-semibold text-foreground transition-[background-color,transform] duration-150 active:scale-95 disabled:pointer-events-none disabled:opacity-50"
              >
                +{order.mode === "buy" ? formatCompactCurrency(amount) : amount}
              </button>
            ))}
            <button
              type="button"
              disabled={status === "placing"}
              onClick={setMax}
              className="h-9 rounded-xl bg-background px-3.5 text-sm font-semibold text-foreground transition-[background-color,transform] duration-150 active:scale-95 disabled:pointer-events-none disabled:opacity-50"
            >
              Max
            </button>
          </div>
        </div>
      </div>

      {showFooter ? (
        <div
          className={cn(
            "border-t border-border/80 px-4 py-4",
            classNames?.footer,
          )}
        >
          <div className="mb-4 flex items-end justify-between gap-3">
            <div className="min-w-0 shrink">
              <div className="flex items-center gap-2 text-xl font-semibold text-foreground">
                {order.mode === "buy" ? "To win" : "To receive"}
                <Banknote className="h-5 w-5 text-emerald-500" />
              </div>
              <p className="text-sm font-medium text-muted-foreground">
                Avg. Price {formatCents(quote.price)}
              </p>
            </div>
            <NumberTicker
              value={quote.payout * 100}
              startOnView={false}
              duration={0.45}
              stagger={0}
              blur
              className={cn(
                "ml-auto min-w-0 shrink-0 justify-end whitespace-nowrap text-right font-semibold leading-none tracking-tight text-emerald-500 tabular-nums transition-[font-size] duration-200",
                payoutSize,
              )}
              format={(cents) => formatCurrency(cents / 100)}
            />
          </div>

          <StatefulButton
            state={actionState}
            variant="primary"
            size="lg"
            pressScale={0.98}
            onClick={submit}
            loadingText="Trading"
            successText="Trade filled"
            errorText={quote.error ?? "Enter an amount"}
            className={cn(
              "h-12 w-full rounded-2xl text-base font-semibold",
              classNames?.action,
            )}
          >
            Trade
          </StatefulButton>
        </div>
      ) : (
        <div className="px-4 pb-5">
          <StatefulButton
            state="idle"
            variant="primary"
            size="lg"
            pressScale={0.98}
            onClick={submit}
            className={cn(
              "h-14 w-full rounded-2xl text-base font-semibold",
              classNames?.action,
            )}
          >
            Connect
          </StatefulButton>
        </div>
      )}
    </div>
  );
}

"use client";

import { Check, Loader2, X } from "lucide-react";
import {
  AnimatePresence,
  motion,
  useReducedMotion,
  type Variants,
} from "motion/react";
import {
  forwardRef,
  type ReactNode,
  useLayoutEffect,
  useRef,
  useState,
} from "react";
import { EASE_OUT, SPRING_SWAP } from "@/lib/ease";
import { Button, type ButtonProps } from "./base";

export type ButtonState = "idle" | "loading" | "success" | "error";

export interface StatefulButtonProps extends Omit<ButtonProps, "children"> {
  state?: ButtonState;
  children: ReactNode;
  loadingText?: ReactNode;
  successText?: ReactNode;
  errorText?: ReactNode;
  icon?: ReactNode;
}

const CASCADE_STAGGER = 0.025;
const ROLL_BLUR = "blur(6px)";

const CASCADE_LETTER_VARIANTS: Variants = {
  initial: { opacity: 0, y: "105%", filter: ROLL_BLUR },
  animate: (delay: number = 0) => ({
    opacity: 1,
    y: "0%",
    filter: "blur(0px)",
    transition: { ...SPRING_SWAP, delay },
  }),
  exit: (delay: number = 0) => ({
    opacity: 0,
    y: "-105%",
    filter: ROLL_BLUR,
    transition: { duration: 0.16, ease: EASE_OUT, delay: delay * 0.5 },
  }),
};

const ICON_VARIANTS: Variants = {
  // Width collapses too, so the icon adds/removes its own space smoothly
  // instead of popping the row width in a single frame.
  initial: { opacity: 0, width: 0, scale: 0.7, filter: ROLL_BLUR },
  animate: {
    opacity: 1,
    width: "1.5rem",
    scale: 1,
    filter: "blur(0px)",
    transition: SPRING_SWAP,
  },
  exit: {
    opacity: 0,
    width: 0,
    scale: 0.7,
    filter: ROLL_BLUR,
    transition: { duration: 0.16, ease: EASE_OUT },
  },
};

function IconSlot({ keyId, children }: { keyId: string; children: ReactNode }) {
  const reduce = useReducedMotion();
  return (
    <motion.span
      key={keyId}
      variants={ICON_VARIANTS}
      initial={reduce ? { opacity: 0 } : "initial"}
      animate={reduce ? { opacity: 1 } : "animate"}
      exit={reduce ? { opacity: 0 } : "exit"}
      transition={reduce ? { duration: 0.15 } : undefined}
      className="inline-grid shrink-0 place-items-center overflow-hidden"
    >
      {children}
    </motion.span>
  );
}

function TextSlot({
  value,
  children,
}: {
  value: string;
  children: ReactNode;
}) {
  const reduce = useReducedMotion();
  const measureRef = useRef<HTMLSpanElement>(null);
  const [width, setWidth] = useState<number>();
  const label = typeof children === "string" ? children : null;
  const cascade = label !== null && !reduce;

  // Measure strings with the same per-letter layout as the cascade. Measuring
  // the whole string preserves kerning, which can make it narrower than the
  // inline-block letters and clip the final glyph during the width animation.
  useLayoutEffect(() => {
    const nextWidth = measureRef.current?.offsetWidth;
    if (!nextWidth) return;
    setWidth((current) => (current === nextWidth ? current : nextWidth));
  });

  return (
    <motion.span
      initial={false}
      animate={{ width }}
      transition={reduce ? { duration: 0 } : SPRING_SWAP}
      className="relative inline-block overflow-hidden whitespace-nowrap align-bottom"
    >
      <span
        ref={measureRef}
        aria-hidden
        className="invisible inline-block whitespace-nowrap"
      >
        {cascade
          ? label.split("").map((char, index) => (
              <span
                // biome-ignore lint/suspicious/noArrayIndexKey: position is the slot identity.
                key={index}
                className="inline-block whitespace-pre"
              >
                {char}
              </span>
            ))
          : children}
      </span>

      {cascade ? (
        <>
          <span className="sr-only">{label}</span>
          <AnimatePresence initial={false}>
            <motion.span
              key={`cascade-${value}`}
              aria-hidden
              initial="initial"
              animate="animate"
              exit="exit"
              className="absolute left-0 top-0 inline-block whitespace-pre"
            >
              {label.split("").map((char, index) => (
                <motion.span
                  // biome-ignore lint/suspicious/noArrayIndexKey: position is the slot identity.
                  key={index}
                  custom={index * CASCADE_STAGGER}
                  variants={CASCADE_LETTER_VARIANTS}
                  className="inline-block whitespace-pre will-change-[opacity,filter,transform]"
                >
                  {char}
                </motion.span>
              ))}
            </motion.span>
          </AnimatePresence>
        </>
      ) : (
        <AnimatePresence initial={false}>
          <motion.span
            key={`text-${value}`}
            initial={reduce ? { opacity: 0 } : { opacity: 0, y: 14, filter: ROLL_BLUR }}
            animate={reduce ? { opacity: 1 } : { opacity: 1, y: 0, filter: "blur(0px)" }}
            exit={reduce ? { opacity: 0 } : { opacity: 0, y: -14, filter: ROLL_BLUR }}
            transition={reduce ? { duration: 0.15 } : SPRING_SWAP}
            className="absolute left-0 top-0 inline-block will-change-[opacity,filter,transform]"
          >
            {children}
          </motion.span>
        </AnimatePresence>
      )}
    </motion.span>
  );
}

export const StatefulButton = forwardRef<HTMLButtonElement, StatefulButtonProps>(function StatefulButton(
  {
    state = "idle",
    children,
    loadingText = "Loading",
    successText = "Done",
    errorText = "Try again",
    icon,
    disabled,
    ...rest
  },
  ref,
) {
  const isBusy = state === "loading";
  const stateText =
    state === "loading"
      ? loadingText
      : state === "success"
        ? successText
        : state === "error"
        ? errorText
        : children;
  const textKey =
    typeof stateText === "string" ? `${state}-${stateText}` : state;

  return (
    <Button ref={ref} disabled={disabled || isBusy} aria-busy={isBusy} whileHover={undefined} {...rest}>
      <span
        aria-live="polite"
        className="relative inline-flex items-center justify-center overflow-hidden"
      >
        <AnimatePresence initial={false}>
          {state === "loading" ? (
            <IconSlot keyId="loading-icon">
              <Loader2 className="h-4 w-4 animate-spin" />
            </IconSlot>
          ) : null}
          {state === "success" ? (
            <IconSlot keyId="success-icon">
              <Check className="h-4 w-4" />
            </IconSlot>
          ) : null}
          {state === "error" ? (
            <IconSlot keyId="error-icon">
              <X className="h-4 w-4" />
            </IconSlot>
          ) : null}
        </AnimatePresence>

        <TextSlot value={textKey}>{stateText}</TextSlot>

        <AnimatePresence initial={false}>
          {state === "idle" && icon ? (
            <IconSlot keyId="idle-icon">{icon}</IconSlot>
          ) : null}
        </AnimatePresence>
      </span>
    </Button>
  );
});