Newsletter Section

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

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

/**
 * Grow a small control's *hit area* to at least 44×44px (WCAG 2.5.5, Apple
 * HIG) on a coarse pointer, without changing what it looks like or the space
 * it takes in layout. An invisible `::after` box, centered on the control and
 * `max(100%, 2.75rem)` on each axis, catches the taps: a 32px icon button
 * reaches 6px past each edge, a wide 40px button only grows vertically, and a
 * control already 44px or larger is left as it is. Hit-testing a pseudo
 * element lands on its owner, so handlers, focus and `:active` all behave.
 *
 * Mouse and trackpad rendering is untouched — nothing here applies outside
 * `pointer: coarse`. Requirements on the element it goes on:
 * - It must be the containing block: add `relative` (and keep it mergeable, so
 *   a consumer's `absolute` still wins through `cn`).
 * - It must not clip itself (`overflow-hidden`), or the overhang is clipped
 *   away along with its hit area.
 * - It must render children: `<input>` and other void elements have no
 *   `::after`. Put it on the wrapper or label instead.
 * - It must not already use `::after` for something visible.
 *
 * Centered 44px means two 32px buttons with a 4px gap overlap by 8px; the
 * later one wins that strip, which still ends well short of the earlier
 * button's visual center. Below a ~32px pitch the later neighbour starts
 * eating into that center — use `TOUCH_TARGET_Y_CLASS` for such dense rows.
 *
 * The overhang is real geometry: inside a scroll container it counts as
 * scrollable overflow, so a control flush against a scroller's edge can add a
 * few pixels of scroll on touch screens. Give such a scroller a little padding
 * on that side.
 */
export const TOUCH_TARGET_CLASS =
  "pointer-coarse:after:absolute pointer-coarse:after:top-1/2 pointer-coarse:after:left-1/2 pointer-coarse:after:size-[max(100%,2.75rem)] pointer-coarse:after:-translate-x-1/2 pointer-coarse:after:-translate-y-1/2 pointer-coarse:after:content-['']";

/**
 * `TOUCH_TARGET_CLASS` on the vertical axis only, for controls packed tighter
 * than ~32px apart in a row (pagination dots, dense swatches), where growing
 * sideways would hand most of each control to its neighbour. Same rules.
 */
export const TOUCH_TARGET_Y_CLASS =
  "pointer-coarse:after:absolute pointer-coarse:after:inset-x-0 pointer-coarse:after:top-1/2 pointer-coarse:after:h-[max(100%,2.75rem)] pointer-coarse:after:-translate-y-1/2 pointer-coarse:after:content-['']";

/**
 * 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";
// karaui.kamisama-v0.my.id/components/blocks/newsletter-section

import { Mail, Send } from "lucide-react";
import { AnimatePresence, motion, useReducedMotion } from "motion/react";
import {
  type FormEvent,
  type ReactNode,
  useEffect,
  useId,
  useRef,
  useState,
} from "react";
import { AvatarGroup, type AvatarGroupItem } from "@/components/motion/avatar-group";
import { type ButtonState, StatefulButton } from "@/components/motion/button";
import { Input } from "@/components/motion/input";
import { EASE_OUT, SPRING_LAYOUT, SPRING_SWAP } from "@/lib/ease";
import { cn } from "@/lib/utils";

export interface NewsletterSocialProof {
  /** Avatars shown in an overlapping stack. */
  avatars: AvatarGroupItem[];
  /** Copy beside the stack, e.g. "Join 4,200 readers". */
  label: ReactNode;
  /** Avatars before a "+N" chip. Default 4. */
  max?: number;
}

export interface NewsletterSectionProps {
  /** "card" is a centered bordered panel; "inline" puts copy and form side by side. */
  variant?: "card" | "inline";
  eyebrow?: ReactNode;
  heading?: ReactNode;
  description?: ReactNode;
  placeholder?: string;
  buttonLabel?: string;
  /** Resolve to confirm; reject (or throw) to show the error state. */
  onSubscribe?: (email: string) => Promise<void> | void;
  /** Small print under the form. Pass null to hide. */
  privacyNote?: ReactNode;
  socialProof?: NewsletterSocialProof;
  successTitle?: ReactNode;
  /** Receives the subscribed address. */
  successMessage?: ReactNode | ((email: string) => ReactNode);
  invalidEmailMessage?: string;
  errorMessage?: string;
  className?: string;
}

const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;

/** Light check used before `onSubscribe`; the server stays the source of truth. */
export function isValidNewsletterEmail(value: string) {
  return EMAIL_PATTERN.test(value.trim());
}

const SWAP_ENTER = { duration: 0.32, ease: EASE_OUT } as const;
const SWAP_EXIT = { duration: 0.16, ease: EASE_OUT } as const;
const ERROR_RESET_MS = 2400;

function SuccessCheck({ reduce }: { reduce: boolean }) {
  return (
    <motion.span
      initial={{ scale: reduce ? 1 : 0.6, opacity: 0 }}
      animate={{ scale: 1, opacity: 1 }}
      transition={reduce ? SWAP_ENTER : SPRING_SWAP}
      className="grid size-11 shrink-0 place-items-center rounded-full bg-success/15 text-success"
    >
      <svg aria-hidden="true" viewBox="0 0 24 24" fill="none" className="size-5">
        <motion.path
          d="M5 12.5l4.5 4.5L19 7.5"
          stroke="currentColor"
          strokeWidth={2.5}
          strokeLinecap="round"
          strokeLinejoin="round"
          initial={{ pathLength: reduce ? 1 : 0 }}
          animate={{ pathLength: 1 }}
          transition={{ duration: 0.4, ease: EASE_OUT, delay: reduce ? 0 : 0.12 }}
        />
      </svg>
    </motion.span>
  );
}

/**
 * Newsletter signup section: heading, an email field with idle/loading/
 * success/error states driven by the `onSubscribe` promise (with a light
 * client-side email check), a privacy note and optional social-proof avatars.
 * On success the form morphs into a confirmation with a draw-in check. Two
 * layouts: a centered "card" and a side-by-side "inline" band that stacks in
 * narrow containers.
 */
export function NewsletterSection({
  variant = "card",
  eyebrow,
  heading = "Get the weekly digest",
  description = "One short email every Friday with new components, motion notes and the occasional deep dive.",
  placeholder = "you@example.com",
  buttonLabel = "Subscribe",
  onSubscribe,
  privacyNote = "No spam. Unsubscribe with one click.",
  socialProof,
  successTitle = "You're on the list",
  successMessage = (email: string) => (
    <>
      We sent a confirmation to <span className="font-medium text-foreground">{email}</span>.
    </>
  ),
  invalidEmailMessage = "Enter a valid email address.",
  errorMessage = "Something went wrong. Please try again.",
  className,
}: NewsletterSectionProps) {
  const reduce = useReducedMotion() ?? false;
  const id = useId();
  const [email, setEmail] = useState("");
  const [state, setState] = useState<ButtonState>("idle");
  const [error, setError] = useState<string | null>(null);
  const [subscribed, setSubscribed] = useState("");
  const timer = useRef<number | undefined>(undefined);
  const successRef = useRef<HTMLDivElement>(null);

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

  const done = state === "success";

  // Move focus to the confirmation so keyboard and screen reader users land
  // on the result instead of a removed form.
  useEffect(() => {
    if (done) successRef.current?.focus({ preventScroll: true });
  }, [done]);

  const submit = async (event: FormEvent<HTMLFormElement>) => {
    event.preventDefault();
    if (state === "loading" || done) return;
    if (!isValidNewsletterEmail(email)) {
      setError(invalidEmailMessage);
      return;
    }
    const value = email.trim();
    setError(null);
    setState("loading");
    try {
      await onSubscribe?.(value);
      setSubscribed(value);
      setState("success");
    } catch {
      setState("error");
      setError(errorMessage);
      if (timer.current) window.clearTimeout(timer.current);
      timer.current = window.setTimeout(() => setState("idle"), ERROR_RESET_MS);
    }
  };

  const inline = variant === "inline";
  const swapInitial = reduce ? { opacity: 0 } : { opacity: 0, y: 10, filter: "blur(4px)" };
  const swapExit = reduce
    ? { opacity: 0, transition: SWAP_EXIT }
    : { opacity: 0, y: -8, filter: "blur(4px)", transition: SWAP_EXIT };

  const form = (
    <motion.form
      key="form"
      noValidate
      onSubmit={submit}
      initial={swapInitial}
      animate={{ opacity: 1, y: 0, filter: "blur(0px)" }}
      exit={swapExit}
      transition={SWAP_ENTER}
      className="flex w-full flex-col gap-2"
    >
      <div className="flex w-full flex-col gap-2 @md:flex-row @md:items-start">
        <Input
          id={`${id}-email`}
          type="email"
          inputMode="email"
          autoComplete="email"
          aria-label="Email address"
          placeholder={placeholder}
          value={email}
          onChange={(next) => {
            setEmail(next);
            if (error && isValidNewsletterEmail(next)) setError(null);
          }}
          error={error ?? undefined}
          leftIcon={<Mail aria-hidden />}
          className="min-w-0 flex-1"
          classNames={{ field: "bg-background", errorMessage: "text-left" }}
        />
        <StatefulButton
          type="submit"
          state={state}
          loadingText="Subscribing"
          successText="Subscribed"
          errorText="Try again"
          icon={<Send aria-hidden className="size-3.5" />}
          className="h-11 shrink-0"
        >
          {buttonLabel}
        </StatefulButton>
      </div>
      {privacyNote ? (
        <p className={cn("text-xs text-muted-foreground", inline ? "text-left" : "text-center @md:text-left")}>
          {privacyNote}
        </p>
      ) : null}
    </motion.form>
  );

  const confirmation = (
    <motion.div
      key="success"
      ref={successRef}
      tabIndex={-1}
      role="status"
      initial={swapInitial}
      animate={{ opacity: 1, y: 0, filter: "blur(0px)" }}
      transition={SWAP_ENTER}
      className="flex w-full items-center gap-3 rounded-2xl border border-border bg-background p-3 text-left outline-none focus-visible:ring-2 focus-visible:ring-ring"
    >
      <SuccessCheck reduce={reduce} />
      <div className="min-w-0">
        <p className="text-sm font-medium text-foreground">{successTitle}</p>
        <p className="text-sm text-muted-foreground">
          {typeof successMessage === "function" ? successMessage(subscribed) : successMessage}
        </p>
      </div>
    </motion.div>
  );

  const copy = (
    <div className={cn("flex flex-col gap-3", !inline && "items-center text-center")}>
      {eyebrow ? (
        <p className="text-xs font-medium uppercase tracking-[0.2em] text-muted-foreground">{eyebrow}</p>
      ) : null}
      {heading ? (
        <h2 className="text-balance text-2xl font-semibold leading-tight tracking-tight @3xl:text-3xl">
          {heading}
        </h2>
      ) : null}
      {description ? (
        <p className={cn("text-pretty text-sm leading-6 text-muted-foreground", !inline && "max-w-md")}>
          {description}
        </p>
      ) : null}
    </div>
  );

  const proof = socialProof ? (
    <div className={cn("flex items-center gap-3", !inline && "justify-center")}>
      <AvatarGroup items={socialProof.avatars} max={socialProof.max ?? 4} size="sm" label="Subscribers" ringClassName={inline ? undefined : "ring-card"} />
      <p className="text-xs font-medium text-muted-foreground">{socialProof.label}</p>
    </div>
  ) : null;

  // The form/confirmation swap changes height, so the slot morphs its layout
  // on purpose (the section must grow or shrink with the content).
  const slot = (
    <motion.div
      layout={reduce ? false : "size"}
      transition={{ layout: SPRING_LAYOUT }}
      className="w-full"
    >
      <AnimatePresence mode="wait" initial={false}>
        {done ? confirmation : form}
      </AnimatePresence>
    </motion.div>
  );

  return (
    <section className={cn("@container w-full text-foreground", className)}>
      {inline ? (
        <div className="grid items-center gap-6 border-y border-border py-8 @2xl:grid-cols-[minmax(0,1fr)_minmax(0,1fr)] @2xl:gap-10">
          <div className="flex flex-col gap-4">
            {copy}
            {proof}
          </div>
          {slot}
        </div>
      ) : (
        <div className="relative isolate mx-auto flex max-w-2xl flex-col items-center gap-6 overflow-hidden rounded-3xl border border-border bg-card px-5 py-10 text-card-foreground shadow-sm @md:px-10">
          {/* Decorative dot grid fading out from the top. */}
          <div
            aria-hidden
            className="pointer-events-none absolute inset-0 -z-10 bg-[radial-gradient(var(--border-strong)_1px,transparent_1px)] bg-[size:18px_18px] [mask-image:radial-gradient(ellipse_70%_60%_at_50%_0%,black,transparent)]"
          />
          {copy}
          <div className="w-full max-w-md">{slot}</div>
          {proof}
        </div>
      )}
    </section>
  );
}

"use client";

import {
  motion,
  useMotionValue,
  useReducedMotion,
  useSpring,
} from "motion/react";
import { useCallback, useEffect, useRef, useState } from "react";
import {
  MorphPopover,
  MorphPopoverContent,
  MorphPopoverTrigger,
} from "@/components/motion/popover-morph";
import { Tooltip } from "@/components/motion/tooltip";
import { EASE_OUT, SPRING_LAYOUT, SPRING_MOUSE } from "@/lib/ease";
import { useHoverCapable } from "@/lib/hooks/use-hover-capable";
import { cn } from "@/lib/utils";

export type AvatarStatus = "online" | "away" | "busy" | "offline";

export interface AvatarGroupItem {
  id: string;
  name: string;
  /** Image URL. Falls back to initials on a colored disc. */
  src?: string;
  /** Background for the initials fallback (any CSS color). */
  color?: string;
  status?: AvatarStatus;
  /** Shows a pulsing ring around the avatar. */
  typing?: boolean;
}

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

export interface AvatarGroupProps {
  items: AvatarGroupItem[];
  /** Avatars shown before the rest collapse into a "+N" chip. Default 4. */
  max?: number;
  size?: AvatarGroupSize;
  /** Makes avatars buttons; also used for rows in the overflow list. */
  onSelect?: (item: AvatarGroupItem) => void;
  /** Accessible label for the group. Default "Collaborators". */
  label?: string;
  className?: string;
  /** Ring color separating overlapped avatars; match the surface behind. */
  ringClassName?: string;
}

const SIZES: Record<
  AvatarGroupSize,
  { box: number; overlap: number; fan: number; text: string; dot: number }
> = {
  sm: { box: 28, overlap: 6, fan: 6, text: "text-[10px]", dot: 8 },
  md: { box: 36, overlap: 8, fan: 8, text: "text-xs", dot: 10 },
  lg: { box: 44, overlap: 10, fan: 10, text: "text-sm", dot: 12 },
};

const STATUS_CLASS: Record<AvatarStatus, string> = {
  online: "bg-emerald-500",
  away: "bg-amber-400",
  busy: "bg-rose-500",
  offline: "bg-muted-foreground/60",
};

const STATUS_LABEL: Record<AvatarStatus, string> = {
  online: "online",
  away: "away",
  busy: "busy",
  offline: "offline",
};

const CHART_VARS = [1, 2, 3, 4, 5].map((n) => `var(--chart-${n})`);

/** Deterministic fallback color from the name, so SSR and client agree. */
function colorFor(item: AvatarGroupItem) {
  if (item.color) return item.color;
  let hash = 0;
  for (const ch of item.name) hash = (hash * 31 + ch.charCodeAt(0)) | 0;
  return CHART_VARS[Math.abs(hash) % CHART_VARS.length];
}

function initials(name: string) {
  const parts = name.trim().split(/\s+/);
  return ((parts[0]?.[0] ?? "") + (parts[1]?.[0] ?? "")).toUpperCase();
}

function describe(item: AvatarGroupItem) {
  const bits = [item.name];
  if (item.status) bits.push(STATUS_LABEL[item.status]);
  if (item.typing) bits.push("typing");
  return bits.join(", ");
}

/**
 * Overlapping avatar stack that fans apart on hover or keyboard focus.
 * Each avatar carries a name tooltip, an optional presence dot and an
 * "is typing" pulse; avatars past `max` collapse into a "+N" chip that opens
 * the full list in a popover.
 */
export function AvatarGroup({
  items,
  max = 4,
  size = "md",
  onSelect,
  label = "Collaborators",
  className,
  ringClassName = "ring-background",
}: AvatarGroupProps) {
  const reduce = useReducedMotion() ?? false;
  const canHover = useHoverCapable();
  const [hovered, setHovered] = useState(false);
  const [focused, setFocused] = useState(false);
  const [listOpen, setListOpen] = useState(false);
  const s = SIZES[size];

  const shown = items.slice(0, max);
  const hidden = items.slice(max);
  const expanded = (hovered || focused || listOpen) && !reduce;

  return (
    // Hover/focus only drive the decorative fan-out; every control inside is a
    // real button.
    <fieldset
      className={cn("m-0 inline-flex min-w-0 items-center border-0 p-0", className)}
      onPointerEnter={(e) => {
        if (e.pointerType === "mouse" && canHover) setHovered(true);
      }}
      onPointerLeave={() => setHovered(false)}
      onFocus={() => setFocused(true)}
      onBlur={(e) => {
        if (!e.currentTarget.contains(e.relatedTarget as Node | null)) {
          setFocused(false);
        }
      }}
    >
      <legend className="sr-only">{label}</legend>
      {shown.map((item, i) => (
        <motion.div
          key={item.id}
          className="relative"
          style={{ marginLeft: i === 0 ? 0 : -s.overlap, zIndex: shown.length - i }}
          initial={false}
          animate={{ x: expanded ? i * s.fan : 0 }}
          transition={SPRING_LAYOUT}
        >
          <Tooltip content={item.name} side="top">
            <Avatar
              item={item}
              size={size}
              ringClassName={ringClassName}
              onSelect={onSelect}
              reduce={reduce}
              lift={canHover && !reduce}
            />
          </Tooltip>
        </motion.div>
      ))}
      {hidden.length > 0 ? (
        <motion.div
          className="relative"
          style={{ marginLeft: -s.overlap, zIndex: 0 }}
          initial={false}
          animate={{ x: expanded ? shown.length * s.fan : 0 }}
          transition={SPRING_LAYOUT}
        >
          <MorphPopover open={listOpen} onOpenChange={setListOpen}>
            <MorphPopoverTrigger>
              <button
                type="button"
                aria-label={`Show ${hidden.length} more`}
                className={cn(
                  "grid place-items-center rounded-full bg-muted font-semibold text-foreground ring-2 outline-none transition-colors hover:bg-muted/80 focus-visible:ring-primary",
                  ringClassName,
                  s.text,
                )}
                style={{ width: s.box, height: s.box }}
              >
                +{hidden.length}
              </button>
            </MorphPopoverTrigger>
            <MorphPopoverContent align="start" className="w-56 p-1.5">
              <ul
                aria-label={`All ${items.length} ${label.toLowerCase()}`}
                className="max-h-64 overflow-y-auto [scrollbar-color:var(--border-strong)_transparent] [scrollbar-width:thin]"
              >
                {items.map((item) => {
                  const row = (
                    <>
                      <Avatar
                        item={item}
                        size="sm"
                        ringClassName="ring-background"
                        reduce={reduce}
                        decorative
                      />
                      <span className="min-w-0 flex-1 truncate text-sm text-foreground">
                        {item.name}
                      </span>
                      {item.typing ? (
                        <span className="text-xs text-muted-foreground">
                          typing…
                        </span>
                      ) : item.status ? (
                        <span className="text-xs capitalize text-muted-foreground">
                          {STATUS_LABEL[item.status]}
                        </span>
                      ) : null}
                    </>
                  );
                  return (
                    <li key={item.id}>
                      {onSelect ? (
                        <button
                          type="button"
                          onClick={() => {
                            onSelect(item);
                            setListOpen(false);
                          }}
                          className="flex w-full items-center gap-2.5 rounded-lg px-2 py-1.5 text-left outline-none transition-colors hover:bg-muted focus-visible:bg-muted"
                        >
                          {row}
                        </button>
                      ) : (
                        <div className="flex items-center gap-2.5 rounded-lg px-2 py-1.5">
                          {row}
                        </div>
                      )}
                    </li>
                  );
                })}
              </ul>
            </MorphPopoverContent>
          </MorphPopover>
        </motion.div>
      ) : null}
    </fieldset>
  );
}

// Typing pulse: a slow breathe so it reads as "activity" rather than an alert.
const TYPING_PULSE = {
  duration: 1.4,
  repeat: Number.POSITIVE_INFINITY,
  ease: EASE_OUT,
} as const;

function Avatar({
  item,
  size,
  ringClassName,
  onSelect,
  reduce,
  lift = false,
  decorative = false,
}: {
  item: AvatarGroupItem;
  size: AvatarGroupSize;
  ringClassName: string;
  onSelect?: (item: AvatarGroupItem) => void;
  reduce: boolean;
  lift?: boolean;
  decorative?: boolean;
}) {
  const s = SIZES[size];
  const color = colorFor(item);
  const face = (
    <>
      {item.typing ? (
        reduce ? (
          <span
            aria-hidden
            className="pointer-events-none absolute -inset-1 rounded-full border-2 border-primary/50"
          />
        ) : (
          <motion.span
            aria-hidden
            className="pointer-events-none absolute -inset-1 rounded-full border-2 border-primary"
            initial={{ opacity: 0.7, scale: 0.95 }}
            animate={{ opacity: 0, scale: 1.25 }}
            transition={TYPING_PULSE}
          />
        )
      ) : null}
      <span
        className={cn(
          "relative grid size-full place-items-center overflow-hidden rounded-full font-semibold text-white ring-2",
          ringClassName,
          s.text,
        )}
        style={{ background: item.src ? undefined : color }}
      >
        {item.src ? (
          // biome-ignore lint/performance/noImgElement: library component, no framework image loader assumed.
          <img src={item.src} alt="" className="size-full object-cover" draggable={false} />
        ) : (
          initials(item.name)
        )}
      </span>
      {item.status ? (
        <span
          aria-hidden
          className={cn(
            "absolute bottom-0 right-0 rounded-full ring-2",
            ringClassName,
            STATUS_CLASS[item.status],
          )}
          style={{ width: s.dot, height: s.dot }}
        />
      ) : null}
    </>
  );

  const box = { width: s.box, height: s.box };
  const hover = lift ? { y: -3 } : undefined;

  if (decorative) {
    return (
      <span aria-hidden className="relative inline-block shrink-0" style={box}>
        {face}
      </span>
    );
  }

  if (onSelect) {
    return (
      <motion.button
        type="button"
        aria-label={describe(item)}
        onClick={() => onSelect(item)}
        whileHover={hover}
        transition={SPRING_LAYOUT}
        className="relative block shrink-0 rounded-full outline-none focus-visible:ring-2 focus-visible:ring-primary focus-visible:ring-offset-2 focus-visible:ring-offset-background"
        style={box}
      >
        {face}
      </motion.button>
    );
  }

  return (
    <motion.span
      role="img"
      aria-label={describe(item)}
      whileHover={hover}
      transition={SPRING_LAYOUT}
      className="relative block shrink-0"
      style={box}
    >
      {face}
    </motion.span>
  );
}

/* -------------------------------------------------------------------------- */
/*                                Live cursors                                */
/* -------------------------------------------------------------------------- */

export interface LiveCursor {
  id: string;
  name: string;
  /** Any CSS color. */
  color: string;
  /** Horizontal position, percent of the container width (0–100). */
  x: number;
  /** Vertical position, percent of the container height (0–100). */
  y: number;
}

export interface LiveCursorsProps {
  cursors: LiveCursor[];
  className?: string;
}

/**
 * Collaboration cursors layered over a `relative` container. Positions arrive
 * as container-relative percentages (e.g. from a presence channel) and each
 * cursor springs toward its latest point, smoothing out sparse updates.
 */
export function LiveCursors({ cursors, className }: LiveCursorsProps) {
  const ref = useRef<HTMLDivElement>(null);
  const [size, setSize] = useState({ width: 0, height: 0 });

  useEffect(() => {
    const el = ref.current;
    if (!el) return;
    const observer = new ResizeObserver(([entry]) => {
      const { width, height } = entry.contentRect;
      setSize((prev) =>
        prev.width === width && prev.height === height
          ? prev
          : { width, height },
      );
    });
    observer.observe(el);
    return () => observer.disconnect();
  }, []);

  return (
    <div
      ref={ref}
      aria-hidden
      className={cn("pointer-events-none absolute inset-0 overflow-hidden", className)}
    >
      {size.width > 0
        ? cursors.map((cursor) => (
            <CursorMark
              key={cursor.id}
              cursor={cursor}
              width={size.width}
              height={size.height}
            />
          ))
        : null}
    </div>
  );
}

function CursorMark({
  cursor,
  width,
  height,
}: {
  cursor: LiveCursor;
  width: number;
  height: number;
}) {
  const reduce = useReducedMotion() ?? false;
  const toPx = useCallback(
    (pct: number, extent: number) => (Math.min(Math.max(pct, 0), 100) / 100) * extent,
    [],
  );
  const targetX = useMotionValue(toPx(cursor.x, width));
  const targetY = useMotionValue(toPx(cursor.y, height));
  const springX = useSpring(targetX, SPRING_MOUSE);
  const springY = useSpring(targetY, SPRING_MOUSE);

  useEffect(() => {
    targetX.set(toPx(cursor.x, width));
    targetY.set(toPx(cursor.y, height));
  }, [cursor.x, cursor.y, width, height, targetX, targetY, toPx]);

  return (
    <motion.div
      className="absolute left-0 top-0"
      style={{ x: reduce ? targetX : springX, y: reduce ? targetY : springY }}
    >
      <svg
        aria-hidden="true"
        width="18"
        height="18"
        viewBox="0 0 18 18"
        fill="none"
        className="block drop-shadow-sm"
      >
        <path
          d="M2 1.5 L15.5 8.2 L9.4 9.6 L6.6 15.5 Z"
          fill={cursor.color}
          stroke="white"
          strokeWidth="1.4"
          strokeLinejoin="round"
        />
      </svg>
      <span
        className="ml-3 -mt-0.5 inline-block whitespace-nowrap rounded-full px-2 py-0.5 text-[11px] font-medium text-white shadow-sm"
        style={{ background: cursor.color }}
      >
        {cursor.name}
      </span>
    </motion.div>
  );
}

export type {
  ButtonLinkProps,
  ButtonProps,
  ButtonSize,
  ButtonVariant,
} from "./base";
export { Button, ButtonLink } from "./base";
export type { MagneticButtonProps } from "./magnetic";
export { MagneticButton } from "./magnetic";
export type { ButtonState, StatefulButtonProps } from "./stateful";
export { StatefulButton } from "./stateful";

"use client";

import {
  AnimatePresence,
  animate,
  motion,
  useReducedMotion,
} from "motion/react";
import {
  forwardRef,
  useEffect,
  useId,
  useRef,
  useState,
  type InputHTMLAttributes,
  type ReactNode,
} from "react";
import { cn } from "@/lib/utils";

export type InputClassNames = {
  root?: string;
  label?: string;
  field?: string;
  input?: string;
  leftIcon?: string;
  rightIcon?: string;
  successIcon?: string;
  errorMessage?: string;
};

export interface InputProps extends Omit<
  InputHTMLAttributes<HTMLInputElement>,
  "value" | "defaultValue" | "onChange"
> {
  label?: string;
  value?: string;
  defaultValue?: string;
  onChange?: (value: string) => void;
  /** Truthy error triggers a shake, red border and (if a string) a message. */
  error?: string | boolean;
  success?: boolean;
  leftIcon?: ReactNode;
  rightIcon?: ReactNode;
  className?: string;
  classNames?: InputClassNames;
}

export const Input = forwardRef<HTMLInputElement, InputProps>(function Input(
  {
    label,
    value: valueProp,
    defaultValue,
    onChange,
    onFocus,
    onBlur,
    error,
    success,
    leftIcon,
    rightIcon,
    className,
    classNames,
    disabled,
    id: idProp,
    type,
    ...rest
  },
  ref,
) {
  const reactId = useId();
  const id = idProp ?? reactId;
  const reduce = useReducedMotion();

  const controlled = valueProp !== undefined;
  const [internal, setInternal] = useState(defaultValue ?? "");
  const value = controlled ? (valueProp ?? "") : internal;

  const [focused, setFocused] = useState(false);

  const fieldRef = useRef<HTMLDivElement>(null);

  const hasError = Boolean(error);
  const errorMessage = typeof error === "string" ? error : null;

  // Right edge shows the success check, otherwise the caller's right icon.
  const rightSlot = success ? null : rightIcon;

  // Shake the field when an error appears.
  useEffect(() => {
    if (!fieldRef.current || reduce || !hasError) return;
    animate(
      fieldRef.current,
      { x: [0, -6, 6, -4, 4, -2, 0] },
      { duration: 0.45 },
    );
  }, [hasError, reduce]);

  const handleChange = (next: string) => {
    if (!controlled) setInternal(next);
    onChange?.(next);
  };

  return (
    <div
      className={cn("flex flex-col gap-1.5", className, classNames?.root)}
    >
      {label ? (
        <label
          htmlFor={id}
          className={cn(
            "px-1 text-sm font-medium text-foreground",
            classNames?.label,
          )}
        >
          {label}
        </label>
      ) : null}

      <div
        ref={fieldRef}
        data-state={
          hasError
            ? "error"
            : success
              ? "success"
              : focused
                ? "focused"
                : "idle"
        }
        className={cn(
          "relative h-11 overflow-hidden rounded-full border transition-colors duration-200",
          "border-border",
          focused && !hasError && "border-foreground/40 ring-2 ring-ring/40",
          hasError && "border-destructive ring-2 ring-destructive/25",
          disabled && "opacity-60",
          classNames?.field,
        )}
      >
        {leftIcon ? (
          <span
            className={cn(
              "pointer-events-none absolute left-3 top-1/2 flex -translate-y-1/2 items-center text-muted-foreground [&_svg]:h-4 [&_svg]:w-4",
              classNames?.leftIcon,
            )}
          >
            {leftIcon}
          </span>
        ) : null}

        <input
          ref={ref}
          id={id}
          type={type}
          value={value}
          disabled={disabled}
          aria-invalid={hasError || undefined}
          aria-describedby={errorMessage ? `${id}-error` : undefined}
          {...rest}
          onChange={(e) => handleChange(e.target.value)}
          onFocus={(event) => {
            setFocused(true);
            onFocus?.(event);
          }}
          onBlur={(event) => {
            setFocused(false);
            onBlur?.(event);
          }}
          className={cn(
            "peer h-full w-full bg-transparent text-base leading-6 text-foreground caret-foreground outline-none",
            "placeholder:text-muted-foreground/60",
            leftIcon ? "pl-10" : "pl-3.5",
            rightSlot || success ? "pr-10" : "pr-3.5",
            disabled && "cursor-not-allowed",
            classNames?.input,
          )}
        />

        {success ? (
          <motion.svg
            viewBox="0 0 24 24"
            fill="none"
            className={cn(
              "absolute right-3.5 top-1/2 h-5 w-5 -translate-y-1/2 text-(--color-success)",
              classNames?.successIcon,
            )}
          >
            <motion.path
              d="M5 12.5l4.5 4.5L19 7.5"
              stroke="currentColor"
              strokeWidth={2.5}
              strokeLinecap="round"
              strokeLinejoin="round"
              initial={reduce ? { pathLength: 1 } : { pathLength: 0 }}
              animate={{ pathLength: 1 }}
              transition={{ duration: 0.35, ease: "easeOut" }}
            />
          </motion.svg>
        ) : rightSlot ? (
          <span
            className={cn(
              "absolute right-0 top-0 flex h-full items-center text-muted-foreground [&_button]:grid [&_button]:size-11 [&_button]:place-items-center [&_svg]:h-4 [&_svg]:w-4",
              classNames?.rightIcon,
            )}
          >
            {rightSlot}
          </span>
        ) : null}
      </div>

      <AnimatePresence initial={false}>
        {errorMessage ? (
          <motion.p
            id={`${id}-error`}
            role="alert"
            initial={
              reduce
                ? { opacity: 0 }
                : { opacity: 0, y: -4, filter: "blur(4px)" }
            }
            animate={{ opacity: 1, y: 0, filter: "blur(0px)" }}
            exit={
              reduce
                ? { opacity: 0 }
                : { opacity: 0, y: -4, filter: "blur(4px)" }
            }
            transition={{ duration: 0.2 }}
            className={cn(
              "px-1 text-xs text-destructive",
              classNames?.errorMessage,
            )}
          >
            {errorMessage}
          </motion.p>
        ) : null}
      </AnimatePresence>
    </div>
  );
});

"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,
  );
}