50: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/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.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"] 51:T300e,// Hairline UI · swipe-actions · MIT License // Copyright (c) 2026 Hairline UI · https://hairlineui.com/license#components 'use client'; /* ───────────────────────────────────────────────────────── * SWIPE ACTIONS: a list row that slides over its actions * * reveal drag the row (or swipe two fingers on a * trackpad) and the actions under that edge share * the space it uncovers: each cell grows with the * finger and its icon scales in once there's room * open let go past half the rail, or flick, and the row * springs open with the actions at full size; tap * the row, anywhere else or Escape to close it. * Opening one row closes the others * arm keep going past most of the row and the first * action takes the whole space, its icon riding the * row's edge (a tick on phones). Let go to run it * remove an action that removes the row (archive, delete) * slides it off and folds its height away at once; * if the work fails, the row unfolds, slides back, * shakes, and its time reads "Failed" * hover with a mouse, the row's time gives way to the same * actions as icons, so nothing needs a swipe * * The icon buttons are the accessible actions: Tab reaches them, * and results are announced. The swipe cells repeat them for * pointers and stay out of the tab order. * ───────────────────────────────────────────────────────── */ import * as React from 'react'; import { EASE_OUT, INTERACTION_FOCUS, useInteractionReducedMotion } from './ui-interaction-motion'; import { type SwipeSide, useSwipeRow } from './use-swipe-row'; export type SwipeTone = 'neutral' | 'primary' | 'destructive'; export interface SwipeAction { id: string; label: string; icon: React.ReactNode; tone?: SwipeTone; /** The row leaves the list (archive, delete): it slides out and folds away at once, and comes back if onAction throws. Remove the item from your list when it resolves. */ removes?: boolean; onAction: () => void | Promise; } export interface SwipeActionsProps extends Omit, 'children'> { /** Names the row for screen readers, e.g. the message subject. */ label: string; /** Under the left edge, revealed by swiping right. The first one runs on a full swipe. */ leading?: SwipeAction[]; /** Under the right edge, revealed by swiping left, listed from the edge inward. The first one runs on a full swipe. */ trailing?: SwipeAction[]; /** At the row's end, e.g. the time. With a mouse it gives way to the actions on hover. */ meta?: React.ReactNode; /** Unfold on mount, for a row put back by an undo. */ enter?: boolean; /** A hairline under the row, folding away with it. */ divider?: boolean; disabled?: boolean; children: React.ReactNode; } const CELL = 76; const NONE: SwipeAction[] = []; const TONES: Record = { neutral: 'bg-muted text-foreground shadow-[inset_1px_0_0_var(--border),inset_-1px_0_0_var(--border)]', primary: 'bg-primary text-primary-foreground', destructive: 'bg-destructive text-white', }; // Cells start off the row; after that the engine owns their transforms, so these objects never change. const OFF: Record = { leading: { transform: 'translate3d(-100%,0,0)' }, trailing: { transform: 'translate3d(100%,0,0)' } }; const HIDDEN: React.CSSProperties = { opacity: 0 }; export function SwipeActions({ label, leading = NONE, trailing = NONE, meta, enter = false, divider = true, disabled = false, children, className = '', ...props }: SwipeActionsProps) { const reduced = useInteractionReducedMotion(); const [gone, setGone] = React.useState(enter && !reduced); const [failed, setFailed] = React.useState(false); const [said, setSaid] = React.useState(''); const busy = React.useRef(false); const alive = React.useRef(true); const body = React.useRef(null); const timers = React.useRef(new Set>()); const lists = React.useRef({ leading, trailing }); lists.current = { leading, trailing }; const wait = (ms: number) => new Promise((resolve) => { const t = setTimeout(() => { timers.current.delete(t); resolve(); }, reduced ? 0 : ms); timers.current.add(t); }); const run = async (side: SwipeSide, index: number, via: 'swipe' | 'cell' | 'button') => { const action = lists.current[side][index]; if (!action || busy.current || disabled) return; busy.current = true; setFailed(false); try { if (action.removes) { // Optimistic: the row leaves now, and comes back only if the work fails. await row.commit(side, index); if (!alive.current) return; setGone(true); try { await action.onAction(); if (alive.current) setSaid(`${label}: ${action.label} done`); } catch { if (!alive.current) return; setGone(false); await wait(360); row.restore(); await wait(420); fail(action); } return; } if (via === 'swipe') await row.commit(side, index); else row.close(); let ok = true; try { await action.onAction(); } catch { ok = false; } if (!alive.current) return; if (via === 'swipe') { await wait(140); row.restore(); } if (ok) setSaid(`${label}: ${action.label} done`); else { await wait(380); fail(action); } } finally { busy.current = false; } }; const fail = (action: SwipeAction) => { if (!alive.current) return; setFailed(true); setSaid(`${label}: ${action.label} failed. Try again.`); if (!reduced) body.current?.animate([{ transform: 'none' }, { transform: 'translateX(-5px)' }, { transform: 'translateX(5px)' }, { transform: 'translateX(-3px)' }, { transform: 'none' }], { duration: 380, easing: 'ease-out' }); const t = setTimeout(() => { timers.current.delete(t); setFailed(false); }, 2600); timers.current.add(t); }; const row = useSwipeRow({ leading: leading.length, trailing: trailing.length, cellWidth: CELL, reduced, disabled, onFull: (side) => void run(side, 0, 'swipe') }); React.useEffect(() => { alive.current = true; const pending = timers.current; return () => { alive.current = false; pending.forEach(clearTimeout); }; }, []); // A row put back by an undo unfolds once it's mounted. React.useEffect(() => { if (!gone || !enter) return; let b = 0; const a = requestAnimationFrame(() => { b = requestAnimationFrame(() => setGone(false)); }); return () => { cancelAnimationFrame(a); cancelAnimationFrame(b); }; // eslint-disable-next-line react-hooks/exhaustive-deps }, []); // Labels changed (Read ↔ Unread): measure the faces again. const labels = [...leading, ...trailing].map((a) => a.label).join('|'); React.useEffect(() => { row.remeasure(); }, [labels]); // eslint-disable-line react-hooks/exhaustive-deps const cellsFor = (side: SwipeSide, list: SwipeAction[]) => list.map((action, i) => ( )); // Mouse users get the same actions as icons: the row's own edge first, so the order matches the swipe. const buttons = [...leading.map((a, i) => ({ a, side: 'leading' as const, i })), ...[...trailing].reverse().map((a) => ({ a, side: 'trailing' as const, i: trailing.indexOf(a) }))]; return (

{ if (e.key === 'Escape' && row.open) { e.preventDefault(); row.close(); } }} className={`group/row relative isolate touch-pan-y overflow-hidden ${divider ? 'border-b border-border' : ''}`} > {cellsFor('leading', leading)} {cellsFor('trailing', trailing)}

{children}

{meta} Failed {buttons.length > 0 && (

{buttons.map(({ a, side, i }) => ( ))}

)}

{said}

); } 52:T3a1d,// Hairline UI · swipe-actions · MIT License // Copyright (c) 2026 Hairline UI · https://hairlineui.com/license#components 'use client'; import * as React from 'react'; /* * The swipe row's engine. The row's face slides over two sets of action cells, one under each * edge. Every cell is a full-height layer moved by transform only: as the face slides, the cells * share the space it uncovers equally, so each one grows with the finger, and their icons scale in * once there is room. Past most of the row the first action arms: it takes the whole space, its * icon rides the face's edge, and letting go there runs it. * * Drags, trackpad swipes and releases write transforms straight to the elements. One frame loop * runs the spring and the arming, and sleeps when both are still. Nothing renders through React * until a row opens, closes or commits. */ export type SwipeSide = 'leading' | 'trailing'; type Options = { leading: number; trailing: number; cellWidth: number; reduced: boolean; disabled: boolean; /** Released while armed: run that side's first action. */ onFull: (side: SwipeSide) => void; }; type Sim = { x: number; v: number; target: number; spring: 'none' | 'settle' | 'out'; arm: number; armTarget: number; armSide: SwipeSide; armIndex: number; armed: boolean; width: number; last: number; done: (() => void) | null; moving: boolean; }; const clamp = (n: number, lo: number, hi: number) => Math.max(lo, Math.min(hi, n)); const lerp = (a: number, b: number, t: number) => a + (b - a) * t; const STEP = 1 / 240; // One open row at a time, as in a mail list: opening one closes the others. const openRows = new Set<() => void>(); export function useSwipeRow(options: Options) { const opts = React.useRef(options); opts.current = options; const surface = React.useRef(null); const front = React.useRef(null); const cells = React.useRef>({ leading: [], trailing: [] }); const faces = React.useRef>({ leading: [], trailing: [] }); const faceWidths = React.useRef(new WeakMap()); const sim = React.useRef({ x: 0, v: 0, target: 0, spring: 'none', arm: 0, armTarget: 0, armSide: 'trailing', armIndex: 0, armed: false, width: 0, last: 0, done: null, moving: false }); const frame = React.useRef(0); const [open, setOpen] = React.useState(null); const openRef = React.useRef(null); const closeOthers = React.useRef<() => void>(() => {}); const width = () => { const s = sim.current; if (!s.width) s.width = surface.current?.offsetWidth ?? 0; return s.width; }; const count = (side: SwipeSide) => (side === 'leading' ? opts.current.leading : opts.current.trailing); const rail = (side: SwipeSide) => count(side) * opts.current.cellWidth; const threshold = (side: SwipeSide) => clamp(width() * 0.62, rail(side) + 40, Math.max(rail(side) + 40, width() - 32)); const paint = React.useCallback(() => { const s = sim.current, W = width(), A = opts.current.cellWidth; if (front.current) front.current.style.transform = `translate3d(${s.x}px,0,0)`; // Mark the row while it's off its rest, so hover affordances stand down until it's back. const moving = Math.abs(s.x) > 0.5; if (surface.current && moving !== s.moving) { s.moving = moving; surface.current.toggleAttribute('data-moving', moving); } for (const side of ['leading', 'trailing'] as const) { const k = count(side); const reveal = side === 'trailing' ? Math.max(0, -s.x) : Math.max(0, s.x); const slice = k ? reveal / k : 0; for (let i = 0; i < k; i++) { const cell = cells.current[side][i], face = faces.current[side][i]; if (!cell) continue; const armed = s.armSide === side && s.armIndex === i ? s.arm : 0; const visible = lerp(slice, reveal, armed); // The cell's inner edge: where the face's edge is when this cell has taken over. const inner = side === 'trailing' ? lerp(W - (i + 1) * slice, W - reveal, armed) : lerp((i + 1) * slice, reveal, armed); cell.style.transform = `translate3d(${side === 'trailing' ? inner : inner - W}px,0,0)`; cell.style.zIndex = String(armed > 0.01 ? 20 : k - i); if (face) { // Measured once per face (labels don't change while it moves), so painting never reads layout. let fw = faceWidths.current.get(face); if (!fw) { fw = face.offsetWidth || A * 0.6; faceWidths.current.set(face, fw); } const centre = lerp(slice / 2, Math.min(visible / 2, A / 2), armed); const x = side === 'trailing' ? centre - fw / 2 : W - centre - fw / 2; const p = clamp((visible - 18) / (A * 0.62), 0, 1); face.style.transform = `translate3d(${x}px,0,0) scale(${0.72 + 0.28 * p})`; face.style.opacity = String(p); } } } }, []); const tick = React.useCallback((now: number) => { frame.current = 0; const s = sim.current; const dt = s.last ? Math.min(0.05, (now - s.last) / 1000) : 1 / 60; s.last = now; let moving = false; if (s.spring !== 'none') { // Opening is a little springy (it overshoots outward, showing more of the same actions). Closing and // leaving are critically damped, and closing never crosses zero, so the other side's cells never flash. const k = 520, c = s.spring === 'out' || s.target === 0 ? 46 : 36; const side = Math.sign(s.x); for (let t = 0; t < dt - 1e-6; t += STEP) { const h = Math.min(STEP, dt - t); s.v += (-k * (s.x - s.target) - c * s.v) * h; s.x += s.v * h; if (s.target === 0 && side !== 0 && Math.sign(s.x) !== side) { s.x = 0; s.v = 0; } } if (Math.abs(s.x - s.target) < 0.4 && Math.abs(s.v) < 8) { s.x = s.target; s.v = 0; s.spring = 'none'; const done = s.done; s.done = null; done?.(); } else moving = true; } const ka = 1 - Math.exp(-dt / 0.06); s.arm += (s.armTarget - s.arm) * ka; if (Math.abs(s.armTarget - s.arm) < 0.002) s.arm = s.armTarget; else moving = true; paint(); if (moving) frame.current = requestAnimationFrame(tick); else s.last = 0; }, [paint]); const kick = React.useCallback(() => { if (!frame.current) frame.current = requestAnimationFrame(tick); }, [tick]); const setOpenSide = React.useCallback((side: SwipeSide | null) => { if (openRef.current === side) return; openRef.current = side; setOpen(side); if (side) { openRows.forEach((close) => close !== closeOthers.current && close()); openRows.add(closeOthers.current); } else openRows.delete(closeOthers.current); }, []); /** Spring to a resting place: 0 (closed) or a side's rail (open). */ const settle = React.useCallback((target: number, velocity = 0) => { const s = sim.current; s.target = target; s.armTarget = 0; s.armed = false; setOpenSide(target < 0 ? 'trailing' : target > 0 ? 'leading' : null); if (opts.current.reduced) { s.x = target; s.v = 0; s.arm = 0; s.spring = 'none'; paint(); return; } s.v = velocity; s.spring = 'settle'; kick(); }, [kick, paint, setOpenSide]); const close = React.useCallback(() => settle(0), [settle]); closeOthers.current = close; /** One action takes the whole row and the face slides off; resolves once it's gone. */ const commit = React.useCallback((side: SwipeSide, index: number) => new Promise((resolve) => { const s = sim.current; s.armSide = side; s.armIndex = index; s.armTarget = 1; s.target = (side === 'trailing' ? -1 : 1) * (width() + 2); setOpenSide(null); if (opts.current.reduced) { s.x = s.target; s.arm = 1; s.spring = 'none'; paint(); resolve(); return; } s.spring = 'out'; s.done = resolve; kick(); }), [kick, paint, setOpenSide]); /** Bring the face back after a commit (the action failed, or it doesn't remove the row). */ const restore = React.useCallback(() => { sim.current.armed = false; settle(0); }, [settle]); // Pointer and trackpad gestures. React.useEffect(() => { const el = surface.current; if (!el) return; const s = sim.current; let drag: { id: number; x: number; y: number; origin: number; started: boolean; samples: { x: number; t: number }[] } | null = null; let quiet: ReturnType | null = null; let wheelV = 0, wheelT = 0; let suppress = false; const follow = (raw: number) => { const W = width(); const side: SwipeSide = raw < 0 ? 'trailing' : 'leading'; const k = count(side); let x: number; if (!k) x = Math.sign(raw) * Math.min(22, Math.abs(raw) * 0.18); else { const r = Math.abs(raw), limit = W * 0.94; x = Math.sign(raw) * (r > limit ? limit + (r - limit) * 0.2 : r); } s.x = x; // Arm past the threshold, disarm a little before it, so the boundary doesn't flicker. const reveal = Math.abs(x), T = k ? threshold(side) : Infinity; if (k && !s.armed && reveal >= T) { s.armed = true; s.armSide = side; s.armIndex = 0; s.armTarget = 1; try { if (drag && 'vibrate' in navigator) navigator.vibrate(6); } catch { /* not allowed yet */ } } else if (s.armed && (reveal < T - 24 || s.armSide !== side)) { s.armed = false; s.armTarget = 0; } if (s.arm !== s.armTarget) kick(); else paint(); }; const release = (velocity: number) => { const side: SwipeSide = s.x < 0 ? 'trailing' : 'leading'; const reveal = Math.abs(s.x), R = rail(side), outward = side === 'trailing' ? velocity < -0.45 : velocity > 0.45; const inward = side === 'trailing' ? velocity > 0.45 : velocity < -0.45; if (s.armed && count(side)) { s.armed = false; opts.current.onFull(side); return; } if (count(side) && !inward && (reveal > R * 0.5 || (outward && reveal > 14))) settle((side === 'trailing' ? -1 : 1) * R, velocity * 1000); else settle(0, velocity * 1000); }; const down = (e: PointerEvent) => { suppress = false; if (opts.current.disabled || e.button !== 0 || !e.isPrimary) return; if (s.spring === 'out') return; const W = surface.current?.offsetWidth ?? 0; s.width = W; cancelAnimationFrame(frame.current); frame.current = 0; s.spring = 'none'; s.v = 0; drag = { id: e.pointerId, x: e.clientX, y: e.clientY, origin: s.x, started: false, samples: [{ x: e.clientX, t: e.timeStamp }] }; }; const move = (e: PointerEvent) => { if (!drag || e.pointerId !== drag.id) return; const dx = e.clientX - drag.x, dy = e.clientY - drag.y; if (!drag.started) { if (Math.abs(dx) < 7 && Math.abs(dy) < 7) return; // Mostly vertical: it's a scroll, not a swipe. if (Math.abs(dy) > Math.abs(dx)) { drag = null; if (s.x !== 0 || s.arm) settle(openRef.current ? s.x : 0); return; } drag.started = true; el.setPointerCapture(e.pointerId); } drag.samples.push({ x: e.clientX, t: e.timeStamp }); while (drag.samples.length > 2 && e.timeStamp - drag.samples[0].t > 90) drag.samples.shift(); follow(drag.origin + dx); }; const up = (e: PointerEvent) => { if (!drag || e.pointerId !== drag.id) return; const d = drag; drag = null; if (!d.started) { // A tap on an open row's face closes it instead of opening whatever is under it. if (openRef.current && front.current?.contains(e.target as Node)) { suppress = true; close(); } else if (s.x !== 0 && !openRef.current) settle(0); return; } suppress = true; const first = d.samples[0], last = d.samples[d.samples.length - 1]; const fresh = e.timeStamp - last.t < 80 && last.t > first.t; release(fresh ? (last.x - first.x) / (last.t - first.t) : 0); }; const cancel = (e: PointerEvent) => { if (!drag || e.pointerId !== drag.id) return; drag = null; settle(openRef.current ? (openRef.current === 'trailing' ? -rail('trailing') : rail('leading')) : 0); }; const click = (e: MouseEvent) => { if (!suppress) return; suppress = false; e.preventDefault(); e.stopPropagation(); }; // Two-finger swipes on a trackpad move the row too; vertical scrolling is left to the page. const wheel = (e: WheelEvent) => { if (opts.current.disabled || s.spring === 'out' || Math.abs(e.deltaX) <= Math.abs(e.deltaY)) return; e.preventDefault(); if (!quiet) { s.width = surface.current?.offsetWidth ?? 0; cancelAnimationFrame(frame.current); frame.current = 0; s.spring = 'none'; s.v = 0; } else clearTimeout(quiet); const now = e.timeStamp; const dt = Math.max(8, now - wheelT); wheelV = wheelV * 0.6 + (-e.deltaX / dt) * 0.4; wheelT = now; follow(s.x - e.deltaX); quiet = setTimeout(() => { quiet = null; release(wheelV); wheelV = 0; }, 110); }; const away = (e: PointerEvent) => { if (openRef.current && !el.contains(e.target as Node)) close(); }; const resize = new ResizeObserver(() => { s.width = el.offsetWidth; faceWidths.current = new WeakMap(); if (openRef.current) s.x = openRef.current === 'trailing' ? -rail('trailing') : rail('leading'); paint(); }); resize.observe(el); el.addEventListener('pointerdown', down); el.addEventListener('pointermove', move); el.addEventListener('pointerup', up); el.addEventListener('pointercancel', cancel); el.addEventListener('click', click, true); el.addEventListener('wheel', wheel, { passive: false }); document.addEventListener('pointerdown', away); paint(); const closeMine = closeOthers.current; return () => { if (quiet) clearTimeout(quiet); cancelAnimationFrame(frame.current); frame.current = 0; resize.disconnect(); openRows.delete(closeMine); el.removeEventListener('pointerdown', down); el.removeEventListener('pointermove', move); el.removeEventListener('pointerup', up); el.removeEventListener('pointercancel', cancel); el.removeEventListener('click', click, true); el.removeEventListener('wheel', wheel); document.removeEventListener('pointerdown', away); }; // eslint-disable-next-line react-hooks/exhaustive-deps }, []); return { surface, front, cells, faces, open, close, commit, restore, openSide: (side: SwipeSide) => settle((side === 'trailing' ? -1 : 1) * rail(side)), remeasure: () => { faceWidths.current = new WeakMap(); paint(); } }; } 53:Tc6b,// Hairline UI · swipe-actions · MIT License // Copyright (c) 2026 Hairline UI · https://hairlineui.com/license#components 'use client'; import * as React from 'react'; export const EASE_OUT = 'cubic-bezier(0.16, 1, 0.3, 1)'; export const EASE_SETTLE = 'cubic-bezier(0.22, 1.18, 0.36, 1)'; export 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'; const query = '(prefers-reduced-motion: reduce)'; const subscribe = (notify: () => void) => { const media = window.matchMedia(query); media.addEventListener('change', notify); return () => media.removeEventListener('change', notify); }; export const useInteractionReducedMotion = () => React.useSyncExternalStore(subscribe, () => window.matchMedia(query).matches, () => false); export function useInteractionActivity() { const ref = React.useRef(null); const [visible, setVisible] = React.useState(false); const [hidden, setHidden] = React.useState(false); React.useEffect(() => { const el = ref.current; if (!el) return; const observer = new IntersectionObserver(([entry]) => setVisible(entry.isIntersecting)); observer.observe(el); const visibility = () => setHidden(document.hidden); visibility(); document.addEventListener('visibilitychange', visibility); return () => { observer.disconnect(); document.removeEventListener('visibilitychange', visibility); }; }, []); return { ref, active: visible && !hidden }; } export function interactionIcon(on: boolean, reduced: boolean): React.CSSProperties { 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}` }; } /** Sample recent movement rather than averaging a long drag and losing its release velocity. */ export type PointerSample = { x: number; time: number }; export function samplePointer(samples: PointerSample[], x: number, time: number) { samples.push({ x, time }); while (samples.length > 2 && time - samples[0].time > 100) samples.shift(); } export function releaseVelocity(samples: PointerSample[], now: number) { if (samples.length < 2 || now - samples[samples.length - 1].time > 100) return 0; const first = samples[0], last = samples[samples.length - 1]; return (last.x - first.x) / Math.max(1, last.time - first.time); } /** A damped spring sampled by WAAPI: no React renders or perpetual frame loop. */ export function springFrames(from: number, to: number, velocity = 0, duration = 520) { const omega = 20, damping = 0.82, damped = omega * Math.sqrt(1 - damping * damping); const displacement = from - to; const coefficient = (velocity * 1000 + damping * omega * displacement) / damped; return Array.from({ length: 33 }, (_, i) => { const t = (i / 32) * duration / 1000; const value = to + Math.exp(-damping * omega * t) * (displacement * Math.cos(damped * t) + coefficient * Math.sin(damped * t)); return { value: i === 32 ? to : value, offset: i / 32 }; }); } 4f:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[null,["$","$L50",null,{"files":[{"path":"registry/swipe-actions.tsx","content":"$51","type":"registry:component"},{"path":"registry/use-swipe-row.ts","content":"$52","type":"registry:component"},{"path":"registry/ui-interaction-motion.ts","content":"$53","type":"registry:component"}],"className":"h-[70svh] min-h-80"}]]}]