Model Selector

// 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";
// karaui.kamisama-v0.my.id/components/agents/model-selector

import { Brain, Check, ChevronDown, Eye, Search, Wrench, Zap } from "lucide-react";
import { motion, useReducedMotion } from "motion/react";
import {
  type KeyboardEvent,
  type ReactNode,
  useEffect,
  useId,
  useMemo,
  useRef,
  useState,
} from "react";
import { Badge } from "@/components/motion/badge";
import { Kbd } from "@/components/motion/kbd";
import {
  MorphPopover,
  MorphPopoverContent,
  MorphPopoverTrigger,
} from "@/components/motion/popover-morph";
import { ScrollArea } from "@/components/motion/scroll-area";
import { SPRING_LAYOUT, SPRING_SWAP } from "@/lib/ease";
import { cn } from "@/lib/utils";

export type ModelCapability = "vision" | "tools" | "reasoning" | "fast";

export type ProviderGlyphShape =
  | "circle"
  | "square"
  | "triangle"
  | "hexagon"
  | "diamond"
  | "spark";

export interface ModelProvider {
  id: string;
  name: string;
  /** Generic geometric glyph. Defaults by provider order. */
  shape?: ProviderGlyphShape;
  /** Replaces the generic glyph entirely (e.g. your own logo). */
  icon?: ReactNode;
}

export interface ModelOption {
  value: string;
  name: string;
  /** `ModelProvider.id` the model is grouped under. */
  provider: string;
  description?: string;
  capabilities?: ModelCapability[];
  /** Context window in tokens. */
  contextWindow?: number;
  /** Relative cost from 1 (cheapest) to 4. */
  cost?: 1 | 2 | 3 | 4;
  isNew?: boolean;
  disabled?: boolean;
}

export interface ModelSelectorProps {
  models: ModelOption[];
  /** Provider order and naming. Providers missing here are derived from `models`. */
  providers?: ModelProvider[];
  value?: string;
  defaultValue?: string;
  onValueChange?: (value: string) => void;
  open?: boolean;
  defaultOpen?: boolean;
  onOpenChange?: (open: boolean) => void;
  placeholder?: string;
  searchPlaceholder?: string;
  emptyMessage?: ReactNode;
  side?: "top" | "bottom";
  align?: "start" | "end";
  disabled?: boolean;
  /** Hide the keyboard hint footer. */
  hideHints?: boolean;
  className?: string;
  triggerClassName?: string;
  contentClassName?: string;
  "aria-label"?: string;
}

const SHAPES: ProviderGlyphShape[] = [
  "spark",
  "hexagon",
  "circle",
  "diamond",
  "square",
  "triangle",
];

const CAPABILITIES: Record<
  ModelCapability,
  { label: string; icon: ReactNode }
> = {
  vision: { label: "Vision", icon: <Eye /> },
  tools: { label: "Tools", icon: <Wrench /> },
  reasoning: { label: "Reasoning", icon: <Brain /> },
  fast: { label: "Fast", icon: <Zap /> },
};

/** 200000 → "200k", 1048576 → "1M". */
export function formatContextWindow(tokens: number) {
  if (tokens >= 1_000_000) {
    const m = tokens / 1_000_000;
    return `${Number.isInteger(m) ? m : m.toFixed(1)}M`;
  }
  if (tokens >= 1000) return `${Math.round(tokens / 1000)}k`;
  return String(tokens);
}

function GlyphShape({ shape }: { shape: ProviderGlyphShape }) {
  switch (shape) {
    case "circle":
      return <circle cx="8" cy="8" r="5.25" />;
    case "square":
      return <rect x="2.75" y="2.75" width="10.5" height="10.5" rx="2.5" />;
    case "triangle":
      return <path d="M8 2.4 13.9 12.9H2.1Z" />;
    case "hexagon":
      return <path d="M8 1.9 13.3 4.95V11.05L8 14.1 2.7 11.05V4.95Z" />;
    case "diamond":
      return <path d="M8 1.6 14.4 8 8 14.4 1.6 8Z" />;
    default:
      return (
        <path d="M8 1.5C8.6 5.6 10.4 7.4 14.5 8 10.4 8.6 8.6 10.4 8 14.5 7.4 10.4 5.6 8.6 1.5 8 5.6 7.4 7.4 5.6 8 1.5Z" />
      );
  }
}

/** Generic provider mark: a geometric shape on a tinted tile, colored by `--chart-*`. */
export function ProviderGlyph({
  provider,
  index = 0,
  className,
}: {
  provider?: ModelProvider;
  index?: number;
  className?: string;
}) {
  const shape = provider?.shape ?? SHAPES[index % SHAPES.length];
  return (
    <span
      aria-hidden="true"
      style={{ color: `var(--chart-${(index % 5) + 1})` }}
      className={cn(
        "grid size-7 shrink-0 place-items-center rounded-lg bg-current/12 [&_svg]:size-4",
        className,
      )}
    >
      {provider?.icon ?? (
        <svg
          aria-hidden="true"
          viewBox="0 0 16 16"
          fill="currentColor"
          stroke="currentColor"
          strokeWidth="1"
          strokeLinejoin="round"
        >
          <GlyphShape shape={shape} />
        </svg>
      )}
    </span>
  );
}

function CostDots({ cost }: { cost: number }) {
  return (
    <span className="flex items-center gap-0.5">
      <span className="sr-only">Relative cost {cost} of 4</span>
      {[1, 2, 3, 4].map((dot) => (
        <span
          key={dot}
          aria-hidden="true"
          className={cn(
            "size-1 rounded-full",
            dot <= cost ? "bg-foreground/70" : "bg-foreground/15",
          )}
        />
      ))}
    </span>
  );
}

const optionId = (uid: string, value: string) =>
  `${uid}-opt-${value.replace(/\W/g, "_")}`;

function matches(model: ModelOption, providerName: string, query: string) {
  const haystack = [
    model.name,
    providerName,
    model.description ?? "",
    ...(model.capabilities ?? []),
  ]
    .join(" ")
    .toLowerCase();
  return query
    .toLowerCase()
    .split(/\s+/)
    .filter(Boolean)
    .every((token) => haystack.includes(token));
}

export function ModelSelector({
  models,
  providers,
  value,
  defaultValue,
  onValueChange,
  open,
  defaultOpen = false,
  onOpenChange,
  placeholder = "Choose a model",
  searchPlaceholder = "Search models…",
  emptyMessage = "No models match your search.",
  side = "bottom",
  align = "start",
  disabled = false,
  hideHints = false,
  className,
  triggerClassName,
  contentClassName,
  "aria-label": ariaLabel = "Model",
}: ModelSelectorProps) {
  const reduce = useReducedMotion() ?? false;
  const uid = useId().replace(/:/g, "");
  const triggerRef = useRef<HTMLButtonElement>(null);
  const [internalValue, setInternalValue] = useState(defaultValue);
  const [internalOpen, setInternalOpen] = useState(defaultOpen);
  const current = value ?? internalValue;
  const isOpen = open ?? internalOpen;

  // Provider order: explicit list first, then any provider only seen in models.
  const providerList = useMemo(() => {
    const list = [...(providers ?? [])];
    for (const model of models) {
      if (!list.some((provider) => provider.id === model.provider)) {
        list.push({ id: model.provider, name: model.provider });
      }
    }
    return list;
  }, [models, providers]);

  const providerIndex = (id: string) =>
    Math.max(
      0,
      providerList.findIndex((provider) => provider.id === id),
    );

  const selected = models.find((model) => model.value === current);

  const setOpen = (next: boolean) => {
    if (open === undefined) setInternalOpen(next);
    onOpenChange?.(next);
  };

  const select = (model: ModelOption) => {
    if (model.disabled) return;
    if (value === undefined) setInternalValue(model.value);
    onValueChange?.(model.value);
    setOpen(false);
    triggerRef.current?.focus({ preventScroll: true });
  };

  return (
    <MorphPopover
      open={isOpen}
      onOpenChange={setOpen}
      className={cn("max-w-full", className)}
    >
      <MorphPopoverTrigger>
      <button
        ref={triggerRef}
        type="button"
        disabled={disabled}
        aria-label={`${ariaLabel}: ${selected?.name ?? placeholder}`}
        className={cn(
          "inline-flex h-9 max-w-full items-center gap-2 rounded-xl border border-border bg-background pr-2 pl-1 text-sm text-foreground outline-none transition-colors hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50",
          triggerClassName,
        )}
      >
        {selected ? (
          <ProviderGlyph
            provider={providerList[providerIndex(selected.provider)]}
            index={providerIndex(selected.provider)}
            className="size-7 [&_svg]:size-3.5"
          />
        ) : null}
        <span
          className={cn(
            "min-w-0 truncate",
            !selected && "pl-2 text-muted-foreground",
          )}
        >
          {selected?.name ?? placeholder}
        </span>
        <motion.span
          aria-hidden="true"
          animate={{ rotate: isOpen ? 180 : 0 }}
          transition={reduce ? { duration: 0 } : SPRING_SWAP}
          className="grid shrink-0 place-items-center text-muted-foreground"
        >
          <ChevronDown className="size-3.5" />
        </motion.span>
      </button>
      </MorphPopoverTrigger>

      <MorphPopoverContent
        side={side}
        align={align}
        radius={14}
        className={cn("w-[min(22rem,calc(100vw-2rem))]", contentClassName)}
      >
        <ModelList
          uid={uid}
          models={models}
          providerList={providerList}
          providerIndex={providerIndex}
          current={current}
          reduce={reduce}
          searchPlaceholder={searchPlaceholder}
          emptyMessage={emptyMessage}
          hideHints={hideHints}
          ariaLabel={ariaLabel}
          onSelect={select}
        />
      </MorphPopoverContent>
    </MorphPopover>
  );
}

function ModelList({
  uid,
  models,
  providerList,
  providerIndex,
  current,
  reduce,
  searchPlaceholder,
  emptyMessage,
  hideHints,
  ariaLabel,
  onSelect,
}: {
  uid: string;
  models: ModelOption[];
  providerList: ModelProvider[];
  providerIndex: (id: string) => number;
  current: string | undefined;
  reduce: boolean;
  searchPlaceholder: string;
  emptyMessage: ReactNode;
  hideHints: boolean;
  ariaLabel: string;
  onSelect: (model: ModelOption) => void;
}) {
  const inputRef = useRef<HTMLInputElement>(null);
  const [query, setQuery] = useState("");
  const listId = `${uid}-list`;

  const groups = useMemo(
    () =>
      providerList
        .map((provider) => ({
          provider,
          models: models.filter(
            (model) =>
              model.provider === provider.id &&
              matches(model, provider.name, query),
          ),
        }))
        .filter((group) => group.models.length > 0),
    [models, providerList, query],
  );

  const enabled = useMemo(
    () =>
      groups.flatMap((group) => group.models).filter((model) => !model.disabled),
    [groups],
  );

  const [active, setActive] = useState<string | undefined>(() =>
    enabled.some((model) => model.value === current)
      ? current
      : enabled[0]?.value,
  );

  // Keep the active row valid as the filter narrows the list.
  const activeValue = enabled.some((model) => model.value === active)
    ? active
    : enabled[0]?.value;

  // The panel mounts with the popover; hand focus to the search field once it
  // is laid out (the morph keeps it hidden until measured).
  useEffect(() => {
    const frame = requestAnimationFrame(() =>
      inputRef.current?.focus({ preventScroll: true }),
    );
    return () => cancelAnimationFrame(frame);
  }, []);

  useEffect(() => {
    if (!activeValue) return;
    document
      .getElementById(optionId(uid, activeValue))
      ?.scrollIntoView({ block: "nearest" });
  }, [activeValue, uid]);

  const move = (delta: number) => {
    if (!enabled.length) return;
    const index = enabled.findIndex((model) => model.value === activeValue);
    const next = (index + delta + enabled.length) % enabled.length;
    setActive(enabled[next].value);
  };

  const onKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
    if (event.key === "ArrowDown") {
      event.preventDefault();
      move(1);
    } else if (event.key === "ArrowUp") {
      event.preventDefault();
      move(-1);
    } else if (event.key === "PageDown" || (event.key === "End" && event.ctrlKey)) {
      event.preventDefault();
      setActive(enabled.at(-1)?.value);
    } else if (event.key === "PageUp" || (event.key === "Home" && event.ctrlKey)) {
      event.preventDefault();
      setActive(enabled[0]?.value);
    } else if (event.key === "Enter" && !event.nativeEvent.isComposing) {
      event.preventDefault();
      const model = enabled.find((item) => item.value === activeValue);
      if (model) onSelect(model);
    }
  };

  return (
    <div className="flex flex-col">
      <div className="flex items-center gap-2 border-b border-border px-3">
        <Search aria-hidden="true" className="size-4 shrink-0 text-muted-foreground" />
        <input
          ref={inputRef}
          type="text"
          role="combobox"
          aria-label={`Search ${ariaLabel.toLowerCase()}s`}
          aria-expanded="true"
          aria-controls={listId}
          aria-autocomplete="list"
          aria-activedescendant={activeValue ? optionId(uid, activeValue) : undefined}
          value={query}
          placeholder={searchPlaceholder}
          onChange={(event) => setQuery(event.target.value)}
          onKeyDown={onKeyDown}
          className="h-10 min-w-0 flex-1 bg-transparent text-sm text-foreground outline-none placeholder:text-muted-foreground/60"
        />
      </div>

      <ScrollArea
        aria-label={`${ariaLabel} list`}
        viewportClassName="max-h-[17.5rem]"
        fadeEdges
      >
        <div
          id={listId}
          role="listbox"
          aria-label={ariaLabel}
          className="relative isolate p-1.5"
        >
          {groups.map((group) => {
            const index = providerIndex(group.provider.id);
            return (
              <fieldset key={group.provider.id} className="m-0 min-w-0 border-0 p-0 pb-1">
                <legend className="w-full px-2 pt-1.5 pb-1 text-[0.68rem] font-medium uppercase tracking-[0.12em] text-muted-foreground">
                  {group.provider.name}
                </legend>
                {group.models.map((model) => {
                  const isActive = model.value === activeValue;
                  const isSelected = model.value === current;
                  return (
                    <button
                      key={model.value}
                      id={optionId(uid, model.value)}
                      type="button"
                      role="option"
                      tabIndex={-1}
                      aria-selected={isSelected}
                      aria-disabled={model.disabled || undefined}
                      onMouseDown={(event) => event.preventDefault()}
                      onPointerMove={() => {
                        if (!model.disabled && !isActive) setActive(model.value);
                      }}
                      onClick={() => onSelect(model)}
                      className={cn(
                        "relative flex w-full items-start gap-2.5 rounded-lg px-2 py-2 text-left outline-none",
                        model.disabled && "cursor-not-allowed opacity-45",
                      )}
                    >
                      {isActive ? (
                        <motion.span
                          aria-hidden="true"
                          layoutId={`${uid}-active`}
                          transition={reduce ? { duration: 0 } : SPRING_LAYOUT}
                          className="absolute inset-0 -z-10 rounded-lg bg-muted"
                        />
                      ) : null}
                      <ProviderGlyph provider={group.provider} index={index} />
                      <span className="min-w-0 flex-1">
                        <span className="flex items-center gap-1.5">
                          <span className="truncate text-sm font-medium text-foreground">
                            {model.name}
                          </span>
                          {model.isNew ? (
                            <Badge size="sm" variant="default" className="h-4 px-1.5 text-[10px]">
                              New
                            </Badge>
                          ) : null}
                        </span>
                        {model.description ? (
                          <span className="mt-0.5 block truncate text-xs text-muted-foreground">
                            {model.description}
                          </span>
                        ) : null}
                        {model.capabilities?.length ? (
                          <span className="mt-1.5 flex flex-wrap gap-1">
                            {model.capabilities.map((capability) => (
                              <Badge
                                key={capability}
                                size="sm"
                                variant="secondary"
                                icon={CAPABILITIES[capability].icon}
                                className="h-[18px] font-normal text-muted-foreground"
                              >
                                {CAPABILITIES[capability].label}
                              </Badge>
                            ))}
                          </span>
                        ) : null}
                      </span>
                      <span className="flex shrink-0 flex-col items-end gap-1.5 pt-0.5">
                        {model.contextWindow ? (
                          <span className="font-mono text-[11px] tabular-nums text-muted-foreground">
                            <span className="sr-only">Context window </span>
                            {formatContextWindow(model.contextWindow)}
                          </span>
                        ) : null}
                        {model.cost ? <CostDots cost={model.cost} /> : null}
                      </span>
                      <span className="grid size-4 shrink-0 place-items-center self-center text-foreground">
                        {isSelected ? (
                          <motion.span
                            initial={reduce ? false : { opacity: 0, scale: 0.6 }}
                            animate={{ opacity: 1, scale: 1 }}
                            transition={reduce ? { duration: 0 } : SPRING_SWAP}
                          >
                            <Check aria-hidden="true" className="size-4" />
                          </motion.span>
                        ) : null}
                      </span>
                    </button>
                  );
                })}
              </fieldset>
            );
          })}
          {groups.length === 0 ? (
            <p className="px-3 py-8 text-center text-sm text-muted-foreground">
              {emptyMessage}
            </p>
          ) : null}
        </div>
      </ScrollArea>

      {hideHints ? null : (
        <div className="flex items-center gap-3 border-t border-border px-3 py-2 text-[11px] text-muted-foreground">
          <span className="flex items-center gap-1">
            <Kbd size="sm">up</Kbd>
            <Kbd size="sm">down</Kbd>
            Navigate
          </span>
          <span className="flex items-center gap-1">
            <Kbd size="sm">enter</Kbd>
            Select
          </span>
          <span className="ml-auto flex items-center gap-1">
            <Kbd size="sm">esc</Kbd>
            Close
          </span>
        </div>
      )}
    </div>
  );
}

"use client";

import { X } from "lucide-react";
import {
  AnimatePresence,
  motion,
  PresenceContext,
  useAnimate,
  useReducedMotion,
  type Variants,
} from "motion/react";
import {
  type KeyboardEvent as ReactKeyboardEvent,
  type ReactNode,
  useContext,
  useEffect,
  useRef,
  useState,
} from "react";
import { EASE_OUT, SPRING_LAYOUT, SPRING_PANEL, SPRING_SWAP } from "@/lib/ease";
import { cn } from "@/lib/utils";

export type BadgeVariant =
  | "default"
  | "secondary"
  | "outline"
  | "destructive"
  | "success"
  | "warning";

export type BadgeSize = "sm" | "md" | "lg";

/** Soft tinted surface or a filled one. Only the status variants differ. */
export type BadgeTone = "soft" | "solid";

const BASE: Record<"default" | "secondary" | "outline", string> = {
  default: "border-transparent bg-primary text-primary-foreground",
  secondary: "border-transparent bg-foreground/[0.07] text-foreground",
  outline: "border-border-strong bg-transparent text-foreground",
};

// Status tints mix the token toward --foreground/--background (as `alert`
// does), so the text keeps its contrast in both themes and every design style.
const SOFT: Record<"destructive" | "success" | "warning", string> = {
  destructive:
    "border-[color-mix(in_oklab,var(--destructive)_30%,transparent)] bg-[color-mix(in_oklab,var(--destructive)_10%,var(--background))] text-[color-mix(in_oklab,var(--destructive)_78%,var(--foreground))]",
  success:
    "border-[color-mix(in_oklab,var(--success)_32%,transparent)] bg-[color-mix(in_oklab,var(--success)_11%,var(--background))] text-[color-mix(in_oklab,var(--success)_60%,var(--foreground))]",
  warning:
    "border-[color-mix(in_oklab,var(--warning)_40%,transparent)] bg-[color-mix(in_oklab,var(--warning)_13%,var(--background))] text-[color-mix(in_oklab,var(--warning)_52%,var(--foreground))]",
};

// Filled status badges. Red reads best with light text in both themes;
// green and amber are light hues, so they always get dark text.
const SOLID: Record<"destructive" | "success" | "warning", string> = {
  destructive:
    "border-transparent bg-destructive text-background dark:text-foreground",
  success:
    "border-transparent bg-success text-[color-mix(in_oklab,var(--success)_22%,var(--foreground))] dark:text-[color-mix(in_oklab,var(--success)_22%,var(--background))]",
  warning:
    "border-transparent bg-warning text-[color-mix(in_oklab,var(--warning)_22%,var(--foreground))] dark:text-[color-mix(in_oklab,var(--warning)_22%,var(--background))]",
};

const SIZE: Record<BadgeSize, string> = {
  sm: "h-5 gap-1 px-1.5 text-[11px] [&_svg]:size-3",
  md: "h-6 gap-1.5 px-2 text-xs [&_svg]:size-3.5",
  lg: "h-7 gap-1.5 px-2.5 text-[13px] [&_svg]:size-3.5",
};

// Count badges are circles at one digit and pills beyond.
const COUNT_SIZE: Record<BadgeSize, string> = {
  sm: "h-4 min-w-4 px-1 text-[10px]",
  md: "h-5 min-w-5 px-1.5 text-[11px]",
  lg: "h-6 min-w-6 px-1.5 text-xs",
};

function variantClass(variant: BadgeVariant, tone: BadgeTone) {
  if (variant === "default" || variant === "secondary" || variant === "outline") {
    return BASE[variant];
  }
  return tone === "solid" ? SOLID[variant] : SOFT[variant];
}

export interface BadgeProps {
  children?: ReactNode;
  variant?: BadgeVariant;
  /** Status variants only (destructive/success/warning). Default "soft". */
  tone?: BadgeTone;
  size?: BadgeSize;
  /** Leading status dot in the text color; `"pulse"` adds a radiating ring. */
  dot?: boolean | "pulse";
  /** Leading icon (sized to the badge). Ignored when `dot` is set. */
  icon?: ReactNode;
  /**
   * Makes the badge removable: an × button plays the exit, then calls this.
   * Focus moves to the neighbouring chip's × when the removal came from it.
   */
  onRemove?: () => void;
  /** Accessible name of the × button. Default `Remove <text>`. */
  removeLabel?: string;
  /**
   * Count mode: renders a compact number that rolls up or down as it changes
   * and bumps when it rises. Hidden at 0 unless `showZero`.
   */
  count?: number;
  /** Counts above this read "max+". Default 99. */
  max?: number;
  showZero?: boolean;
  /** Spoken label for count mode, e.g. `(n) => \`${n} unread\``. */
  countLabel?: (count: number) => string;
  className?: string;
}

/**
 * General-purpose badge: six variants, three sizes, an optional (pulsing) dot
 * or icon, removable chips with an exit animation, and a count mode with
 * rolling digits capped at "99+". For animated status transitions
 * (loading → success) use `AnimatedBadge` instead.
 */
export function Badge(props: BadgeProps) {
  if (props.count !== undefined) return <CountBadge {...props} count={props.count} />;
  return <LabelBadge {...props} />;
}

/* -------------------------------------------------------------------------- */
/*                                 Label badge                                */
/* -------------------------------------------------------------------------- */

function LabelBadge({
  children,
  variant = "default",
  tone = "soft",
  size = "md",
  dot = false,
  icon,
  onRemove,
  removeLabel,
  className,
}: BadgeProps) {
  const reduce = useReducedMotion() ?? false;
  // Inside an AnimatePresence the badge pops in when added; anywhere else it
  // renders as-is so server HTML is visible before hydration.
  const inPresence = useContext(PresenceContext) !== null;
  const rootRef = useRef<HTMLSpanElement>(null);
  const [leaving, setLeaving] = useState(false);
  const refocus = useRef<HTMLElement | null>(null);
  const removable = Boolean(onRemove);

  const hidden = reduce ? { opacity: 0 } : { opacity: 0, scale: 0.8 };

  const startRemove = (fromKeyboardFocus: boolean) => {
    if (leaving) return;
    if (fromKeyboardFocus) refocus.current = neighbourRemoveButton(rootRef.current);
    setLeaving(true);
  };

  const finishRemove = () => {
    if (!leaving) return;
    const target = refocus.current;
    refocus.current = null;
    onRemove?.();
    if (target) requestAnimationFrame(() => target.focus({ preventScroll: true }));
  };

  const text = typeof children === "string" ? children : undefined;

  return (
    <motion.span
      ref={rootRef}
      data-badge=""
      // Siblings glide into the gap a removed chip leaves (transform-only).
      layout={removable && !reduce ? "position" : false}
      initial={inPresence ? hidden : false}
      animate={
        leaving
          ? { ...hidden, pointerEvents: "none" }
          : { opacity: 1, scale: 1, pointerEvents: "auto" }
      }
      // Already faded out by the × — leave at once so siblings close the gap.
      exit={{
        ...hidden,
        pointerEvents: "none",
        transition: { duration: leaving ? 0 : 0.12, ease: EASE_OUT },
      }}
      transition={
        leaving
          ? { duration: 0.14, ease: EASE_OUT }
          : reduce
            ? { duration: 0.12 }
            : { ...SPRING_PANEL, layout: SPRING_LAYOUT }
      }
      onAnimationComplete={finishRemove}
      className={cn(
        "inline-flex shrink-0 select-none items-center whitespace-nowrap rounded-full border font-medium leading-none",
        SIZE[size],
        variantClass(variant, tone),
        removable && (size === "sm" ? "pr-0.5" : "pr-1"),
        className,
      )}
    >
      {dot ? (
        <Dot pulse={dot === "pulse" && !reduce} />
      ) : icon ? (
        <span aria-hidden="true" className="inline-flex shrink-0">
          {icon}
        </span>
      ) : null}
      <span className="min-w-0 truncate">{children}</span>
      {removable ? (
        <button
          type="button"
          data-badge-remove=""
          aria-label={removeLabel ?? (text ? `Remove ${text}` : "Remove")}
          onClick={(event) => startRemove(event.detail === 0)}
          onKeyDown={(event: ReactKeyboardEvent<HTMLButtonElement>) => {
            if (event.key === "Backspace" || event.key === "Delete") {
              event.preventDefault();
              startRemove(true);
            }
          }}
          className={cn(
            "inline-flex shrink-0 items-center justify-center rounded-full opacity-70 outline-none transition-[opacity,background-color] hover:bg-current/15 hover:opacity-100 focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-current/40",
            size === "sm" ? "size-4" : "size-[18px]",
          )}
        >
          <X aria-hidden="true" strokeWidth={2.4} className="size-3!" />
        </button>
      ) : null}
    </motion.span>
  );
}

/** The × of the next chip in the row, else the previous one. */
function neighbourRemoveButton(node: HTMLElement | null) {
  if (!node) return null;
  const pick = (el: Element | null) =>
    el?.querySelector<HTMLElement>("[data-badge-remove]") ?? null;
  let next = node.nextElementSibling;
  while (next && !pick(next)) next = next.nextElementSibling;
  if (next) return pick(next);
  let prev = node.previousElementSibling;
  while (prev && !pick(prev)) prev = prev.previousElementSibling;
  return prev ? pick(prev) : null;
}

// One pulse cycle of the dot's radiating ring, in seconds. Slow on purpose:
// an ambient "live" signal, not feedback, so it sits well outside UI timing.
const PULSE_DURATION = 1.6;

function Dot({ pulse }: { pulse: boolean }) {
  return (
    <span aria-hidden="true" className="relative inline-flex size-1.5 shrink-0">
      {pulse ? (
        <motion.span
          className="absolute inset-0 rounded-full bg-current"
          initial={{ scale: 1, opacity: 0.55 }}
          animate={{ scale: 2.6, opacity: 0 }}
          transition={{
            duration: PULSE_DURATION,
            ease: EASE_OUT,
            repeat: Number.POSITIVE_INFINITY,
          }}
        />
      ) : null}
      <span className="relative size-1.5 rounded-full bg-current" />
    </span>
  );
}

/* -------------------------------------------------------------------------- */
/*                                 Count badge                                */
/* -------------------------------------------------------------------------- */

function CountBadge({
  count,
  max = 99,
  showZero = false,
  countLabel,
  variant = "destructive",
  tone = "solid",
  size = "md",
  className,
}: BadgeProps & { count: number }) {
  const reduce = useReducedMotion() ?? false;
  const [scope, animate] = useAnimate<HTMLSpanElement>();
  const value = Math.max(0, Math.round(count));
  const visible = value > 0 || showZero;
  const text = value > max ? `${max}+` : String(value);

  // Direction is derived during render (not in an effect) so the very render
  // that swaps the digits already rolls them the right way.
  const [seen, setSeen] = useState(value);
  const [direction, setDirection] = useState<1 | -1>(1);
  if (value !== seen) {
    setSeen(value);
    setDirection(value > seen ? 1 : -1);
  }

  // Rising counts bump the pill (not on the pop-in from zero, which has its
  // own entrance).
  const previous = useRef(value);
  useEffect(() => {
    const prev = previous.current;
    previous.current = value;
    if (value > prev && prev > 0 && !reduce && scope.current) {
      animate(scope.current, { scale: [1, 1.18, 1] }, { duration: 0.32, ease: EASE_OUT });
    }
  }, [value, reduce, animate, scope]);

  return (
    <AnimatePresence initial={false}>
      {visible ? (
        <motion.span
          key="count"
          initial={reduce ? { opacity: 0 } : { opacity: 0, scale: 0.4 }}
          animate={{ opacity: 1, scale: 1 }}
          exit={
            reduce
              ? { opacity: 0, transition: { duration: 0.1 } }
              : { opacity: 0, scale: 0.4, transition: { duration: 0.14, ease: EASE_OUT } }
          }
          transition={reduce ? { duration: 0.12 } : SPRING_PANEL}
          className={cn("inline-flex shrink-0", className)}
        >
          <span
            ref={scope}
            data-badge-count=""
            className={cn(
              "inline-flex items-center justify-center rounded-full border font-semibold leading-none tabular-nums",
              COUNT_SIZE[size],
              variantClass(variant, tone),
            )}
          >
            <span className="sr-only">{countLabel ? countLabel(value) : text}</span>
            <RollingCount text={text} direction={direction} reduce={reduce} />
          </span>
        </motion.span>
      ) : null}
    </AnimatePresence>
  );
}

const roll: Variants = {
  enter: (dir: 1 | -1) => ({ y: dir > 0 ? "100%" : "-100%", opacity: 0 }),
  center: { y: "0%", opacity: 1 },
  exit: (dir: 1 | -1) => ({
    y: dir > 0 ? "-100%" : "100%",
    opacity: 0,
    transition: { duration: 0.14, ease: EASE_OUT },
  }),
};

const fade: Variants = {
  enter: { opacity: 0 },
  center: { opacity: 1 },
  exit: { opacity: 0, transition: { duration: 0.1 } },
};

/**
 * Direction-aware digit roll. `NumberTicker` spins each digit along a 0–9
 * strip, so 9 → 10 would roll the ones digit backwards; here every changed
 * glyph slides in from the direction of change instead.
 */
function RollingCount({
  text,
  direction,
  reduce,
}: {
  text: string;
  direction: 1 | -1;
  reduce: boolean;
}) {
  const chars = text.split("");
  // Keyed by place value from the right so a digit keeps its slot as the
  // number grows on the left.
  const glyphs = chars.map((char, i) => ({ char, place: chars.length - 1 - i }));
  return (
    <span aria-hidden="true" className="inline-flex">
      {glyphs.map(({ char, place }) => (
        <span
          key={place}
          className="relative inline-flex h-[1.2em] items-center justify-center overflow-hidden"
        >
          <span className="invisible">{char}</span>
          <AnimatePresence initial={false} custom={direction}>
            <motion.span
              key={char}
              custom={direction}
              variants={reduce ? fade : roll}
              initial="enter"
              animate="center"
              exit="exit"
              transition={reduce ? { duration: 0.12 } : SPRING_SWAP}
              className="absolute inset-0 flex items-center justify-center"
            >
              {char}
            </motion.span>
          </AnimatePresence>
        </span>
      ))}
    </span>
  );
}

"use client";

import { motion, useReducedMotion } from "motion/react";
import { Fragment, type ReactNode, useEffect, useState } from "react";
import { SPRING_PRESS } from "@/lib/ease";
import { cn } from "@/lib/utils";

/* -------------------------------------------------------------------------- */
/*                                  Platform                                  */
/* -------------------------------------------------------------------------- */

function detectApple() {
  const nav = navigator as Navigator & {
    userAgentData?: { platform?: string };
  };
  const platform = nav.userAgentData?.platform ?? nav.platform ?? "";
  return /mac|iphone|ipad|ipod/i.test(platform);
}

/**
 * True on Apple platforms. Always `true` on the server and the first client
 * render (so markup matches), then corrected after mount — `Mod` therefore
 * renders ⌘ first and swaps to Ctrl on other platforms.
 */
export function useIsApple() {
  const [apple, setApple] = useState(true);
  useEffect(() => setApple(detectApple()), []);
  return apple;
}

type KeyLabel = { glyph: string; name: string };

/** Display glyph + spoken name for a key token like "mod", "shift", "k". */
export function keyLabel(key: string, apple: boolean): KeyLabel {
  const k = key.toLowerCase();
  switch (k) {
    case "mod":
      return apple
        ? { glyph: "⌘", name: "Command" }
        : { glyph: "Ctrl", name: "Control" };
    case "cmd":
    case "command":
    case "meta":
      return apple
        ? { glyph: "⌘", name: "Command" }
        : { glyph: "Win", name: "Windows" };
    case "ctrl":
    case "control":
      return apple
        ? { glyph: "⌃", name: "Control" }
        : { glyph: "Ctrl", name: "Control" };
    case "shift":
      return apple
        ? { glyph: "⇧", name: "Shift" }
        : { glyph: "Shift", name: "Shift" };
    case "alt":
    case "option":
      return apple
        ? { glyph: "⌥", name: "Option" }
        : { glyph: "Alt", name: "Alt" };
    case "enter":
    case "return":
      return { glyph: "↵", name: "Enter" };
    case "esc":
    case "escape":
      return { glyph: "Esc", name: "Escape" };
    case "backspace":
      return { glyph: "⌫", name: "Backspace" };
    case "delete":
      return { glyph: "⌦", name: "Delete" };
    case "tab":
      return { glyph: "⇥", name: "Tab" };
    case "space":
      return { glyph: "Space", name: "Space" };
    case "up":
    case "arrowup":
      return { glyph: "↑", name: "Up arrow" };
    case "down":
    case "arrowdown":
      return { glyph: "↓", name: "Down arrow" };
    case "left":
    case "arrowleft":
      return { glyph: "←", name: "Left arrow" };
    case "right":
    case "arrowright":
      return { glyph: "→", name: "Right arrow" };
    default:
      return key.length === 1
        ? { glyph: key.toUpperCase(), name: key.toUpperCase() }
        : { glyph: key, name: key };
  }
}

/* -------------------------------------------------------------------------- */
/*                               Key listening                                */
/* -------------------------------------------------------------------------- */

/** Does this keyboard event's key correspond to the token? */
function eventMatches(token: string, event: KeyboardEvent, apple: boolean) {
  const k = token.toLowerCase();
  const key = event.key.toLowerCase();
  switch (k) {
    case "mod":
      return key === (apple ? "meta" : "control");
    case "cmd":
    case "command":
    case "meta":
      return key === "meta";
    case "ctrl":
    case "control":
      return key === "control";
    case "alt":
    case "option":
      return key === "alt";
    case "esc":
      return key === "escape";
    case "return":
      return key === "enter";
    case "space":
      return event.code === "Space";
    case "up":
    case "down":
    case "left":
    case "right":
      return key === `arrow${k}`;
    default:
      // Letters and digits by physical key, so Shift/Option variants
      // ("P" with Shift, "π" with Option) still match.
      if (/^[a-z]$/.test(k)) return event.code === `Key${k.toUpperCase()}`;
      if (/^[0-9]$/.test(k)) return event.code === `Digit${k}`;
      return key === k;
  }
}

const MODIFIERS = new Set(["meta", "control", "shift", "alt"]);

/**
 * Tracks which of `keys` are physically held. Listens on window without
 * preventing default, so it never steals the shortcut from the page.
 */
export function useKeysPressed(keys: string[], enabled = true) {
  const apple = useIsApple();
  const [held, setHeld] = useState<boolean[]>(() => keys.map(() => false));
  const signature = keys.join("+");

  useEffect(() => {
    const tokens = signature.split("+");
    setHeld(tokens.map(() => false));
    if (!enabled) return;
    const down = new Set<number>();
    const sync = () => setHeld(tokens.map((_, i) => down.has(i)));

    const onDown = (event: KeyboardEvent) => {
      let changed = false;
      tokens.forEach((token, i) => {
        if (!down.has(i) && eventMatches(token, event, apple)) {
          down.add(i);
          changed = true;
        }
      });
      if (changed) sync();
    };
    const onUp = (event: KeyboardEvent) => {
      // macOS swallows keyup for other keys while ⌘ is held, so releasing a
      // modifier releases everything.
      if (MODIFIERS.has(event.key.toLowerCase()) && apple) {
        down.clear();
        sync();
        return;
      }
      let changed = false;
      tokens.forEach((token, i) => {
        if (down.has(i) && eventMatches(token, event, apple)) {
          down.delete(i);
          changed = true;
        }
      });
      if (changed) sync();
    };
    const reset = () => {
      down.clear();
      sync();
    };
    window.addEventListener("keydown", onDown);
    window.addEventListener("keyup", onUp);
    window.addEventListener("blur", reset);
    return () => {
      window.removeEventListener("keydown", onDown);
      window.removeEventListener("keyup", onUp);
      window.removeEventListener("blur", reset);
    };
  }, [signature, enabled, apple]);

  return held;
}

/* -------------------------------------------------------------------------- */
/*                                    Kbd                                     */
/* -------------------------------------------------------------------------- */

type KbdSize = "sm" | "md";

const SIZE: Record<KbdSize, string> = {
  sm: "h-5 min-w-5 px-1 text-[11px] rounded-[5px] border-b-[2px]",
  md: "h-6 min-w-6 px-1.5 text-xs rounded-md border-b-[3px]",
};

// How far the key drops when pressed, in px — matches the thicker bottom edge
// so the cap visibly sinks into its base.
const DIP: Record<KbdSize, number> = { sm: 1.5, md: 2 };

export interface KbdProps {
  /** A key token ("mod", "shift", "k", "enter"…) or any custom content. */
  children: ReactNode;
  size?: KbdSize;
  /** Show the key pressed (spring dip). */
  pressed?: boolean;
  /** Dip when the real key is held. Needs `children` to be a key token string. */
  listen?: boolean;
  className?: string;
}

/**
 * A single keyboard key. String children are treated as key tokens, so
 * `<Kbd>mod</Kbd>` renders ⌘ on Apple platforms and Ctrl elsewhere.
 */
export function Kbd({
  children,
  size = "md",
  pressed = false,
  listen = false,
  className,
}: KbdProps) {
  const apple = useIsApple();
  const token = typeof children === "string" ? children : null;
  const [held] = useKeysPressed(token ? [token] : [], listen && token !== null);
  const label = token ? keyLabel(token, apple) : null;

  return (
    <KeyCap
      size={size}
      pressed={pressed || Boolean(held)}
      title={label?.name}
      className={className}
    >
      {label ? label.glyph : children}
    </KeyCap>
  );
}

function KeyCap({
  children,
  size,
  pressed,
  title,
  className,
}: {
  children: ReactNode;
  size: KbdSize;
  pressed: boolean;
  title?: string;
  className?: string;
}) {
  const reduce = useReducedMotion() ?? false;
  return (
    <motion.kbd
      title={title}
      data-pressed={pressed ? "" : undefined}
      initial={false}
      animate={
        reduce
          ? { opacity: pressed ? 0.7 : 1 }
          : { y: pressed ? DIP[size] : 0, scale: pressed ? 0.96 : 1 }
      }
      transition={reduce ? { duration: 0.1 } : SPRING_PRESS}
      className={cn(
        "inline-flex select-none items-center justify-center border border-border border-b-border-strong bg-muted font-sans font-medium leading-none text-muted-foreground",
        "data-[pressed]:border-b-border data-[pressed]:bg-foreground/[0.08] data-[pressed]:text-foreground",
        SIZE[size],
        className,
      )}
    >
      {children}
    </motion.kbd>
  );
}

export interface KbdComboProps {
  /** Key tokens, e.g. ["mod", "shift", "p"]. */
  keys: string[];
  size?: KbdSize;
  /** Show every key pressed. */
  pressed?: boolean;
  /** Dip each key while the real key is held. */
  listen?: boolean;
  /** Text between keys. Default none on Apple, "+" elsewhere. */
  separator?: ReactNode;
  className?: string;
}

/**
 * A key combination: one chip per key, platform-aware, with a spoken label
 * ("Command + Shift + P") for assistive tech.
 */
export function KbdCombo({
  keys,
  size = "md",
  pressed = false,
  listen = false,
  separator,
  className,
}: KbdComboProps) {
  const apple = useIsApple();
  const held = useKeysPressed(keys, listen);
  const labels = keys.map((key) => keyLabel(key, apple));
  const sep = separator === undefined ? (apple ? null : "+") : separator;

  return (
    <kbd
      className={cn(
        "inline-flex items-center gap-1 font-sans text-muted-foreground",
        className,
      )}
    >
      <span className="sr-only">{labels.map((l) => l.name).join(" + ")}</span>
      <span aria-hidden="true" className="inline-flex items-center gap-1">
        {labels.map((label, i) => (
          <Fragment key={keys[i]}>
            {i > 0 && sep !== null ? (
              <span className="text-[10px] text-muted-foreground/70">{sep}</span>
            ) : null}
            <KeyCap size={size} pressed={pressed || Boolean(held[i])}>
              {label.glyph}
            </KeyCap>
          </Fragment>
        ))}
      </span>
    </kbd>
  );
}

"use client";

import { AnimatePresence, motion, useReducedMotion } from "motion/react";
import {
  cloneElement,
  createContext,
  isValidElement,
  type ReactElement,
  type ReactNode,
  type Ref,
  useCallback,
  useContext,
  useEffect,
  useId,
  useMemo,
  useRef,
  useState,
} from "react";
import { createPortal } from "react-dom";
import { usePopoverPortalPosition } from "@/components/motion/popover-position";
import { EASE_OUT, SPRING_PANEL } from "@/lib/ease";
import { cn } from "@/lib/utils";

type Side = "top" | "bottom";
type Align = "start" | "end";

type MorphContextValue = {
  open: boolean;
  setOpen: (open: boolean) => void;
  toggle: () => void;
  triggerId: string;
  contentId: string;
  /** The element the panel measures against — see `registerTrigger`. */
  triggerRef: React.MutableRefObject<HTMLElement | null>;
  registerTrigger: (node: HTMLElement | null) => void;
  contentRef: React.MutableRefObject<HTMLDivElement | null>;
};

const MorphContext = createContext<MorphContextValue | null>(null);

function useMorphContext(component: string) {
  const ctx = useContext(MorphContext);
  if (!ctx) throw new Error(`${component} must be used within <MorphPopover>`);
  return ctx;
}

export interface MorphPopoverProps {
  children: ReactNode;
  /** Controlled open state. */
  open?: boolean;
  /** Uncontrolled initial open state. */
  defaultOpen?: boolean;
  onOpenChange?: (open: boolean) => void;
  className?: string;
}

/**
 * A popover whose panel morphs open from the trigger corner: it's laid out at
 * full size but clipped to the corner nearest the trigger, then unclips as one
 * piece. Closes on outside pointer / Escape. Controlled or uncontrolled.
 */
export function MorphPopover({
  children,
  open: controlledOpen,
  defaultOpen = false,
  onOpenChange,
  className,
}: MorphPopoverProps) {
  const baseId = useId();
  const [root, setRoot] = useState<HTMLDivElement | null>(null);
  const [trigger, setTrigger] = useState<HTMLElement | null>(null);
  const contentRef = useRef<HTMLDivElement | null>(null);
  const [internalOpen, setInternalOpen] = useState(defaultOpen);
  const controlled = controlledOpen !== undefined;
  const open = controlled ? controlledOpen : internalOpen;

  const setOpen = useCallback(
    (next: boolean) => {
      if (!controlled) setInternalOpen(next);
      onOpenChange?.(next);
    },
    [controlled, onOpenChange],
  );
  const toggle = useCallback(() => setOpen(!open), [setOpen, open]);

  // A trigger normally registers itself through MorphPopoverTrigger. It can't
  // when something else already clones the element — a Tooltip wrapping the
  // button, say — and an unregistered trigger leaves the panel with nothing to
  // measure against, so it renders permanently invisible. The root boxes the
  // trigger exactly (the content portals out of it), so it stands in until a
  // real trigger registers, and stands in again if that one unmounts. Both are
  // state, so a trigger arriving while the panel is open re-anchors it.
  const anchorRef = useMemo<React.MutableRefObject<HTMLElement | null>>(
    () => ({ current: trigger ?? root }),
    [root, trigger],
  );

  // The panel is a `role="dialog"` and goes inert the moment it closes, so
  // focus cannot be left sitting inside it: a dismissal hands it back to the
  // trigger, the way the ARIA dialog pattern asks. A pointer dismissal takes
  // the focus onward itself when it lands on something focusable — this only
  // catches the case where it would otherwise be stranded. When no trigger has
  // registered, the root anchor stands in only if it can actually hold focus;
  // there is nowhere better than where the keyboard already is, so leave it.
  const close = useCallback(() => {
    setOpen(false);
    const focused = document.activeElement;
    const inPanel =
      focused instanceof HTMLElement && contentRef.current?.contains(focused);
    if (!inPanel) return;
    const restore = trigger ?? (root && root.tabIndex >= 0 ? root : null);
    restore?.focus();
  }, [root, setOpen, trigger]);

  useEffect(() => {
    if (!open) return;
    const onKey = (e: KeyboardEvent) => e.key === "Escape" && close();
    const onPointer = (e: PointerEvent) => {
      const target = e.target as Node;
      if (
        root &&
        !root.contains(target) &&
        !contentRef.current?.contains(target)
      )
        close();
    };
    window.addEventListener("keydown", onKey);
    window.addEventListener("pointerdown", onPointer);
    return () => {
      window.removeEventListener("keydown", onKey);
      window.removeEventListener("pointerdown", onPointer);
    };
  }, [open, root, close]);

  const ctx = useMemo<MorphContextValue>(
    () => ({
      open,
      setOpen,
      toggle,
      triggerId: `${baseId}-trigger`,
      contentId: `${baseId}-content`,
      triggerRef: anchorRef,
      registerTrigger: setTrigger,
      contentRef,
    }),
    [open, setOpen, toggle, baseId, anchorRef],
  );

  return (
    <MorphContext.Provider value={ctx}>
      <div ref={setRoot} className={cn("relative inline-flex", className)}>
        {children}
      </div>
    </MorphContext.Provider>
  );
}

export interface MorphPopoverTriggerProps {
  children: ReactElement;
}

function mergeRefs<T>(...refs: Array<Ref<T> | undefined>) {
  return (node: T | null) => {
    for (const ref of refs) {
      if (typeof ref === "function") ref(node);
      else if (ref && typeof ref === "object")
        (ref as React.MutableRefObject<T | null>).current = node;
    }
  };
}

/** Wraps a single element, toggling the popover on click. */
export function MorphPopoverTrigger({ children }: MorphPopoverTriggerProps) {
  const ctx = useMorphContext("MorphPopoverTrigger");
  if (!isValidElement(children)) return children;

  const child = children as ReactElement<Record<string, unknown>>;
  const childOnClick = child.props.onClick as
    | ((e: unknown) => void)
    | undefined;
  const childRef = (child.props as { ref?: Ref<HTMLElement> }).ref;

  return cloneElement(child, {
    id: ctx.triggerId,
    ref: mergeRefs(childRef, ctx.registerTrigger),
    onClick: (e: unknown) => {
      childOnClick?.(e);
      ctx.toggle();
    },
    "aria-haspopup": "dialog",
    "aria-expanded": ctx.open,
    "aria-controls": ctx.open ? ctx.contentId : undefined,
  });
}

const originFor = (side: Side, align: Align) =>
  `${side === "bottom" ? "top" : "bottom"} ${align === "end" ? "right" : "left"}`;

// A clip that hides everything but the corner nearest the trigger, so the
// panel appears to grow out of it. inset(top right bottom left).
function clipHidden(side: Side, align: Align, radius: number) {
  const top = side === "bottom" ? "0%" : "92%";
  const bottom = side === "bottom" ? "92%" : "0%";
  const right = align === "end" ? "0%" : "92%";
  const left = align === "end" ? "92%" : "0%";
  return `inset(${top} ${right} ${bottom} ${left} round ${radius}px)`;
}
const clipShown = (radius: number) => `inset(0% 0% 0% 0% round ${radius}px)`;

// Preserve the original spring character on the wrapper, but tween the complex
// clip-path so it cannot snap when the spring resolves its final distance.
const MORPH_CLIP_TRANSITION = { duration: 0.32, ease: EASE_OUT } as const;

export interface MorphPopoverContentProps {
  children: ReactNode;
  side?: Side;
  align?: Align;
  /** Gap between trigger and panel, in px. Default 8. */
  sideOffset?: number;
  /** Panel corner radius, in px. Default 16. */
  radius?: number;
  className?: string;
}

export function MorphPopoverContent({
  children,
  side = "bottom",
  align = "end",
  sideOffset = 8,
  radius = 16,
  className,
}: MorphPopoverContentProps) {
  const ctx = useMorphContext("MorphPopoverContent");
  const reduce = useReducedMotion() ?? false;
  const [portalReady, setPortalReady] = useState(false);
  const layout = usePopoverPortalPosition(
    ctx.triggerRef,
    ctx.contentRef,
    portalReady && ctx.open,
  );

  useEffect(() => setPortalReady(true), []);
  const left = layout
    ? align === "end"
      ? layout.trigger.left + layout.trigger.width - layout.content.width
      : layout.trigger.left
    : 0;
  const top = layout
    ? side === "bottom"
      ? layout.trigger.top + layout.trigger.height + sideOffset
      : layout.trigger.top - layout.content.height - sideOffset
    : 0;

  // Both directions travel between the exact same hidden/show states. Exit
  // targets "hidden" directly instead of introducing separate choreography.
  const wrap = reduce
    ? undefined
    : {
        hidden: { opacity: 0, scale: 0.96, transition: SPRING_PANEL },
        show: { opacity: 1, scale: 1, transition: SPRING_PANEL },
      };
  const clip = reduce
    ? undefined
    : {
        hidden: {
          clipPath: clipHidden(side, align, radius),
          transition: MORPH_CLIP_TRANSITION,
        },
        show: {
          clipPath: clipShown(radius),
          transition: MORPH_CLIP_TRANSITION,
        },
      };

  // Keep the server and first client render identical, then mount the portal.
  if (!portalReady) return null;

  return createPortal(
    <AnimatePresence>
      {ctx.open ? (
        <motion.div
          data-morph-popover-portal=""
          // Wrapper carries the shadow as a drop-shadow filter, which hugs the
          // clipped shape below (box-shadow would just get clipped away).
          variants={wrap}
          initial={reduce ? { opacity: 0 } : "hidden"}
          animate={reduce ? { opacity: 1 } : "show"}
          exit={reduce ? { opacity: 0 } : "hidden"}
          transition={reduce ? { duration: 0.12 } : undefined}
          style={{
            left,
            top,
            visibility: layout ? "visible" : "hidden",
            transformOrigin: originFor(side, align),
          }}
          className="fixed z-[9999] [filter:drop-shadow(0_10px_18px_rgba(0,0,0,0.14))]"
        >
          <motion.div
            ref={ctx.contentRef}
            id={ctx.contentId}
            role="dialog"
            aria-labelledby={ctx.triggerId}
            variants={clip}
            style={{ borderRadius: radius }}
            className={cn(
              "overflow-hidden border border-border bg-background",
              className,
            )}
          >
            {children}
          </motion.div>
        </motion.div>
      ) : null}
    </AnimatePresence>,
    document.body,
  );
}