{"$schema":"https://ui.shadcn.com/schema/registry-item.json","name":"hold-to-confirm","type":"registry:component","title":"Hold to confirm","description":"A deliberate action, held for a moment: the ring fills, the label changes, and confirmation settles into a check.","author":"Hairline UI","dependencies":["lucide-react"],"registryDependencies":["https://hairlineui.com/r/text-morph.json?as=dependency"],"files":[{"path":"registry/hold-to-confirm.tsx","type":"registry:component","content":"// Hairline UI · hold-to-confirm · MIT License\n// Copyright (c) 2026 Hairline UI · https://hairlineui.com/license#components\n\n'use client';\n\nimport * as React from 'react';\nimport { CircleAlert, Fingerprint } from 'lucide-react';\nimport { TextMorph } from './text-morph';\nimport { INTERACTION_FOCUS, interactionIcon, useInteractionReducedMotion } from './ui-interaction-motion';\nimport { useHoldConfirm, type HoldStatus } from './use-hold-confirm';\nexport type { HoldStatus } from './use-hold-confirm';\n\nexport interface HoldToConfirmProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onClick' | 'children'> {\n  onConfirm: () => void | Promise<void>;\n  duration?: number;\n  resetAfter?: number;\n  labels?: Partial<Record<HoldStatus, string>>;\n  icon?: React.ReactNode;\n  /** Every change of state: holding, pending, success, error, back to idle. */\n  onStatusChange?: (status: HoldStatus) => void;\n}\nconst LABELS = { idle: 'Hold to confirm', holding: 'Keep holding', pending: 'Confirming', success: 'Confirmed', error: 'Hold to retry' };\n\n/** Press and keep holding. The threshold owns the action; a click never submits it. */\nexport function HoldToConfirm({ onConfirm, duration = 1100, resetAfter = 2200, labels, icon, onStatusChange, disabled = false, className = '', ...props }: HoldToConfirmProps) {\n  const reduced = useInteractionReducedMotion();\n  const delay = Number.isFinite(duration) ? Math.max(300, Math.min(5000, duration)) : 1100;\n  const { status, progress, begin, cancel } = useHoldConfirm(onConfirm, delay, resetAfter, disabled, reduced);\n  const report = React.useRef(onStatusChange);\n  React.useLayoutEffect(() => {\n    report.current = onStatusChange;\n  });\n  React.useEffect(() => {\n    report.current?.(status);\n  }, [status]);\n  const text = { ...LABELS, ...labels }[status];\n  const hint = React.useId();\n  const pending = status === 'pending', succeeded = status === 'success';\n  return <>\n    <button {...props} type=\"button\" disabled={disabled} aria-describedby={hint} aria-busy={pending || undefined} aria-disabled={pending || succeeded || disabled || undefined}\n      onPointerDown={(event) => {\n        if (event.button !== 0 || !event.isPrimary) return;\n        event.currentTarget.setPointerCapture(event.pointerId); event.currentTarget.focus({ preventScroll: true }); begin(`pointer:${event.pointerId}`);\n      }}\n      onPointerMove={(event) => {\n        if (!event.currentTarget.hasPointerCapture(event.pointerId)) return;\n        const rect = event.currentTarget.getBoundingClientRect();\n        if (event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom) cancel(`pointer:${event.pointerId}`);\n      }}\n      onPointerUp={(event) => cancel(`pointer:${event.pointerId}`)} onPointerCancel={(event) => cancel(`pointer:${event.pointerId}`)} onLostPointerCapture={(event) => cancel(`pointer:${event.pointerId}`)} onPointerLeave={(event) => cancel(`pointer:${event.pointerId}`)} onBlur={() => cancel()}\n      onKeyDown={(event) => {\n        if (event.key === 'Escape') { event.preventDefault(); cancel(); }\n        if (event.key === ' ' || event.key === 'Enter') { event.preventDefault(); if (!event.repeat) begin(`key:${event.key}`); }\n      }} onKeyUp={(event) => { if (event.key === ' ' || event.key === 'Enter') { event.preventDefault(); cancel(`key:${event.key}`); } }}\n      onClick={(event) => event.preventDefault()}\n      className={`cursor-pointer disabled:cursor-default aria-disabled:cursor-default relative inline-flex h-11 select-none items-center justify-center gap-2.5 overflow-clip rounded-full border px-4 text-[13px] font-medium transition-colors disabled:opacity-40 ${status === 'error' ? 'border-destructive/40 bg-destructive/5 text-destructive' : 'border-primary bg-primary text-primary-foreground hover:bg-primary/90'} ${INTERACTION_FOCUS} ${className}`}\n      style={{ touchAction: 'none', ...props.style }}>\n      <span aria-hidden=\"true\" className=\"relative size-5 shrink-0\">\n        <span className=\"absolute inset-0 flex items-center justify-center [&>svg]:size-4\" style={interactionIcon(status === 'idle' || status === 'holding', reduced)}>{icon ?? <Fingerprint />}</span>\n        <svg viewBox=\"0 0 24 24\" className=\"absolute -inset-1 size-7 -rotate-90\" style={{ opacity: status === 'holding' ? 1 : 0, transition: reduced ? 'none' : 'opacity 180ms ease-out' }}>\n          <circle cx=\"12\" cy=\"12\" r=\"10.5\" fill=\"none\" stroke=\"currentColor\" strokeOpacity=\"0.2\" strokeWidth=\"1\" />\n          <circle ref={progress} cx=\"12\" cy=\"12\" r=\"10.5\" pathLength=\"1\" fill=\"none\" stroke=\"currentColor\" strokeWidth=\"1.5\" strokeLinecap=\"round\" strokeDasharray=\"1\" strokeDashoffset=\"1\" />\n        </svg>\n        <span className=\"absolute inset-0 flex items-center justify-center\" style={interactionIcon(pending, reduced)}><span className={`size-4 rounded-full border-[1.5px] border-current/30 border-t-current ${pending && !reduced ? 'animate-spin' : ''}`} /></span>\n        <svg viewBox=\"0 0 20 20\" className=\"absolute inset-0 size-5\" style={interactionIcon(succeeded, reduced)}><path d=\"m4 10 4 4 8-8\" fill=\"none\" stroke=\"currentColor\" strokeWidth=\"1.6\" strokeLinecap=\"round\" strokeLinejoin=\"round\" pathLength=\"1\" style={{ strokeDasharray: 1, strokeDashoffset: succeeded ? 0 : 1, transition: reduced ? 'none' : 'stroke-dashoffset 380ms ease-out 80ms' }} /></svg>\n        <CircleAlert className=\"absolute inset-0 size-5\" style={interactionIcon(status === 'error', reduced)} />\n      </span>\n      <TextMorph>{text}</TextMorph>\n    </button>\n    <span id={hint} className=\"sr-only\">Hold the pointer, Space or Enter for {delay / 1000} seconds. Release early or press Escape to cancel.</span>\n    <span role=\"status\" className=\"sr-only\">{status === 'idle' ? '' : text}</span>\n  </>;\n}\n"},{"path":"registry/use-hold-confirm.ts","type":"registry:component","content":"// Hairline UI · hold-to-confirm · MIT License\n// Copyright (c) 2026 Hairline UI · https://hairlineui.com/license#components\n\n'use client';\n\nimport * as React from 'react';\nimport { EASE_OUT } from './ui-interaction-motion';\n\nexport type HoldStatus = 'idle' | 'holding' | 'pending' | 'success' | 'error';\n\nexport function useHoldConfirm(onConfirm: () => void | Promise<void>, duration: number, resetAfter: number, disabled: boolean, reduced: boolean) {\n  const [status, setStatus] = React.useState<HoldStatus>('idle');\n  const phase = React.useRef<HoldStatus>('idle');\n  const progress = React.useRef<SVGCircleElement>(null);\n  const animation = React.useRef<Animation | null>(null);\n  const timer = React.useRef<ReturnType<typeof setTimeout> | null>(null);\n  const resetTimer = React.useRef<ReturnType<typeof setTimeout> | null>(null);\n  const held = React.useRef(false);\n  const owner = React.useRef<string | null>(null);\n  const alive = React.useRef(false);\n  const action = React.useRef(onConfirm);\n  React.useLayoutEffect(() => {\n    action.current = onConfirm;\n  });\n  const setPhase = (next: HoldStatus) => { phase.current = next; setStatus(next); };\n  const cancel = (source?: string) => {\n    if (!held.current || (source && source !== owner.current)) return;\n    held.current = false;\n    if (timer.current) clearTimeout(timer.current);\n    const path = progress.current;\n    const from = path ? getComputedStyle(path).strokeDashoffset : '1';\n    animation.current?.cancel();\n    if (path && !reduced) animation.current = path.animate([{ strokeDashoffset: from }, { strokeDashoffset: '1' }], { duration: 240, easing: EASE_OUT });\n    setPhase('idle');\n  };\n  const begin = (source: string) => {\n    if (disabled || held.current || !['idle', 'error'].includes(phase.current)) return;\n    if (resetTimer.current) clearTimeout(resetTimer.current);\n    held.current = true; owner.current = source; setPhase('holding'); animation.current?.cancel();\n    if (progress.current) animation.current = progress.current.animate([{ strokeDashoffset: '1' }, { strokeDashoffset: '0' }], { duration, easing: 'linear', fill: 'forwards' });\n    timer.current = setTimeout(async () => {\n      if (!held.current || !alive.current) return;\n      held.current = false; setPhase('pending');\n      try { await action.current(); if (alive.current) setPhase('success'); }\n      catch { if (alive.current) setPhase('error'); }\n      finally {\n        animation.current?.cancel();\n        if (alive.current && resetAfter > 0) resetTimer.current = setTimeout(() => setPhase('idle'), resetAfter);\n      }\n    }, duration);\n  };\n  const cancelRef = React.useRef(cancel);\n  React.useLayoutEffect(() => {\n    cancelRef.current = cancel;\n  });\n  React.useEffect(() => {\n    alive.current = true;\n    const hidden = () => { if (document.hidden) cancelRef.current(); };\n    const blur = () => cancelRef.current();\n    window.addEventListener('blur', blur); document.addEventListener('visibilitychange', hidden);\n    return () => {\n      alive.current = false; held.current = false;\n      if (timer.current) clearTimeout(timer.current);\n      if (resetTimer.current) clearTimeout(resetTimer.current);\n      animation.current?.cancel();\n      window.removeEventListener('blur', blur); document.removeEventListener('visibilitychange', hidden);\n    };\n  }, []);\n  React.useEffect(() => { cancelRef.current(); }, [reduced]);\n  React.useEffect(() => { if (disabled) cancelRef.current(); }, [disabled]);\n  return { status, progress, begin, cancel };\n}\n"},{"path":"registry/ui-interaction-motion.ts","type":"registry:component","content":"// Hairline UI · hold-to-confirm · MIT License\n// Copyright (c) 2026 Hairline UI · https://hairlineui.com/license#components\n\n'use client';\n\nimport * as React from 'react';\n\nexport const EASE_OUT = 'cubic-bezier(0.16, 1, 0.3, 1)';\nexport const EASE_SETTLE = 'cubic-bezier(0.22, 1.18, 0.36, 1)';\n/** Thrown things (indicators, thumbs): a slight overshoot on transform only. */\nexport const EASE_THROW = 'cubic-bezier(0.34, 1.36, 0.64, 1)';\n/**\n * The press every button primitive shares: a 3% give that eases in and settles back.\n * Tailwind v4's scale-* writes the `scale` property, so `scale` has to be in the list\n * or the press snaps.\n */\nexport const INTERACTION_PRESS =\n  'transition-[background-color,color,box-shadow,opacity,scale] duration-200 ease-[cubic-bezier(0.16,1,0.3,1)] active:scale-[0.97] motion-reduce:transition-none motion-reduce:active:scale-100';\nexport const INTERACTION_FOCUS ='focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50 focus-visible:ring-offset-2 focus-visible:ring-offset-background';\n\nconst query = '(prefers-reduced-motion: reduce)';\nconst subscribe = (notify: () => void) => {\n  const media = window.matchMedia(query);\n  media.addEventListener('change', notify);\n  return () => media.removeEventListener('change', notify);\n};\nexport const useInteractionReducedMotion = () => React.useSyncExternalStore(subscribe, () => window.matchMedia(query).matches, () => false);\n\nexport function useInteractionActivity<T extends Element>() {\n  const ref = React.useRef<T>(null);\n  const [visible, setVisible] = React.useState(false);\n  const [hidden, setHidden] = React.useState(false);\n  React.useEffect(() => {\n    const el = ref.current;\n    if (!el) return;\n    const observer = new IntersectionObserver(([entry]) => setVisible(entry.isIntersecting));\n    observer.observe(el);\n    const visibility = () => setHidden(document.hidden);\n    visibility(); document.addEventListener('visibilitychange', visibility);\n    return () => { observer.disconnect(); document.removeEventListener('visibilitychange', visibility); };\n  }, []);\n  return { ref, active: visible && !hidden };\n}\n\nexport function interactionIcon(on: boolean, reduced: boolean): React.CSSProperties {\n  return { opacity: on ? 1 : 0, transform: on ? 'none' : 'scale(0.6)', filter: on ? 'blur(0px)' : 'blur(3px)', transition: reduced ? 'none' : `opacity 220ms ${EASE_OUT}, transform 380ms ${EASE_OUT}, filter 220ms ${EASE_OUT}` };\n}\n\n/** A raised object: one tight contact shadow, one short ambient, a hairline of light on its top edge. */\nexport const MATERIAL_LIFT =\n  'shadow-[0_1px_1.5px_rgb(0_0_0/0.07),0_3px_8px_-2px_rgb(0_0_0/0.1),inset_0_0.5px_0_rgb(255_255_255/0.8)] dark:shadow-[0_1px_2px_rgb(0_0_0/0.5),0_4px_10px_-2px_rgb(0_0_0/0.35),inset_0_0.5px_0_rgb(255_255_255/0.1)]';\n/** A trough something sits in, shaded from above, lit along its bottom edge. */\nexport const MATERIAL_RECESS =\n  'shadow-[inset_0_1px_2.5px_rgb(0_0_0/0.09),inset_0_-0.5px_0_rgb(255_255_255/0.7)] dark:shadow-[inset_0_1px_3px_rgb(0_0_0/0.45),inset_0_-0.5px_0_rgb(255_255_255/0.07)]';\n\nexport type SpringConfig = { stiffness: number; damping: number; mass?: number };\nexport interface Spring {\n  get(): number;\n  getVelocity(): number;\n  getTarget(): number;\n  /** Aim somewhere new from wherever it is now, keeping its speed. */\n  set(target: number): void;\n  /** Add speed (units per second), on top of what it already has. */\n  push(velocity: number): void;\n  /** Be there now, at rest. */\n  jump(value: number): void;\n  configure(config: SpringConfig): void;\n  stop(): void;\n}\n\n// Every moving spring on the page shares one frame loop, which sleeps when the last one rests. Each spring's onFrame runs\n// once per frame after all of them have stepped, so several springs that draw one shape paint it once.\nconst SPRING_STEP = 1 / 240;\ntype Running = { step: () => void };\nconst runningSprings = new Set<Running>();\nconst springPainters = new Set<() => void>();\nlet springFrame = 0;\nlet springLast = 0;\nlet springSpare = 0;\n\nfunction springTick(now: number) {\n  // A hidden tab stops the frames, so the first one back must not count the whole gap as time passed.\n  springSpare += Math.min((now - springLast) / 1000, 0.05);\n  springLast = now;\n  while (springSpare >= SPRING_STEP) {\n    runningSprings.forEach((spring) => spring.step());\n    springSpare -= SPRING_STEP;\n  }\n  const painters = [...springPainters];\n  springPainters.clear();\n  painters.forEach((paint) => paint());\n  springFrame = runningSprings.size ? requestAnimationFrame(springTick) : 0;\n}\n\nfunction wakeSprings(spring: Running) {\n  runningSprings.add(spring);\n  if (springFrame) return;\n  springSpare = 0;\n  springFrame = requestAnimationFrame((now) => {\n    springLast = now - 1000 / 60;\n    springTick(now);\n  });\n}\n\n/**\n * A spring that carries its speed: re-aim it mid-flight and it curves on from where it is, push it while it swings and the\n * push adds to the swing. Use it for anything that can be interrupted; a curve restarts from a standstill every time.\n * `onFrame` should write straight to the DOM. `precision` is how close counts as there, in the value's own units.\n */\nexport function createSpring(initial: number, config: SpringConfig, onFrame: () => void, precision = 0.01): Spring {\n  let value = initial;\n  let velocity = 0;\n  let target = initial;\n  let { stiffness, damping, mass = 1 } = config;\n  const running: Running = {\n    step() {\n      velocity += ((-stiffness * (value - target) - damping * velocity) / mass) * SPRING_STEP;\n      value += velocity * SPRING_STEP;\n      if (Math.abs(value - target) < precision && Math.abs(velocity) < precision * 10) {\n        value = target;\n        velocity = 0;\n        runningSprings.delete(running);\n      }\n      springPainters.add(onFrame);\n    },\n  };\n  return {\n    get: () => value,\n    getVelocity: () => velocity,\n    getTarget: () => target,\n    set(next) {\n      if (next === target && !runningSprings.has(running)) return;\n      target = next;\n      wakeSprings(running);\n    },\n    push(speed) {\n      velocity += speed;\n      wakeSprings(running);\n    },\n    jump(next) {\n      value = next;\n      target = next;\n      velocity = 0;\n      runningSprings.delete(running);\n      onFrame();\n    },\n    configure(next) {\n      ({ stiffness, damping, mass = 1 } = next);\n    },\n    stop() {\n      runningSprings.delete(running);\n    },\n  };\n}\n\n/** Sample recent movement rather than averaging a long drag and losing its release velocity. */\nexport type PointerSample = { x: number; time: number };\nexport function samplePointer(samples: PointerSample[], x: number, time: number) {\n  samples.push({ x, time });\n  while (samples.length > 2 && time - samples[0].time > 100) samples.shift();\n}\nexport function releaseVelocity(samples: PointerSample[], now: number) {\n  if (samples.length < 2 || now - samples[samples.length - 1].time > 100) return 0;\n  const first = samples[0], last = samples[samples.length - 1];\n  return (last.x - first.x) / Math.max(1, last.time - first.time);\n}\n\n/** Smooth Apple/rational rubber-band curve: continuous exponential-like resistance without linear kinks. */\nexport function rubberBand(overshoot: number, dimension = 320, constant = 0.55): number {\n  const d = dimension || 320;\n  const abs = Math.abs(overshoot);\n  return Math.sign(overshoot) * (1 - 1 / ((abs * constant) / d + 1)) * d;\n}\n\n/** Projects resting travel from release velocity (velocity in px/ms; time in seconds). */\nexport function projectInertia(distance: number, velocity: number, time = 0.12): number {\n  return distance + velocity * 1000 * time;\n}\n\n/** Smooths incoming release velocity toward a boundary so springs don't slam or clip into walls. */\nexport function softenVelocity(velocity: number, distanceToTarget: number, factor = 10): number {\n  const maxAllowed = Math.abs(distanceToTarget) * factor;\n  return Math.sign(velocity) * Math.min(Math.abs(velocity), maxAllowed);\n}\n\n/** A damped spring sampled by WAAPI: tuned for organic lightness with a hint of life (3% breath). */\nexport function springFrames(\n  from: number,\n  to: number,\n  velocity = 0,\n  duration = 480,\n  config: { omega?: number; damping?: number; steps?: number } = {},\n) {\n  const { omega = 16, damping = 0.74, steps = 36 } = config;\n  const damped = omega * Math.sqrt(Math.max(0.001, 1 - damping * damping));\n  const displacement = from - to;\n  const coefficient = (velocity * 1000 + damping * omega * displacement) / damped;\n  return Array.from({ length: steps + 1 }, (_, i) => {\n    const t = (i / steps) * (duration / 1000);\n    const value = to + Math.exp(-damping * omega * t) * (displacement * Math.cos(damped * t) + coefficient * Math.sin(damped * t));\n    return { value: i === steps ? to : value, offset: i / steps };\n  });\n}\n\n"}],"css":{},"docs":"Docs and live preview: https://hairlineui.com/ui/hold-to-confirm. MIT licensed: https://hairlineui.com/license#components","meta":{"license":"MIT"}}