62:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 63:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 64:Tab6e,"use client"; // beui.dev/components/motion/color-picker import { Pipette } from "lucide-react"; import { AnimatePresence, arc, LayoutGroup, type MotionValue, motion, type Transition, useAnimate, useReducedMotion, useSpring, useTransform, useVelocity, } from "motion/react"; import { Children, type ComponentPropsWithRef, createContext, isValidElement, type KeyboardEvent, type PointerEvent, type ReactNode, type RefObject, useContext, useEffect, useId, useLayoutEffect, useRef, useState, } from "react"; import { EASE_OUT, SPRING_GLIDE, SPRING_LAYOUT, SPRING_PRESS } from "@/lib/ease"; import { useDismiss } from "@/lib/hooks/use-dismiss"; import { PresenceGate } from "@/lib/presence-gate"; import { capturePointer, releasePointer, TOUCH_GESTURE_CLASS } from "@/lib/touch"; import { cn } from "@/lib/utils"; // --------------------------------------------------------------------------- // Color math // --------------------------------------------------------------------------- /** Hue 0-360, saturation and value 0-100, alpha 0-1. */ export type Hsva = { h: number; s: number; v: number; a: number }; /** Channels 0-255, alpha 0-1. */ export type Rgba = { r: number; g: number; b: number; a: number }; const clamp = (n: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, n)); const round = (n: number, places = 0) => { const f = 10 ** places; return Math.round(n * f) / f; }; export function hsvaToRgba({ h, s, v, a }: Hsva): Rgba { const sat = s / 100; const val = v / 100; const f = (n: number) => { const k = (n + h / 60) % 6; return val - val * sat * Math.max(0, Math.min(k, 4 - k, 1)); }; return { r: Math.round(f(5) * 255), g: Math.round(f(3) * 255), b: Math.round(f(1) * 255), a }; } /** `previous` keeps hue for greys and saturation for black, which RGB cannot carry. */ export function rgbaToHsva({ r, g, b, a }: Rgba, previous?: Hsva): Hsva { const rn = r / 255; const gn = g / 255; const bn = b / 255; const max = Math.max(rn, gn, bn); const d = max - Math.min(rn, gn, bn); let h = previous?.h ?? 0; if (d) { if (max === rn) h = ((gn - bn) / d) % 6; else if (max === gn) h = (bn - rn) / d + 2; else h = (rn - gn) / d + 4; h = (h * 60 + 360) % 360; } const v = max * 100; const s = max ? (d / max) * 100 : (previous?.s ?? 0); return { h, s, v, a }; } const HEX_PATTERN = /^#?([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i; /** Parses #rgb, #rgba, #rrggbb and #rrggbbaa. Returns null for anything else. */ export function parseHex(input: string): Rgba | null { const match = HEX_PATTERN.exec(input.trim()); if (!match) return null; let hex = match[1]; if (hex.length <= 4) hex = [...hex].map((c) => c + c).join(""); const n = (i: number) => Number.parseInt(hex.slice(i, i + 2), 16); return { r: n(0), g: n(2), b: n(4), a: hex.length === 8 ? round(n(6) / 255, 2) : 1 }; } /** Lowercase #rrggbb, or #rrggbbaa when the color is translucent. */ export function formatHex({ r, g, b, a }: Rgba): string { const pair = (n: number) => Math.round(n).toString(16).padStart(2, "0"); return `#${pair(r)}${pair(g)}${pair(b)}${a < 1 ? pair(a * 255) : ""}`; } function hsvToHsl({ h, s, v }: Hsva) { const sv = s / 100; const vv = v / 100; const l = vv * (1 - sv / 2); const sl = l === 0 || l === 1 ? 0 : (vv - l) / Math.min(l, 1 - l); return { h, s: sl * 100, l: l * 100 }; } function hslToHsv(h: number, s: number, l: number, previous: Hsva, a: number): Hsva { const sl = s / 100; const ll = l / 100; const v = ll + sl * Math.min(ll, 1 - ll); return { h, s: v ? 2 * (1 - ll / v) * 100 : previous.s, v: v * 100, a }; } const BLACK: Rgba = { r: 0, g: 0, b: 0, a: 1 }; // --------------------------------------------------------------------------- // Root // --------------------------------------------------------------------------- type ColorPickerContextValue = { id: string; hsva: Hsva; rgba: Rgba; hex: string; alpha: boolean; disabled: boolean; update: (next: Hsva) => void; commit: () => void; open: boolean; setOpen: (open: boolean) => void; triggerRef: RefObject; }; const ColorPickerContext = createContext(null); function usePickerContext(component: string) { const context = useContext(ColorPickerContext); if (!context) throw new Error(`${component} must be used within ColorPicker`); return context; } /** Current color and a setter, for custom parts inside a ColorPicker. */ export function useColorPicker() { const { hex, rgba, hsva, alpha, disabled, update, commit } = usePickerContext("useColorPicker"); return { hex, rgba, hsva, alpha, disabled, /** Accepts any hex form. Invalid input is ignored. */ setColor: (value: string) => { const parsed = parseHex(value); if (!parsed) return; update(rgbaToHsva(parsed, hsva)); commit(); }, }; } export interface ColorPickerProps extends Omit, "onChange" | "defaultValue"> { /** Controlled hex color (#rgb, #rrggbb or #rrggbbaa). */ value?: string; defaultValue?: string; /** Fires on every change while dragging or typing, with a lowercase hex. */ onValueChange?: (value: string) => void; /** Fires once an interaction settles: pointer release, key, preset or field commit. */ onValueCommit?: (value: string) => void; /** Allow transparency. When false the value is always opaque. Default true. */ alpha?: boolean; /** Submits the hex value with a form under this name. */ name?: string; /** Controlled open state for ColorPickerTrigger + ColorPickerContent. */ open?: boolean; defaultOpen?: boolean; onOpenChange?: (open: boolean) => void; } /** Give it an aria-label, or a legend through children. */ export function ColorPicker({ value, defaultValue = "#3478f6", onValueChange, onValueCommit, alpha = true, disabled = false, name, open: openProp, defaultOpen = false, onOpenChange, form, className, children, ...props }: ColorPickerProps) { const id = useId(); const triggerRef = useRef(null); const [openInternal, setOpenInternal] = useState(defaultOpen); const open = openProp ?? openInternal; const setOpen = (next: boolean) => { if (next === open) return; if (openProp === undefined) setOpenInternal(next); onOpenChange?.(next); }; const controlled = value !== undefined; const incoming = controlled ? value : defaultValue; const [state, setState] = useState(() => ({ source: incoming, hsva: rgbaToHsva(parseHex(incoming) ?? BLACK), })); // A controlled value the picker did not emit itself is re-read here, during // render, so the thumbs never paint a stale color for a frame. let hsva = state.hsva; if (controlled && value !== state.source) { const parsed = parseHex(value); hsva = parsed ? rgbaToHsva(parsed, state.hsva) : state.hsva; setState({ source: value, hsva }); } if (!alpha && hsva.a !== 1) hsva = { ...hsva, a: 1 }; const rgba = hsvaToRgba(hsva); const hex = formatHex(rgba); // Event handlers read the latest emitted hex, which may be ahead of render. const hexRef = useRef(hex); useLayoutEffect(() => { hexRef.current = hex; }, [hex]); const update = (next: Hsva) => { const clean: Hsva = { h: clamp(next.h, 0, 360), s: clamp(next.s, 0, 100), v: clamp(next.v, 0, 100), a: alpha ? clamp(next.a, 0, 1) : 1, }; const nextHex = formatHex(hsvaToRgba(clean)); const changed = nextHex !== hexRef.current; hexRef.current = nextHex; setState({ source: nextHex, hsva: clean }); if (changed) onValueChange?.(nextHex); }; return ( onValueCommit?.(hexRef.current), open, setOpen, triggerRef, }} >

[data-color-picker-trigger]]:w-fit has-[>[data-color-picker-trigger]]:self-start", disabled && "opacity-50", className, )} > {children} {name && }

); } // --------------------------------------------------------------------------- // Pointer + spring plumbing shared by the area and the sliders // --------------------------------------------------------------------------- function useGlide(target: number) { const reduce = useReducedMotion(); const spring = useSpring(target, SPRING_GLIDE); useEffect(() => { if (reduce) spring.jump(target); else spring.set(target); }, [reduce, spring, target]); return { spring, offset: useTransform(spring, (n) => `${n}%`) }; } function useDrag( onPoint: (x: number, y: number) => void, onEnd: () => void, disabled: boolean, ) { const railRef = useRef(null); const thumbRef = useRef(null); const draggingRef = useRef(false); const [dragging, setDragging] = useState(false); const point = (event: PointerEvent) => { const rect = railRef.current?.getBoundingClientRect(); if (!rect || rect.width === 0 || rect.height === 0) return; onPoint( clamp((event.clientX - rect.left) / rect.width, 0, 1), clamp((event.clientY - rect.top) / rect.height, 0, 1), ); }; const end = (event: PointerEvent) => { if (!draggingRef.current) return; releasePointer(event.currentTarget, event.pointerId); draggingRef.current = false; setDragging(false); onEnd(); }; return { railRef, thumbRef, dragging, handlers: { onPointerDown: (event: PointerEvent) => { if (disabled || event.button !== 0) return; draggingRef.current = true; setDragging(true); capturePointer(event.currentTarget, event.pointerId); thumbRef.current?.focus({ preventScroll: true }); point(event); }, onPointerMove: (event: PointerEvent) => { if (draggingRef.current) point(event); }, onPointerUp: end, onPointerCancel: end, }, }; } /** Arrow, Page and Home/End stepping. Returns the delta, or null when unhandled. */ function keyStep(event: KeyboardEvent, big: number): { axis: "x" | "y"; delta: number } | "min" | "max" | null { const step = event.shiftKey ? big : 1; switch (event.key) { case "ArrowRight": return { axis: "x", delta: step }; case "ArrowLeft": return { axis: "x", delta: -step }; case "ArrowUp": return { axis: "y", delta: step }; case "ArrowDown": return { axis: "y", delta: -step }; case "PageUp": return { axis: "y", delta: big }; case "PageDown": return { axis: "y", delta: -big }; case "Home": return "min"; case "End": return "max"; default: return null; } } const CHECKERBOARD = "repeating-conic-gradient(#d4d4d8 0% 25%, #fafafa 0% 50%) 0 0 / 8px 8px"; // The loupe lifts with a visible overshoot so it reads as picked up, unlike // the critically damped glide the thumb itself rides on. const LOUPE_LIFT: Transition = { type: "spring", stiffness: 520, damping: 24, mass: 0.6 }; const LOUPE_DROP: Transition = { duration: 0.12, ease: EASE_OUT }; // Glide velocity in %/s mapped to a pendulum swing, so the loupe trails the drag. const LOUPE_TILT_INPUT = [-400, 400]; const LOUPE_TILT_DEGREES = [16, -16]; function Thumb({ thumbRef, dragging, color, glide, x, y, className, ...props }: ComponentPropsWithRef<"div"> & { thumbRef: RefObject; dragging: boolean; color: string; /** Horizontal glide spring, read for the loupe's tilt. */ glide: MotionValue; x: MotionValue; y?: MotionValue; }) { const reduce = useReducedMotion(); const velocity = useVelocity(glide); const tilt = useSpring( useTransform(velocity, LOUPE_TILT_INPUT, LOUPE_TILT_DEGREES, { clamp: true }), SPRING_PRESS, ); const lifted = dragging && !reduce; return (

); } // --------------------------------------------------------------------------- // Saturation / brightness area // --------------------------------------------------------------------------- export interface ColorPickerAreaProps extends Omit, "children"> { /** Accessible name for the 2D thumb. Default "Saturation and brightness". */ label?: string; } // One surface: the trigger chip grows into the area and shrinks back into it. const MORPH: Transition = { type: "spring", duration: 0.5, bounce: 0.2 }; const AREA_RADIUS = 12; const CHIP_RADIUS = 6; /** True inside ColorPickerContent, where the area morphs out of the trigger chip. */ const MorphContext = createContext(false); export function ColorPickerArea({ label = "Saturation and brightness", className, style, ...props }: ColorPickerAreaProps) { const { id, hsva, rgba, hex, disabled, update, commit, open } = usePickerContext("ColorPickerArea"); const morph = useContext(MorphContext); const reduce = useReducedMotion(); const { railRef, thumbRef, dragging, handlers } = useDrag( (x, y) => update({ ...hsva, s: x * 100, v: (1 - y) * 100 }), commit, disabled, ); const x = useGlide(hsva.s); const y = useGlide(100 - hsva.v); const s = Math.round(hsva.s); const v = Math.round(hsva.v); const morphing = morph && !reduce; const rgb = `rgb(${rgba.r} ${rgba.g} ${rgba.b})`; return ( )} {...handlers} ref={railRef} layoutId={morphing ? `${id}-chip` : undefined} // Measure only when open flips: every drag frame would otherwise force a // layout read, and the close render must snapshot so the chip can morph // back from here and the exit can finish. layoutDependency={open} transition={MORPH} className={cn( "relative h-40 w-full touch-none", TOUCH_GESTURE_CLASS, disabled ? "cursor-not-allowed" : "cursor-crosshair", className, )} style={{ ...style, borderRadius: AREA_RADIUS, background: `linear-gradient(to top, #000, transparent), linear-gradient(to right, #fff, hsl(${hsva.h} 100% 50%))`, }} > {/* Arriving from the chip, the solid color dissolves to reveal the spectrum behind it. */} {morphing && ( )}

{ if (disabled) return; const step = keyStep(event, 10); if (!step) return; event.preventDefault(); if (step === "min") update({ ...hsva, s: 0 }); else if (step === "max") update({ ...hsva, s: 100 }); else if (step.axis === "x") update({ ...hsva, s: hsva.s + step.delta }); else update({ ...hsva, v: hsva.v + step.delta }); commit(); }} /> ); } // --------------------------------------------------------------------------- // Hue and alpha sliders // --------------------------------------------------------------------------- function ChannelSlider({ value, max, onValue, label, valueText, background, thumbColor, className, ...props }: Omit, "children"> & { value: number; max: number; onValue: (next: number) => void; label: string; valueText: string; background: string; thumbColor: string; }) { const { disabled, commit } = usePickerContext("ColorPicker slider"); const { railRef, thumbRef, dragging, handlers } = useDrag((x) => onValue(x * max), commit, disabled); const x = useGlide((value / max) * 100); return (

{/* The rail is inset by half a thumb so the thumb never leaves the rounded track. */}

{ if (disabled) return; const step = keyStep(event, 10); if (!step) return; event.preventDefault(); if (step === "min") onValue(0); else if (step === "max") onValue(max); else onValue(Math.round(value) + step.delta); commit(); }} />

); } export interface ColorPickerHueProps extends Omit, "children"> { label?: string; } export function ColorPickerHue({ label = "Hue", ...props }: ColorPickerHueProps) { const { hsva, update } = usePickerContext("ColorPickerHue"); const h = Math.round(hsva.h); return ( update({ ...hsva, h: next })} label={label} valueText={`${h} degrees`} background="linear-gradient(to right, #f00 0%, #ff0 17%, #0f0 33%, #0ff 50%, #00f 67%, #f0f 83%, #f00 100%)" thumbColor={`hsl(${hsva.h} 100% 50%)`} /> ); } export interface ColorPickerAlphaProps extends Omit, "children"> { label?: string; } /** Renders nothing when the picker has `alpha={false}`. */ export function ColorPickerAlpha({ label = "Opacity", ...props }: ColorPickerAlphaProps) { const { hsva, rgba, alpha, update } = usePickerContext("ColorPickerAlpha"); if (!alpha) return null; const rgb = `${rgba.r} ${rgba.g} ${rgba.b}`; const percent = Math.round(hsva.a * 100); return ( update({ ...hsva, a: Math.round(next) / 100 })} label={label} valueText={`${percent}%`} background={`linear-gradient(to right, rgb(${rgb} / 0), rgb(${rgb})), ${CHECKERBOARD}`} thumbColor={`rgb(${rgb} / ${hsva.a})`} /> ); } // --------------------------------------------------------------------------- // Swatch // --------------------------------------------------------------------------- export type ColorPickerSwatchProps = Omit, "children">; /** The current color over a transparency checkerboard. Decorative. */ export function ColorPickerSwatch({ className, style, ...props }: ColorPickerSwatchProps) { const { hex } = usePickerContext("ColorPickerSwatch"); return ( ); } // --------------------------------------------------------------------------- // Text fields // --------------------------------------------------------------------------- const FIELD_CLASS = "h-9 w-full min-w-0 rounded-lg border border-border bg-background text-sm text-foreground tabular-nums outline-none transition-colors focus-visible:border-foreground/40 focus-visible:ring-2 focus-visible:ring-ring/30 disabled:cursor-not-allowed"; /** A horizontal shake for rejected input; dropped under reduced motion. */ function useRejectShake() { const [scope, animate] = useAnimate(); const reduce = useReducedMotion(); return { scope, shake: () => { if (reduce || !scope.current) return; animate(scope.current, { x: [0, -5, 5, -3, 3, 0] }, { duration: 0.3 }); }, }; } export interface ColorPickerHexInputProps extends Omit, "value" | "defaultValue" | "type"> {} /** Hex field. Updates live once six or eight digits are typed, reverts invalid input on blur. */ export function ColorPickerHexInput({ className, onChange, onBlur, onKeyDown, "aria-label": ariaLabel = "Hex color", ...props }: ColorPickerHexInputProps) { const { hsva, hex, update, commit, disabled } = usePickerContext("ColorPickerHexInput"); const [draft, setDraft] = useState(null); const { scope, shake } = useRejectShake(); const settle = () => { if (draft === null) return; const parsed = parseHex(draft); if (parsed) { update(rgbaToHsva(parsed, hsva)); commit(); } else shake(); setDraft(null); }; return (

{ onChange?.(event); const next = event.target.value.replace(/^#/, ""); setDraft(next); // Live preview only for full-length entries, so "abc" mid-way to // "abcdef" does not flash a short-form color. if (next.length === 6 || next.length === 8) { const parsed = parseHex(next); if (parsed) update(rgbaToHsva(parsed, hsva)); } }} onBlur={(event) => { onBlur?.(event); settle(); }} onKeyDown={(event) => { onKeyDown?.(event); if (event.key === "Enter") settle(); if (event.key === "Escape" && draft !== null) { event.preventDefault(); setDraft(null); } }} className={cn(FIELD_CLASS, "pr-3 pl-6 font-mono uppercase")} />

); } type ChannelSpec = { key: string; short: string; name: string; max: number; value: number; set: (n: number) => Hsva }; function ChannelField({ spec }: { spec: ChannelSpec }) { const { update, commit, disabled } = usePickerContext("ColorPickerChannels"); const [draft, setDraft] = useState(null); const shown = Math.round(spec.value); return ( { const next = event.target.value.replace(/[^\d]/g, "").slice(0, 3); setDraft(next); if (next !== "") update(spec.set(clamp(Number(next), 0, spec.max))); }} onBlur={() => { if (draft !== null) commit(); setDraft(null); }} onKeyDown={(event) => { const delta = event.key === "ArrowUp" ? 1 : event.key === "ArrowDown" ? -1 : 0; if (delta) { event.preventDefault(); setDraft(null); update(spec.set(clamp(shown + delta * (event.shiftKey ? 10 : 1), 0, spec.max))); commit(); } else if (event.key === "Enter") { setDraft(null); commit(); } }} className={cn(FIELD_CLASS, "px-1 text-center")} /> ); } export interface ColorPickerChannelsProps extends Omit, "children"> { /** Which channels to edit. Default "rgb". */ format?: "rgb" | "hsl"; } /** Numeric RGB or HSL fields, plus an opacity field when alpha is enabled. Arrow keys nudge. */ export function ColorPickerChannels({ format = "rgb", className, ...props }: ColorPickerChannelsProps) { const { hsva, rgba, alpha } = usePickerContext("ColorPickerChannels"); const fromRgb = (patch: Partial) => rgbaToHsva({ ...rgba, ...patch }, hsva); let specs: ChannelSpec[]; if (format === "hsl") { const hsl = hsvToHsl(hsva); specs = [ { key: "h", short: "H", name: "Hue", max: 360, value: hsl.h, set: (n) => hslToHsv(n, hsl.s, hsl.l, hsva, hsva.a) }, { key: "s", short: "S", name: "Saturation", max: 100, value: hsl.s, set: (n) => hslToHsv(hsl.h, n, hsl.l, hsva, hsva.a) }, { key: "l", short: "L", name: "Lightness", max: 100, value: hsl.l, set: (n) => hslToHsv(hsl.h, hsl.s, n, hsva, hsva.a) }, ]; } else { specs = [ { key: "r", short: "R", name: "Red", max: 255, value: rgba.r, set: (n) => fromRgb({ r: n }) }, { key: "g", short: "G", name: "Green", max: 255, value: rgba.g, set: (n) => fromRgb({ g: n }) }, { key: "b", short: "B", name: "Blue", max: 255, value: rgba.b, set: (n) => fromRgb({ b: n }) }, ]; } if (alpha) { specs.push({ key: "a", short: "A", name: "Opacity percent", max: 100, value: hsva.a * 100, set: (n) => ({ ...hsva, a: n / 100 }) }); } return (

{specs.map((spec) => ( ))}

); } // --------------------------------------------------------------------------- // Eye dropper // --------------------------------------------------------------------------- type EyeDropperConstructor = new () => { open: () => Promise<{ sRGBHex: string }> }; export interface ColorPickerEyeDropperProps extends Omit, "type"> { children?: ReactNode; } /** Samples a color from the screen. Renders nothing where the EyeDropper API is missing. */ export function ColorPickerEyeDropper({ className, children, onClick, "aria-label": ariaLabel = "Pick a color from the screen", ...props }: ColorPickerEyeDropperProps) { const { hsva, update, commit, disabled } = usePickerContext("ColorPickerEyeDropper"); const reduce = useReducedMotion(); const [EyeDropper, setEyeDropper] = useState(null); useEffect(() => { const ctor = (window as Window & { EyeDropper?: EyeDropperConstructor }).EyeDropper; if (ctor) setEyeDropper(() => ctor); }, []); if (!EyeDropper) return null; return ( )} type="button" disabled={disabled} aria-label={ariaLabel} whileTap={reduce || disabled ? undefined : { scale: 0.92 }} transition={SPRING_PRESS} onClick={async (event) => { onClick?.(event); if (event.defaultPrevented) return; try { const { sRGBHex } = await new EyeDropper().open(); const parsed = parseHex(sRGBHex); if (!parsed) return; update(rgbaToHsva({ ...parsed, a: hsva.a }, hsva)); commit(); } catch { // Dismissed with Escape. } }} className={cn( "inline-flex size-9 shrink-0 items-center justify-center rounded-lg border border-border bg-background text-muted-foreground outline-none transition-colors hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed", className, )} > {children ?? ); } // --------------------------------------------------------------------------- // Presets // --------------------------------------------------------------------------- // The selection ring hops between swatches over a low arc instead of sliding. // arc() bends with distance (the apex sits at half of strength x distance), so // a neighbour gets a ~5px hop and a jump across the row clears the fields above. // Automatic direction always puts a horizontal bulge below the row; a negative // strength mirrors it above, in both directions of travel. const PRESET_HOP: Transition = { ...SPRING_LAYOUT, layout: { ...SPRING_LAYOUT, path: arc({ strength: -0.3 }) }, }; export type ColorPickerPresetsProps = ComponentPropsWithRef<"div">; export function ColorPickerPresets({ className, children, ...props }: ColorPickerPresetsProps) { const { id } = usePickerContext("ColorPickerPresets"); return (

{children}

); } export interface ColorPickerPresetProps extends Omit, "value" | "children" | "type"> { /** Hex color this preset applies. */ value: string; /** Accessible color name. Defaults to the hex. */ label?: string; } export function ColorPickerPreset({ value, label, className, onClick, ...props }: ColorPickerPresetProps) { const { hsva, hex, update, commit, disabled } = usePickerContext("ColorPickerPreset"); const reduce = useReducedMotion(); const parsed = parseHex(value); const normalized = parsed ? formatHex(parsed) : value; const selected = normalized === hex; return ( )} type="button" disabled={disabled} aria-label={label ?? normalized} aria-pressed={selected} whileTap={reduce || disabled ? undefined : { scale: 0.88 }} transition={SPRING_PRESS} onClick={(event) => { onClick?.(event); if (event.defaultPrevented || !parsed) return; update(rgbaToHsva(parsed, hsva)); commit(); }} className={cn( "relative size-6 shrink-0 rounded-full outline-none focus-visible:outline-2 focus-visible:outline-offset-3 focus-visible:outline-foreground disabled:cursor-not-allowed", className, )} > {selected && ( ); } // --------------------------------------------------------------------------- // Popover: trigger chip morphs into the area // --------------------------------------------------------------------------- export interface ColorPickerTriggerProps extends Omit, "type"> { /** Replaces the hex label beside the chip. */ children?: ReactNode; } /** * The hex beside the chip. Its width springs to the text instead of snapping, * so the trigger never jumps when the hex gains or drops its alpha pair. Width * is a layout property, but this is one small inline box with nothing laid out * after it inside the button, and a transform cannot resize the border. */ function TriggerLabel({ hex }: { hex: string }) { const reduce = useReducedMotion(); const textRef = useRef(null); const [width, setWidth] = useState(null); useLayoutEffect(() => { const text = textRef.current; if (!text) return; setWidth(text.offsetWidth); const observer = new ResizeObserver(() => setWidth(text.offsetWidth)); observer.observe(text); return () => observer.disconnect(); }, []); const alpha = hex.slice(7); return ( {hex.slice(0, 7)} {alpha && ( {alpha} )} ); } /** Opens ColorPickerContent. Its color chip is the surface that grows into the area. */ export function ColorPickerTrigger({ className, children, onClick, ...props }: ColorPickerTriggerProps) { const { id, hex, open, setOpen, triggerRef, disabled } = usePickerContext("ColorPickerTrigger"); const reduce = useReducedMotion(); return ( ); } export interface ColorPickerContentProps extends Omit, "role"> { /** Edge of the trigger the panel lines up with. Default "start". */ align?: "start" | "end"; } /** Minimum gap between the panel and the viewport edge, in px. */ const VIEWPORT_GUTTER = 8; // Each layer owns its enter and exit values instead of inheriting them from // the panel. Reopening during the close cancels the exit per element, and an // element only returns to its enter state if that state is its own. const PANEL_DELAY = 0.1; const PANEL_STAGGER = 0.035; const PANEL_ITEM = { initial: { opacity: 0, y: -6, filter: "blur(4px)" }, animate: { opacity: 1, y: 0, filter: "blur(0px)" }, }; const PANEL_ITEM_REDUCED = { initial: { opacity: 0 }, animate: { opacity: 1 }, }; const PANEL_ITEM_EXIT = { opacity: 0, transition: { duration: 0.1 } }; /** * Panel opened by ColorPickerTrigger, laid out under it. A ColorPickerArea * placed directly inside grows out of the trigger chip; the other children * stagger in behind it. Closes on outside press and Escape. */ export function ColorPickerContent({ align = "start", className, children, ...props }: ColorPickerContentProps) { const { id, open, setOpen, triggerRef } = usePickerContext("ColorPickerContent"); const reduce = useReducedMotion() ?? false; const panelRef = useRef(null); // Keep the panel on screen horizontally. Written before paint, and before // motion measures the area, so the chip morphs to where the panel really is. useLayoutEffect(() => { const panel = panelRef.current; if (!open || !panel) return; panel.style.marginLeft = "0px"; const rect = panel.getBoundingClientRect(); const max = document.documentElement.clientWidth - VIEWPORT_GUTTER; let shift = 0; if (rect.right > max) shift = max - rect.right; if (rect.left + shift < VIEWPORT_GUTTER) shift = VIEWPORT_GUTTER - rect.left; panel.style.marginLeft = `${shift}px`; }, [open]); useDismiss(open, () => setOpen(false), panelRef, { ignore: (target) => Boolean(triggerRef.current?.contains(target)), }); // Hand focus in on open, and back to the trigger when it closes from inside. // Skipped on mount, so a picker that starts open does not steal page focus. const wasOpen = useRef(open); useEffect(() => { if (wasOpen.current === open) return; wasOpen.current = open; if (open) { panelRef.current ?.querySelector( '[role="slider"]:not([aria-disabled]), input:not(:disabled), button:not(:disabled)', ) ?.focus({ preventScroll: true }); return; } const active = document.activeElement; if (!active || active === document.body || panelRef.current?.contains(active)) { triggerRef.current?.focus({ preventScroll: true }); } }, [open, triggerRef]); return ( {open && ( {({ gate }) => { // Counted per render, for stagger delays only; keys come from Children.map. let row = 0; return ( )} {...gate} ref={panelRef} id={`${id}-content`} role="dialog" aria-label={props["aria-label"] ?? "Color picker"} className={cn( "absolute top-full z-50 mt-2 flex w-72 flex-col gap-3 p-3", align === "end" ? "right-0" : "left-0", className, )} > {/* The surface fades on its own layer so the morphing area is never faded with it. */} {/* Children.map keys each wrapper from its child, stable across the exit render. */} {Children.map(children, (child) => { if (isValidElement(child) && child.type === ColorPickerArea) return child; row += 1; const item = reduce ? PANEL_ITEM_REDUCED : PANEL_ITEM; return ( {child} ); })} ); }} )} ); } 65:T722,// 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; /** Accelerating curve for things that fall (a dropped ball, a toppled block). Not for UI entrances. */ export const EASE_IN = [0.55, 0, 1, 0.45] 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; 66:T1279,"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 | 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]); } 67:T74c,"use client"; import { useIsPresent } from "motion/react"; import type { ReactNode } from "react"; export interface PresenceGateRenderProps { /** * False from the render that starts the exit animation onward. An overlay * kept in the tree by `AnimatePresence` is still the topmost thing on the * page, so anything it decides from `open` alone stays true for the whole * exit — this is the boolean that already knows the overlay is leaving. */ isPresent: boolean; /** * Spread onto every layer that takes pointer events while the overlay is * open. Interaction releases in the same commit that starts the exit while * the visual exit keeps playing: pointer events stop landing, and `inert` * drops the subtree from focus order, from tab order and from the * accessibility tree — an exiting dialog is not a dialog you can still type * into. A layer that never takes pointer events (a wrapper that only centres * the panel) takes `inert={!isPresent}` alone, so its own * `pointer-events-none` is not overwritten. */ gate: { inert: boolean; style: { pointerEvents: "auto" | "none" }; }; } export interface PresenceGateProps { children: (props: PresenceGateRenderProps) => ReactNode; } /** * Reads the presence of the subtree it renders and hands it down. * * `useIsPresent` only answers inside the `AnimatePresence` subtree, and the * components that own an overlay render the `AnimatePresence` themselves, so * the boolean has to be read one component further down: this is that * component, and the render prop is how it reaches the layers. */ export function PresenceGate({ children }: PresenceGateProps) { const isPresent = useIsPresent(); return children({ isPresent, gate: { inert: !isPresent, style: { pointerEvents: isPresent ? "auto" : "none" }, }, }); } 68:T1668,// 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 `` or `` descendant. `-webkit-user-drag` is // not inherited and plain divs and buttons are not drag sources, so setting // it on the surface does nothing — the child itself needs `draggable={false}`. /** * Classes for a surface that *is* the control: a thumb, a drum, a stage, a * handle, a hold button. Selection is suppressed on every input, because a * drag that highlights the control's own label is wrong on a mouse too. * Compose with `touch-none` when the surface also owns the scroll axis — leave * it off when the page must still scroll from there. */ export const TOUCH_GESTURE_CLASS = "select-none [-webkit-touch-callout:none]"; /** * The same opt-out for a gesture surface that wraps content the consumer owns: * a scroller, a context-menu trigger, a sheet header, a list row. Selection is * suppressed only where the platform runs its own press gestures — a coarse * pointer — so a mouse user can still select and copy that content. If the * gesture itself would paint a selection under the cursor, add `select-none` * for the duration of the gesture rather than reaching for * `TOUCH_GESTURE_CLASS`. * * `pointer: coarse` describes the *primary* pointer and nothing else, so a * hybrid machine reads it wrong in both directions: a tablet with a mouse * plugged in keeps touch as primary and loses mouse selection, and a laptop * with a touchscreen keeps the mouse as primary and leaves selection live * under a finger. No media query can answer per interaction — the query is * about the device, and the question is about the gesture in progress. The * default stays here because it is right on the machines that are one thing or * the other, and losing a selection is a nuisance; where the miss costs a * *gesture* instead, the surface pairs it with `holdSelection` on the press. */ export const TOUCH_GESTURE_CONTENT_CLASS = "[-webkit-touch-callout:none] pointer-coarse:select-none"; /** * Suppress selection on `element` for as long as a gesture is running on it, * whatever the primary pointer of the machine happens to be. Returns the * release. Inline, so it wins over the class above and is gone again the * moment the gesture ends. * * For the press gestures a native selection would otherwise steal — a * long-press that opens a menu. Elsewhere prefer the classes: a surface that * takes selection away for the whole session is a surface whose text nobody * can copy. */ export function holdSelection(element: HTMLElement) { element.style.setProperty("user-select", "none"); element.style.setProperty("-webkit-user-select", "none"); return () => { element.style.removeProperty("user-select"); element.style.removeProperty("-webkit-user-select"); }; } /** * Pointer capture, best effort. WebKit throws `NotFoundError` when the pointer * is already gone by the time the handler runs — routine on iOS, where the * system can claim the touch first — and an uncaught throw takes the rest of * the handler, the gesture included, down with it. Touch pointers carry * implicit capture anyway, so losing it is never fatal. */ export function capturePointer(element: Element, pointerId: number) { try { element.setPointerCapture(pointerId); } catch { // Pointer is no longer active — implicit capture still applies on touch. } } /** Release a capture taken with `capturePointer`, ignoring a stale pointer. */ export function releasePointer(element: Element, pointerId: number) { try { if (element.hasPointerCapture(pointerId)) { element.releasePointerCapture(pointerId); } } catch { // Capture was already dropped by the browser. } } /** * Whether this event came from a pointer that is *hovering*: not a touch, and * not currently pressed. Which input the user is holding right now is not * something a device capability can answer — a touchscreen laptop hovers and * taps, and iPadOS reports a fine hovering pointer for a finger — so both * paths stay live and each handler branches on the event it was given. * * A pen resting on the glass is making contact, not hovering: `buttons` is the * tell, and it sends a pen tap down the same route a finger takes. * * This answers what an *enter* asks. A leave is the other half of a pair and * has to be read against the enter that started it — `useHoverGesture` in * `lib/hooks/use-hover-gesture` does that, and hover surfaces should use it * rather than asking this question twice. */ export const isHoveringPointer = (event: { pointerType: string; buttons: number; }) => event.pointerType !== "touch" && event.buttons === 0; 61:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","clsx",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/clsx","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"clsx"}]]}]}],["$","li","lucide-react",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/lucide-react","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"lucide-react"}]]}]}],["$","li","motion",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/motion","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"motion"}]]}]}],["$","li","tailwind-merge",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/tailwind-merge","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"tailwind-merge"}]]}]}]]}],["$","$L62",null,{"namespace":"@registrydirectory","registryDependencies":[]}]]}],null]}],["$","$L63",null,{"files":[{"path":"components/motion/color-picker.tsx","content":"$64","type":"registry:component","target":"@components/motion/color-picker.tsx"},{"path":"lib/ease.ts","content":"$65","type":"registry:lib","target":"@lib/ease.ts"},{"path":"lib/hooks/use-dismiss.ts","content":"$66","type":"registry:hook","target":"@lib/hooks/use-dismiss.ts"},{"path":"lib/presence-gate.tsx","content":"$67","type":"registry:lib","target":"@lib/presence-gate.tsx"},{"path":"lib/touch.ts","content":"$68","type":"registry:lib","target":"@lib/touch.ts"},{"path":"lib/utils.ts","content":"import { clsx, type ClassValue } from \"clsx\"\nimport { twMerge } from \"tailwind-merge\"\n\nexport function cn(...inputs: ClassValue[]) {\n return twMerge(clsx(inputs))\n}\n","type":"registry:lib","target":"@lib/utils.ts"}],"className":"h-[70svh] min-h-80"}]]}]