@gabvdl/ui 0.0.14

package/dist/components/toast/toast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toast.js","sources":["../../../src/components/toast/toast.tsx"],"sourcesContent":["import * as React from 'react';\nimport { createPortal } from 'react-dom';\nimport { AlertTriangle, CheckCircle2, Info, Loader2, X, XCircle } from 'lucide-react';\n\nimport { cn } from '../../lib/utils';\n\nexport type ToastType = 'success' | 'error' | 'warning' | 'info' | 'loading';\n\nexport type ToastPosition =\n  | 'top-left'\n  | 'top-center'\n  | 'top-right'\n  | 'bottom-left'\n  | 'bottom-center'\n  | 'bottom-right';\n\nexport interface ToastAction {\n  label: string;\n  onClick?: () => void;\n  /** Renders the action as a link instead of a button. */\n  href?: string;\n}\n\nexport interface ToastOptions {\n  /** Bold first line above the message. */\n  title?: string;\n  type?: ToastType;\n  /** ms before it self-dismisses. `0` (or a `loading` toast) pins it open. */\n  duration?: number;\n  action?: ToastAction;\n}\n\nexport interface Toast extends ToastOptions {\n  id: string;\n  message: React.ReactNode;\n  type: ToastType;\n}\n\n/** Callable: `toast('Saved')`, plus one shorthand per type. */\nexport interface ToastFn {\n  (message: React.ReactNode, options?: ToastOptions): string;\n  success: (message: React.ReactNode, options?: ToastOptions) => string;\n  error: (message: React.ReactNode, options?: ToastOptions) => string;\n  warning: (message: React.ReactNode, options?: ToastOptions) => string;\n  info: (message: React.ReactNode, options?: ToastOptions) => string;\n  /** Pinned open with a spinner — settle it with `toast.update(id, …)`. */\n  loading: (message: React.ReactNode, options?: ToastOptions) => string;\n  /** Turn a pending toast into its outcome, in place. */\n  update: (id: string, message: React.ReactNode, options?: ToastOptions) => void;\n  dismiss: (id?: string) => void;\n}\n\nconst ToastCtx = React.createContext<ToastFn | null>(null);\n\n/**\n * The toast queue.\n *\n * ```tsx\n * <ToastProvider>          <App />         </ToastProvider>\n *\n * const toast = useToast()\n * toast.success('Deployed', { action: { label: 'Open', href: url } })\n * const id = toast.loading('Uploading…')\n * toast.update(id, 'Uploaded', { type: 'success' })\n * ```\n */\nexport function ToastProvider({\n  children,\n  position = 'bottom-right',\n  duration = 4000,\n  max = 4,\n}: {\n  children: React.ReactNode;\n  position?: ToastPosition;\n  /** Default lifetime. Errors get 1.75× this, since they carry more to read. */\n  duration?: number;\n  /** Oldest toasts beyond this are dropped, so a burst can't cover the page. */\n  max?: number;\n}) {\n  const [toasts, setToasts] = React.useState<Toast[]>([]);\n  const timers = React.useRef(new Map<string, ReturnType<typeof setTimeout>>());\n  const seq = React.useRef(0);\n\n  const dismiss = React.useCallback((id?: string) => {\n    if (id == null) {\n      timers.current.forEach(clearTimeout);\n      timers.current.clear();\n      setToasts([]);\n      return;\n    }\n    clearTimeout(timers.current.get(id));\n    timers.current.delete(id);\n    setToasts((prev) => prev.filter((t) => t.id !== id));\n  }, []);\n\n  const arm = React.useCallback(\n    (t: Toast) => {\n      clearTimeout(timers.current.get(t.id));\n      const ttl = t.duration ?? (t.type === 'loading' ? 0 : t.type === 'error' ? duration * 1.75 : duration);\n      if (ttl > 0) timers.current.set(t.id, setTimeout(() => dismiss(t.id), ttl));\n    },\n    [dismiss, duration],\n  );\n\n  const push = React.useCallback(\n    (message: React.ReactNode, { type = 'info', ...rest }: ToastOptions = {}) => {\n      const id = `t${(seq.current += 1)}`;\n      const toast: Toast = { id, message, type, ...rest };\n      setToasts((prev) => [...prev, toast].slice(-max));\n      arm(toast);\n      return id;\n    },\n    [arm, max],\n  );\n\n  const update = React.useCallback(\n    (id: string, message: React.ReactNode, options: ToastOptions = {}) => {\n      setToasts((prev) =>\n        prev.map((t) => {\n          if (t.id !== id) return t;\n          const next: Toast = { ...t, message, ...options, type: options.type ?? t.type };\n          arm(next);\n          return next;\n        }),\n      );\n    },\n    [arm],\n  );\n\n  const toast = React.useMemo<ToastFn>(() => {\n    const fn = ((message, options) => push(message, options)) as ToastFn;\n    fn.success = (m, o) => push(m, { ...o, type: 'success' });\n    fn.error = (m, o) => push(m, { ...o, type: 'error' });\n    fn.warning = (m, o) => push(m, { ...o, type: 'warning' });\n    fn.info = (m, o) => push(m, { ...o, type: 'info' });\n    fn.loading = (m, o) => push(m, { ...o, type: 'loading' });\n    fn.update = update;\n    fn.dismiss = dismiss;\n    return fn;\n  }, [push, update, dismiss]);\n\n  React.useEffect(() => {\n    const pending = timers.current;\n    return () => pending.forEach(clearTimeout);\n  }, []);\n\n  return (\n    <ToastCtx.Provider value={toast}>\n      {children}\n      <Toaster toasts={toasts} position={position} onDismiss={dismiss} />\n    </ToastCtx.Provider>\n  );\n}\n\n/** The toast function. Throws outside a `<ToastProvider>` — a silent no-op toast is worse. */\nexport function useToast(): ToastFn {\n  const ctx = React.useContext(ToastCtx);\n  if (!ctx) throw new Error('useToast must be used inside a <ToastProvider>');\n  return ctx;\n}\n\nconst META: Record<ToastType, { Icon: typeof Info; tone: string }> = {\n  success: { Icon: CheckCircle2, tone: 'text-emerald-500' },\n  error: { Icon: XCircle, tone: 'text-destructive' },\n  warning: { Icon: AlertTriangle, tone: 'text-amber-500' },\n  info: { Icon: Info, tone: 'text-sky-500' },\n  loading: { Icon: Loader2, tone: 'text-muted-foreground' },\n};\n\nconst PLACEMENT: Record<ToastPosition, string> = {\n  'top-left': 'top-0 left-0 items-start',\n  'top-center': 'top-0 left-1/2 -translate-x-1/2 items-center',\n  'top-right': 'top-0 right-0 items-end',\n  'bottom-left': 'bottom-0 left-0 items-start',\n  'bottom-center': 'bottom-0 left-1/2 -translate-x-1/2 items-center',\n  'bottom-right': 'bottom-0 right-0 items-end',\n};\n\n/** The rendered stack. `ToastProvider` mounts one; you rarely need it directly. */\nexport function Toaster({\n  toasts,\n  position = 'bottom-right',\n  onDismiss,\n}: {\n  toasts: Toast[];\n  position?: ToastPosition;\n  onDismiss: (id: string) => void;\n}) {\n  if (typeof document === 'undefined') return null;\n\n  const fromTop = position.startsWith('top');\n\n  return createPortal(\n    <div\n      className={cn(\n        'pointer-events-none fixed z-[100] flex w-full max-w-sm flex-col gap-2 p-4',\n        fromTop ? 'flex-col' : 'flex-col-reverse',\n        PLACEMENT[position],\n      )}\n      role=\"region\"\n      aria-label=\"Notifications\"\n    >\n      {toasts.map((t) => {\n        const { Icon, tone } = META[t.type];\n        return (\n          <div\n            key={t.id}\n            role={t.type === 'error' ? 'alert' : 'status'}\n            aria-live={t.type === 'error' ? 'assertive' : 'polite'}\n            className={cn(\n              'ds-toast pointer-events-auto flex w-full items-start gap-3 rounded-xl border border-border bg-popover p-3 pr-2 text-popover-foreground shadow-lg',\n              fromTop ? 'ds-toast--top' : 'ds-toast--bottom',\n            )}\n          >\n            <Icon className={cn('mt-0.5 size-4 shrink-0', tone, t.type === 'loading' && 'animate-spin')} />\n            <div className=\"min-w-0 flex-1\">\n              {t.title && <p className=\"text-sm font-medium\">{t.title}</p>}\n              <div className=\"text-sm text-muted-foreground [overflow-wrap:anywhere]\">{t.message}</div>\n              {t.action &&\n                (t.action.href ? (\n                  <a\n                    href={t.action.href}\n                    target=\"_blank\"\n                    rel=\"noreferrer\"\n                    className=\"mt-1.5 inline-block text-xs font-medium text-foreground underline underline-offset-2\"\n                  >\n                    {t.action.label}\n                  </a>\n                ) : (\n                  <button\n                    type=\"button\"\n                    onClick={() => {\n                      t.action?.onClick?.();\n                      onDismiss(t.id);\n                    }}\n                    className=\"mt-1.5 text-xs font-medium text-foreground underline underline-offset-2\"\n                  >\n                    {t.action.label}\n                  </button>\n                ))}\n            </div>\n            <button\n              type=\"button\"\n              onClick={() => onDismiss(t.id)}\n              aria-label=\"Dismiss\"\n              className=\"rounded-md p-1 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground\"\n            >\n              <X className=\"size-3.5\" />\n            </button>\n          </div>\n        );\n      })}\n    </div>,\n    document.body,\n  );\n}\n"],"names":["ToastCtx","React","ToastProvider","children","position","duration","max","toasts","setToasts","timers","seq","dismiss","id","prev","t","arm","ttl","push","message","type","rest","toast","update","options","next","fn","m","pending","jsxs","jsx","Toaster","useToast","ctx","META","CheckCircle2","XCircle","AlertTriangle","Info","Loader2","PLACEMENT","onDismiss","fromTop","createPortal","cn","Icon","tone","_b","_a","X"],"mappings":"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"}

package/dist/components/virtual-list/index.d.ts

@@ -0,0 +1,3 @@
+export { VirtualList } from './virtual-list';
+export type { VirtualListProps, VirtualListHandle } from './virtual-list';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/virtual-list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/virtual-list/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/components/virtual-list/virtual-list.d.ts

@@ -0,0 +1,71 @@
+import { CSSProperties, Key, ReactNode, Ref } from 'react';
+/** Imperative handle exposed via {@link VirtualListProps.apiRef}. */
+export interface VirtualListHandle {
+    scrollToIndex: (index: number, opts?: {
+        align?: 'auto' | 'start' | 'center' | 'end';
+    }) => void;
+    scrollToTop: () => void;
+}
+export interface VirtualListProps<T> {
+    /** The rows. Only the ones near the viewport are ever in the DOM. */
+    items: T[];
+    /** Render one row. */
+    renderItem: (item: T, index: number) => ReactNode;
+    /** Stable React key per row (defaults to the index). */
+    getItemKey?: (item: T, index: number) => Key;
+    /** First-paint height guess in px; real heights are then measured. */
+    estimateSize?: number;
+    /** Off-screen rows kept mounted as a scroll buffer. */
+    overscan?: number;
+    /**
+     * Called when the last rows scroll into range — append more items here for an
+     * infinite list. Guarded by `hasMore` and `loading`.
+     */
+    onEndReached?: () => void;
+    /** Whether more pages remain (guards `onEndReached`). */
+    hasMore?: boolean;
+    /** Whether a load is in flight (guards `onEndReached`, shows the indicator). */
+    loading?: boolean;
+    /** Rows-from-the-end that trip `onEndReached`. Default 4. */
+    endThreshold?: number;
+    /** Shown at the bottom while `loading`. */
+    loadingIndicator?: ReactNode;
+    /** Shown when `items` is empty and not loading. */
+    emptyState?: ReactNode;
+    /**
+     * Animate rows sliding to their new position when the list is re-sorted (e.g.
+     * an auto-sort by "updated" date whose value changed), so a reorder glides
+     * instead of teleporting. Only animates while the list is idle — scrolling and
+     * lazy height-measurement never animate. Requires the stylesheet
+     * `@gabvdl/ui/virtual-list.css` (bundled in `styles.css`) and a stable
+     * `getItemKey` so React keeps each row's DOM node across the reorder. Honors
+     * `prefers-reduced-motion`.
+     */
+    smooth?: boolean;
+    /** The scroll container — MUST be given a bounded height (via `className`). */
+    className?: string;
+    style?: CSSProperties;
+    /** Escape hatch to drive scrolling (e.g. keyboard navigation). */
+    apiRef?: Ref<VirtualListHandle>;
+}
+/**
+ * A virtualized, optionally infinite list. Only the rows near the viewport are
+ * mounted (windowing), heights are measured so rows may vary, and `onEndReached`
+ * fires as the tail comes into view so you can lazily append more. The scroll
+ * container needs a bounded height — set one with `className` (e.g. `h-96` or
+ * `flex-1 min-h-0`).
+ *
+ * ```tsx
+ * <VirtualList
+ *   items={rows}
+ *   className="h-96"
+ *   estimateSize={56}
+ *   hasMore={hasMore}
+ *   loading={loading}
+ *   onEndReached={loadNextPage}
+ *   renderItem={(row) => <Row {...row} />}
+ * />
+ * ```
+ */
+export declare function VirtualList<T>({ items, renderItem, getItemKey, estimateSize, overscan, onEndReached, hasMore, loading, endThreshold, loadingIndicator, emptyState, smooth, className, style, apiRef, }: VirtualListProps<T>): import("react").JSX.Element;
+//# sourceMappingURL=virtual-list.d.ts.map

package/dist/components/virtual-list/virtual-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-list.d.ts","sourceRoot":"","sources":["../../../src/components/virtual-list/virtual-list.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,GAAG,EACR,KAAK,SAAS,EACd,KAAK,GAAG,EACT,MAAM,OAAO,CAAC;AAKf,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAA;KAAE,KAAK,IAAI,CAAC;IAC/F,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,qEAAqE;IACrE,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,sBAAsB;IACtB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,SAAS,CAAC;IAClD,wDAAwD;IACxD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,CAAC;IAC7C,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,yDAAyD;IACzD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,gBAAgB,CAAC,EAAE,SAAS,CAAC;IAC7B,mDAAmD;IACnD,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,kEAAkE;IAClE,MAAM,CAAC,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAC;CACjC;AAQD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAC7B,KAAK,EACL,UAAU,EACV,UAAU,EACV,YAAiB,EACjB,QAAY,EACZ,YAAY,EACZ,OAAe,EACf,OAAe,EACf,YAAgB,EAChB,gBAAiC,EACjC,UAAiB,EACjB,MAAc,EACd,SAAS,EACT,KAAK,EACL,MAAM,GACP,EAAE,gBAAgB,CAAC,CAAC,CAAC,+BAmErB"}

package/dist/components/virtual-list/virtual-list.js

@@ -0,0 +1,65 @@
+import { jsx as o, jsxs as z } from "react/jsx-runtime";
+import { useRef as S, useImperativeHandle as L, useEffect as N } from "react";
+import { useVirtualizer as V } from "@tanstack/react-virtual";
+import { cn as u } from "../../lib/utils.js";
+const j = /* @__PURE__ */ o("div", { className: "py-3 text-center mono text-[11px] uppercase tracking-[0.2em] text-muted-foreground", children: "Loading…" });
+function H({
+  items: r,
+  renderItem: g,
+  getItemKey: c,
+  estimateSize: p = 56,
+  overscan: h = 6,
+  onEndReached: n,
+  hasMore: f = !1,
+  loading: l = !1,
+  endThreshold: m = 4,
+  loadingIndicator: v = j,
+  emptyState: w = null,
+  smooth: y = !1,
+  className: d,
+  style: x,
+  apiRef: I
+}) {
+  const a = S(null), t = V({
+    count: r.length,
+    getScrollElement: () => a.current,
+    estimateSize: () => p,
+    overscan: h,
+    getItemKey: c ? (e) => c(r[e], e) : void 0
+  }), i = t.getVirtualItems(), T = y && !t.isScrolling;
+  return L(
+    I,
+    () => ({
+      scrollToIndex: (e, s) => t.scrollToIndex(e, { align: (s == null ? void 0 : s.align) ?? "auto" }),
+      scrollToTop: () => t.scrollToOffset(0)
+    }),
+    [t]
+  ), N(() => {
+    if (!n || !f || l) return;
+    const e = i[i.length - 1];
+    e && e.index >= r.length - 1 - m && n();
+  }, [i, r.length, f, l, m, n]), r.length === 0 && !l ? /* @__PURE__ */ o("div", { ref: a, className: u("overflow-y-auto", d), style: x, children: w }) : /* @__PURE__ */ z("div", { ref: a, className: u("overflow-y-auto", d), style: x, children: [
+    /* @__PURE__ */ o("div", { style: { position: "relative", width: "100%", height: t.getTotalSize() }, children: i.map((e) => /* @__PURE__ */ o(
+      "div",
+      {
+        "data-index": e.index,
+        ref: t.measureElement,
+        className: u("ds-virtual-row", T && "ds-virtual-row--smooth"),
+        style: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          width: "100%",
+          transform: `translateY(${e.start}px)`
+        },
+        children: g(r[e.index], e.index)
+      },
+      e.key
+    )) }),
+    l && v
+  ] });
+}
+export {
+  H as VirtualList
+};
+//# sourceMappingURL=virtual-list.js.map

package/dist/components/virtual-list/virtual-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-list.js","sources":["../../../src/components/virtual-list/virtual-list.tsx"],"sourcesContent":["import {\n  useEffect,\n  useImperativeHandle,\n  useRef,\n  type CSSProperties,\n  type Key,\n  type ReactNode,\n  type Ref,\n} from 'react';\nimport { useVirtualizer } from '@tanstack/react-virtual';\n\nimport { cn } from '../../lib/utils';\n\n/** Imperative handle exposed via {@link VirtualListProps.apiRef}. */\nexport interface VirtualListHandle {\n  scrollToIndex: (index: number, opts?: { align?: 'auto' | 'start' | 'center' | 'end' }) => void;\n  scrollToTop: () => void;\n}\n\nexport interface VirtualListProps<T> {\n  /** The rows. Only the ones near the viewport are ever in the DOM. */\n  items: T[];\n  /** Render one row. */\n  renderItem: (item: T, index: number) => ReactNode;\n  /** Stable React key per row (defaults to the index). */\n  getItemKey?: (item: T, index: number) => Key;\n  /** First-paint height guess in px; real heights are then measured. */\n  estimateSize?: number;\n  /** Off-screen rows kept mounted as a scroll buffer. */\n  overscan?: number;\n  /**\n   * Called when the last rows scroll into range — append more items here for an\n   * infinite list. Guarded by `hasMore` and `loading`.\n   */\n  onEndReached?: () => void;\n  /** Whether more pages remain (guards `onEndReached`). */\n  hasMore?: boolean;\n  /** Whether a load is in flight (guards `onEndReached`, shows the indicator). */\n  loading?: boolean;\n  /** Rows-from-the-end that trip `onEndReached`. Default 4. */\n  endThreshold?: number;\n  /** Shown at the bottom while `loading`. */\n  loadingIndicator?: ReactNode;\n  /** Shown when `items` is empty and not loading. */\n  emptyState?: ReactNode;\n  /**\n   * Animate rows sliding to their new position when the list is re-sorted (e.g.\n   * an auto-sort by \"updated\" date whose value changed), so a reorder glides\n   * instead of teleporting. Only animates while the list is idle — scrolling and\n   * lazy height-measurement never animate. Requires the stylesheet\n   * `@gabvdl/ui/virtual-list.css` (bundled in `styles.css`) and a stable\n   * `getItemKey` so React keeps each row's DOM node across the reorder. Honors\n   * `prefers-reduced-motion`.\n   */\n  smooth?: boolean;\n  /** The scroll container — MUST be given a bounded height (via `className`). */\n  className?: string;\n  style?: CSSProperties;\n  /** Escape hatch to drive scrolling (e.g. keyboard navigation). */\n  apiRef?: Ref<VirtualListHandle>;\n}\n\nconst DefaultLoading = (\n  <div className=\"py-3 text-center mono text-[11px] uppercase tracking-[0.2em] text-muted-foreground\">\n    Loading…\n  </div>\n);\n\n/**\n * A virtualized, optionally infinite list. Only the rows near the viewport are\n * mounted (windowing), heights are measured so rows may vary, and `onEndReached`\n * fires as the tail comes into view so you can lazily append more. The scroll\n * container needs a bounded height — set one with `className` (e.g. `h-96` or\n * `flex-1 min-h-0`).\n *\n * ```tsx\n * <VirtualList\n *   items={rows}\n *   className=\"h-96\"\n *   estimateSize={56}\n *   hasMore={hasMore}\n *   loading={loading}\n *   onEndReached={loadNextPage}\n *   renderItem={(row) => <Row {...row} />}\n * />\n * ```\n */\nexport function VirtualList<T>({\n  items,\n  renderItem,\n  getItemKey,\n  estimateSize = 56,\n  overscan = 6,\n  onEndReached,\n  hasMore = false,\n  loading = false,\n  endThreshold = 4,\n  loadingIndicator = DefaultLoading,\n  emptyState = null,\n  smooth = false,\n  className,\n  style,\n  apiRef,\n}: VirtualListProps<T>) {\n  const parentRef = useRef<HTMLDivElement>(null);\n\n  const virtualizer = useVirtualizer({\n    count: items.length,\n    getScrollElement: () => parentRef.current,\n    estimateSize: () => estimateSize,\n    overscan,\n    getItemKey: getItemKey ? (index) => getItemKey(items[index], index) : undefined,\n  });\n\n  const virtualItems = virtualizer.getVirtualItems();\n\n  // Only glide rows when the list is idle: during a scroll the same reflow that\n  // repositions rows (and lazy height-measurement) would otherwise animate too,\n  // reading as lag. On a reorder the component re-renders while not scrolling,\n  // so the target offsets change and the transition plays.\n  const animate = smooth && !virtualizer.isScrolling;\n\n  useImperativeHandle(\n    apiRef,\n    () => ({\n      scrollToIndex: (index, opts) => virtualizer.scrollToIndex(index, { align: opts?.align ?? 'auto' }),\n      scrollToTop: () => virtualizer.scrollToOffset(0),\n    }),\n    [virtualizer],\n  );\n\n  // Infinite load: pull the next page as the last rows enter range.\n  useEffect(() => {\n    if (!onEndReached || !hasMore || loading) return;\n    const last = virtualItems[virtualItems.length - 1];\n    if (last && last.index >= items.length - 1 - endThreshold) onEndReached();\n  }, [virtualItems, items.length, hasMore, loading, endThreshold, onEndReached]);\n\n  if (items.length === 0 && !loading) {\n    return (\n      <div ref={parentRef} className={cn('overflow-y-auto', className)} style={style}>\n        {emptyState}\n      </div>\n    );\n  }\n\n  return (\n    <div ref={parentRef} className={cn('overflow-y-auto', className)} style={style}>\n      <div style={{ position: 'relative', width: '100%', height: virtualizer.getTotalSize() }}>\n        {virtualItems.map((v) => (\n          <div\n            key={v.key}\n            data-index={v.index}\n            ref={virtualizer.measureElement}\n            className={cn('ds-virtual-row', animate && 'ds-virtual-row--smooth')}\n            style={{\n              position: 'absolute',\n              top: 0,\n              left: 0,\n              width: '100%',\n              transform: `translateY(${v.start}px)`,\n            }}\n          >\n            {renderItem(items[v.index], v.index)}\n          </div>\n        ))}\n      </div>\n      {loading && loadingIndicator}\n    </div>\n  );\n}\n"],"names":["DefaultLoading","jsx","VirtualList","items","renderItem","getItemKey","estimateSize","overscan","onEndReached","hasMore","loading","endThreshold","loadingIndicator","emptyState","smooth","className","style","apiRef","parentRef","useRef","virtualizer","useVirtualizer","index","virtualItems","animate","useImperativeHandle","opts","useEffect","last","cn","jsxs","v"],"mappings":";;;;AA8DA,MAAMA,IACJ,gBAAAC,EAAC,OAAA,EAAI,WAAU,sFAAqF,UAAA,YAEpG;AAsBK,SAASC,EAAe;AAAA,EAC7B,OAAAC;AAAA,EACA,YAAAC;AAAA,EACA,YAAAC;AAAA,EACA,cAAAC,IAAe;AAAA,EACf,UAAAC,IAAW;AAAA,EACX,cAAAC;AAAA,EACA,SAAAC,IAAU;AAAA,EACV,SAAAC,IAAU;AAAA,EACV,cAAAC,IAAe;AAAA,EACf,kBAAAC,IAAmBZ;AAAA,EACnB,YAAAa,IAAa;AAAA,EACb,QAAAC,IAAS;AAAA,EACT,WAAAC;AAAA,EACA,OAAAC;AAAA,EACA,QAAAC;AACF,GAAwB;AACtB,QAAMC,IAAYC,EAAuB,IAAI,GAEvCC,IAAcC,EAAe;AAAA,IACjC,OAAOlB,EAAM;AAAA,IACb,kBAAkB,MAAMe,EAAU;AAAA,IAClC,cAAc,MAAMZ;AAAA,IACpB,UAAAC;AAAA,IACA,YAAYF,IAAa,CAACiB,MAAUjB,EAAWF,EAAMmB,CAAK,GAAGA,CAAK,IAAI;AAAA,EAAA,CACvE,GAEKC,IAAeH,EAAY,gBAAA,GAM3BI,IAAUV,KAAU,CAACM,EAAY;AAkBvC,SAhBAK;AAAA,IACER;AAAA,IACA,OAAO;AAAA,MACL,eAAe,CAACK,GAAOI,MAASN,EAAY,cAAcE,GAAO,EAAE,QAAOI,KAAA,gBAAAA,EAAM,UAAS,OAAA,CAAQ;AAAA,MACjG,aAAa,MAAMN,EAAY,eAAe,CAAC;AAAA,IAAA;AAAA,IAEjD,CAACA,CAAW;AAAA,EAAA,GAIdO,EAAU,MAAM;AACd,QAAI,CAACnB,KAAgB,CAACC,KAAWC,EAAS;AAC1C,UAAMkB,IAAOL,EAAaA,EAAa,SAAS,CAAC;AACjD,IAAIK,KAAQA,EAAK,SAASzB,EAAM,SAAS,IAAIQ,KAAcH,EAAA;AAAA,EAC7D,GAAG,CAACe,GAAcpB,EAAM,QAAQM,GAASC,GAASC,GAAcH,CAAY,CAAC,GAEzEL,EAAM,WAAW,KAAK,CAACO,IAEvB,gBAAAT,EAAC,OAAA,EAAI,KAAKiB,GAAW,WAAWW,EAAG,mBAAmBd,CAAS,GAAG,OAAAC,GAC/D,UAAAH,EAAA,CACH,IAKF,gBAAAiB,EAAC,SAAI,KAAKZ,GAAW,WAAWW,EAAG,mBAAmBd,CAAS,GAAG,OAAAC,GAChE,UAAA;AAAA,IAAA,gBAAAf,EAAC,OAAA,EAAI,OAAO,EAAE,UAAU,YAAY,OAAO,QAAQ,QAAQmB,EAAY,kBACpE,UAAAG,EAAa,IAAI,CAACQ,MACjB,gBAAA9B;AAAA,MAAC;AAAA,MAAA;AAAA,QAEC,cAAY8B,EAAE;AAAA,QACd,KAAKX,EAAY;AAAA,QACjB,WAAWS,EAAG,kBAAkBL,KAAW,wBAAwB;AAAA,QACnE,OAAO;AAAA,UACL,UAAU;AAAA,UACV,KAAK;AAAA,UACL,MAAM;AAAA,UACN,OAAO;AAAA,UACP,WAAW,cAAcO,EAAE,KAAK;AAAA,QAAA;AAAA,QAGjC,YAAW5B,EAAM4B,EAAE,KAAK,GAAGA,EAAE,KAAK;AAAA,MAAA;AAAA,MAZ9BA,EAAE;AAAA,IAAA,CAcV,GACH;AAAA,IACCrB,KAAWE;AAAA,EAAA,GACd;AAEJ;"}

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+export { useCopyToClipboard } from './use-copy-to-clipboard';
+export type { UseCopyOptions } from './use-copy-to-clipboard';
+export { useDebouncedValue } from './use-debounced-value';
+export type { UseDebouncedValueOptions } from './use-debounced-value';
+export { useInfiniteScroll, useIntersection } from './use-intersection';
+export type { UseInfiniteScrollOptions } from './use-intersection';
+export { useLocalStorage } from './use-local-storage';
+export { useLongPress } from './use-long-press';
+export type { LongPressPoint, UseLongPressOptions } from './use-long-press';
+export { useIsMobile, useIsTouch, useMediaQuery, usePrefersDark, usePrefersReducedMotion, } from './use-media-query';
+export { useEscape, useOutsideClick, useScrollLock } from './use-overlay';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACxE,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,EACL,WAAW,EACX,UAAU,EACV,aAAa,EACb,cAAc,EACd,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/hooks/use-copy-to-clipboard.d.ts

@@ -0,0 +1,26 @@
+export interface UseCopyOptions {
+    /** How long `copied` stays true, in ms. */
+    timeout?: number;
+    /**
+     * On touch devices, offer the native share sheet first (falls back to the
+     * clipboard when the user dismisses it, or when sharing is unavailable).
+     */
+    share?: boolean | {
+        title?: string;
+        text?: string;
+    };
+}
+/**
+ * Copy text to the clipboard and flag it for a moment, so a button can swap its
+ * icon to a check.
+ *
+ * Handles the two ways `navigator.clipboard` is unavailable — insecure origins
+ * and old WebViews — by falling back to a hidden `<textarea>` + `execCommand`,
+ * so it works over plain HTTP on the LAN too.
+ */
+export declare function useCopyToClipboard({ timeout, share }?: UseCopyOptions): {
+    copy: (text: string) => Promise<boolean>;
+    copied: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=use-copy-to-clipboard.d.ts.map

package/dist/hooks/use-copy-to-clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-to-clipboard.d.ts","sourceRoot":"","sources":["../../src/hooks/use-copy-to-clipboard.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,OAAc,EAAE,KAAa,EAAE,GAAE,cAAmB;iBAQxE,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;;;EA2BzC"}

package/dist/hooks/use-copy-to-clipboard.js

@@ -0,0 +1,36 @@
+import * as o from "react";
+function f({ timeout: r = 1500, share: e = !1 } = {}) {
+  const [t, a] = o.useState(!1), [s, c] = o.useState(null), n = o.useRef(void 0);
+  return o.useEffect(() => () => clearTimeout(n.current), []), { copy: o.useCallback(
+    async (i) => {
+      if (e && typeof navigator < "u" && navigator.share)
+        try {
+          const u = typeof e == "object" ? e : {};
+          return await navigator.share({ ...u, text: u.text ?? i }), !0;
+        } catch {
+        }
+      return await l(i) ? (c(null), a(!0), clearTimeout(n.current), n.current = setTimeout(() => a(!1), r), !0) : (c(new Error("clipboard unavailable")), !1);
+    },
+    [e, r]
+  ), copied: t, error: s };
+}
+async function l(r) {
+  var e;
+  try {
+    if ((e = navigator.clipboard) != null && e.writeText)
+      return await navigator.clipboard.writeText(r), !0;
+  } catch {
+  }
+  try {
+    const t = document.createElement("textarea");
+    t.value = r, t.setAttribute("readonly", ""), t.style.cssText = "position:fixed;top:0;left:-9999px;opacity:0", document.body.appendChild(t), t.select();
+    const a = document.execCommand("copy");
+    return t.remove(), a;
+  } catch {
+    return !1;
+  }
+}
+export {
+  f as useCopyToClipboard
+};
+//# sourceMappingURL=use-copy-to-clipboard.js.map

package/dist/hooks/use-copy-to-clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-to-clipboard.js","sources":["../../src/hooks/use-copy-to-clipboard.ts"],"sourcesContent":["import * as React from 'react';\n\nexport interface UseCopyOptions {\n  /** How long `copied` stays true, in ms. */\n  timeout?: number;\n  /**\n   * On touch devices, offer the native share sheet first (falls back to the\n   * clipboard when the user dismisses it, or when sharing is unavailable).\n   */\n  share?: boolean | { title?: string; text?: string };\n}\n\n/**\n * Copy text to the clipboard and flag it for a moment, so a button can swap its\n * icon to a check.\n *\n * Handles the two ways `navigator.clipboard` is unavailable — insecure origins\n * and old WebViews — by falling back to a hidden `<textarea>` + `execCommand`,\n * so it works over plain HTTP on the LAN too.\n */\nexport function useCopyToClipboard({ timeout = 1500, share = false }: UseCopyOptions = {}) {\n  const [copied, setCopied] = React.useState(false);\n  const [error, setError] = React.useState<Error | null>(null);\n  const timer = React.useRef<ReturnType<typeof setTimeout> | undefined>(undefined);\n\n  React.useEffect(() => () => clearTimeout(timer.current), []);\n\n  const copy = React.useCallback(\n    async (text: string): Promise<boolean> => {\n      if (share && typeof navigator !== 'undefined' && navigator.share) {\n        try {\n          const meta = typeof share === 'object' ? share : {};\n          await navigator.share({ ...meta, text: meta.text ?? text });\n          return true; // shared, not copied — no check mark to show\n        } catch {\n          /* dismissed or unsupported — fall through to the clipboard */\n        }\n      }\n\n      const ok = await writeClipboard(text);\n      if (!ok) {\n        setError(new Error('clipboard unavailable'));\n        return false;\n      }\n\n      setError(null);\n      setCopied(true);\n      clearTimeout(timer.current);\n      timer.current = setTimeout(() => setCopied(false), timeout);\n      return true;\n    },\n    [share, timeout],\n  );\n\n  return { copy, copied, error };\n}\n\nasync function writeClipboard(text: string): Promise<boolean> {\n  try {\n    if (navigator.clipboard?.writeText) {\n      await navigator.clipboard.writeText(text);\n      return true;\n    }\n  } catch {\n    /* blocked (insecure origin, permissions) — try the legacy path */\n  }\n\n  try {\n    const ta = document.createElement('textarea');\n    ta.value = text;\n    ta.setAttribute('readonly', '');\n    ta.style.cssText = 'position:fixed;top:0;left:-9999px;opacity:0';\n    document.body.appendChild(ta);\n    ta.select();\n    const ok = document.execCommand('copy');\n    ta.remove();\n    return ok;\n  } catch {\n    return false;\n  }\n}\n"],"names":["useCopyToClipboard","timeout","share","copied","setCopied","React","error","setError","timer","text","meta","writeClipboard","_a","ta","ok"],"mappings":";AAoBO,SAASA,EAAmB,EAAE,SAAAC,IAAU,MAAM,OAAAC,IAAQ,GAAA,IAA0B,IAAI;AACzF,QAAM,CAACC,GAAQC,CAAS,IAAIC,EAAM,SAAS,EAAK,GAC1C,CAACC,GAAOC,CAAQ,IAAIF,EAAM,SAAuB,IAAI,GACrDG,IAAQH,EAAM,OAAkD,MAAS;AAE/E,SAAAA,EAAM,UAAU,MAAM,MAAM,aAAaG,EAAM,OAAO,GAAG,EAAE,GA6BpD,EAAE,MA3BIH,EAAM;AAAA,IACjB,OAAOI,MAAmC;AACxC,UAAIP,KAAS,OAAO,YAAc,OAAe,UAAU;AACzD,YAAI;AACF,gBAAMQ,IAAO,OAAOR,KAAU,WAAWA,IAAQ,CAAA;AACjD,uBAAM,UAAU,MAAM,EAAE,GAAGQ,GAAM,MAAMA,EAAK,QAAQD,GAAM,GACnD;AAAA,QACT,QAAQ;AAAA,QAER;AAIF,aADW,MAAME,EAAeF,CAAI,KAMpCF,EAAS,IAAI,GACbH,EAAU,EAAI,GACd,aAAaI,EAAM,OAAO,GAC1BA,EAAM,UAAU,WAAW,MAAMJ,EAAU,EAAK,GAAGH,CAAO,GACnD,OARLM,EAAS,IAAI,MAAM,uBAAuB,CAAC,GACpC;AAAA,IAQX;AAAA,IACA,CAACL,GAAOD,CAAO;AAAA,EAAA,GAGF,QAAAE,GAAQ,OAAAG,EAAA;AACzB;AAEA,eAAeK,EAAeF,GAAgC;;AAC5D,MAAI;AACF,SAAIG,IAAA,UAAU,cAAV,QAAAA,EAAqB;AACvB,mBAAM,UAAU,UAAU,UAAUH,CAAI,GACjC;AAAA,EAEX,QAAQ;AAAA,EAER;AAEA,MAAI;AACF,UAAMI,IAAK,SAAS,cAAc,UAAU;AAC5C,IAAAA,EAAG,QAAQJ,GACXI,EAAG,aAAa,YAAY,EAAE,GAC9BA,EAAG,MAAM,UAAU,+CACnB,SAAS,KAAK,YAAYA,CAAE,GAC5BA,EAAG,OAAA;AACH,UAAMC,IAAK,SAAS,YAAY,MAAM;AACtC,WAAAD,EAAG,OAAA,GACIC;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;"}

package/dist/hooks/use-debounced-value.d.ts

@@ -0,0 +1,23 @@
+export interface UseDebouncedValueOptions {
+    /**
+     * Skip the delay when the value becomes "empty" (empty string / null /
+     * undefined / empty array), so clearing a search box repaints the full list
+     * immediately instead of after the debounce window. Default true.
+     */
+    leadingOnEmpty?: boolean;
+}
+/**
+ * Trail a fast-changing value (a search query, a slider) by `delay` ms so the
+ * expensive consumer downstream only sees it once the user pauses.
+ *
+ * Returns the debounced value plus `pending` — true while the live value has
+ * moved on but the debounced one hasn't caught up yet, which is what a search
+ * box hangs its spinner on.
+ *
+ * ```tsx
+ * const [debounced, pending] = useDebouncedValue(query, 400);
+ * const results = useMemo(() => search(debounced), [debounced]);
+ * ```
+ */
+export declare function useDebouncedValue<T>(value: T, delay?: number, { leadingOnEmpty }?: UseDebouncedValueOptions): [T, boolean];
+//# sourceMappingURL=use-debounced-value.d.ts.map

package/dist/hooks/use-debounced-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-value.d.ts","sourceRoot":"","sources":["../../src/hooks/use-debounced-value.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AASD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EACR,KAAK,SAAM,EACX,EAAE,cAAqB,EAAE,GAAE,wBAA6B,GACvD,CAAC,CAAC,EAAE,OAAO,CAAC,CAiBd"}

package/dist/hooks/use-debounced-value.js

@@ -0,0 +1,19 @@
+import { useState as c, useRef as i, useEffect as f } from "react";
+function m(t) {
+  return t == null ? !0 : typeof t == "string" ? t.trim() === "" : Array.isArray(t) ? t.length === 0 : !1;
+}
+function p(t, r = 400, { leadingOnEmpty: e = !0 } = {}) {
+  const [n, s] = c(t), o = i(t);
+  return o.current = t, f(() => {
+    if (r <= 0 || e && m(t)) {
+      s(t);
+      return;
+    }
+    const u = setTimeout(() => s(o.current), r);
+    return () => clearTimeout(u);
+  }, [t, r, e]), [n, !Object.is(n, t)];
+}
+export {
+  p as useDebouncedValue
+};
+//# sourceMappingURL=use-debounced-value.js.map

package/dist/hooks/use-debounced-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-value.js","sources":["../../src/hooks/use-debounced-value.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\n\nexport interface UseDebouncedValueOptions {\n  /**\n   * Skip the delay when the value becomes \"empty\" (empty string / null /\n   * undefined / empty array), so clearing a search box repaints the full list\n   * immediately instead of after the debounce window. Default true.\n   */\n  leadingOnEmpty?: boolean;\n}\n\nfunction isEmpty(value: unknown): boolean {\n  if (value == null) return true;\n  if (typeof value === 'string') return value.trim() === '';\n  if (Array.isArray(value)) return value.length === 0;\n  return false;\n}\n\n/**\n * Trail a fast-changing value (a search query, a slider) by `delay` ms so the\n * expensive consumer downstream only sees it once the user pauses.\n *\n * Returns the debounced value plus `pending` — true while the live value has\n * moved on but the debounced one hasn't caught up yet, which is what a search\n * box hangs its spinner on.\n *\n * ```tsx\n * const [debounced, pending] = useDebouncedValue(query, 400);\n * const results = useMemo(() => search(debounced), [debounced]);\n * ```\n */\nexport function useDebouncedValue<T>(\n  value: T,\n  delay = 400,\n  { leadingOnEmpty = true }: UseDebouncedValueOptions = {},\n): [T, boolean] {\n  const [debounced, setDebounced] = useState(value);\n  // Keep the latest value in a ref so the flush on unmount/delay-change can't\n  // resurrect a stale one.\n  const latest = useRef(value);\n  latest.current = value;\n\n  useEffect(() => {\n    if (delay <= 0 || (leadingOnEmpty && isEmpty(value))) {\n      setDebounced(value);\n      return;\n    }\n    const t = setTimeout(() => setDebounced(latest.current), delay);\n    return () => clearTimeout(t);\n  }, [value, delay, leadingOnEmpty]);\n\n  return [debounced, !Object.is(debounced, value)];\n}\n"],"names":["isEmpty","value","useDebouncedValue","delay","leadingOnEmpty","debounced","setDebounced","useState","latest","useRef","useEffect","t"],"mappings":";AAWA,SAASA,EAAQC,GAAyB;AACxC,SAAIA,KAAS,OAAa,KACtB,OAAOA,KAAU,WAAiBA,EAAM,WAAW,KACnD,MAAM,QAAQA,CAAK,IAAUA,EAAM,WAAW,IAC3C;AACT;AAeO,SAASC,EACdD,GACAE,IAAQ,KACR,EAAE,gBAAAC,IAAiB,GAAA,IAAmC,IACxC;AACd,QAAM,CAACC,GAAWC,CAAY,IAAIC,EAASN,CAAK,GAG1CO,IAASC,EAAOR,CAAK;AAC3B,SAAAO,EAAO,UAAUP,GAEjBS,EAAU,MAAM;AACd,QAAIP,KAAS,KAAMC,KAAkBJ,EAAQC,CAAK,GAAI;AACpD,MAAAK,EAAaL,CAAK;AAClB;AAAA,IACF;AACA,UAAMU,IAAI,WAAW,MAAML,EAAaE,EAAO,OAAO,GAAGL,CAAK;AAC9D,WAAO,MAAM,aAAaQ,CAAC;AAAA,EAC7B,GAAG,CAACV,GAAOE,GAAOC,CAAc,CAAC,GAE1B,CAACC,GAAW,CAAC,OAAO,GAAGA,GAAWJ,CAAK,CAAC;AACjD;"}

package/dist/hooks/use-intersection.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+/**
+ * Fire `onIntersect` while a sentinel element is (near) the viewport.
+ *
+ * The paged-reveal counterpart to `VirtualList`'s `onEndReached`: put the
+ * returned ref on a div at the bottom of a plain grid and it loads the next
+ * page before the user reaches it (`rootMargin` looks ahead by default).
+ */
+export declare function useIntersection<T extends HTMLElement = HTMLDivElement>(onIntersect: () => void, { enabled, rootMargin, threshold, }?: {
+    enabled?: boolean;
+    rootMargin?: string;
+    threshold?: number;
+}): React.RefObject<T | null>;
+export interface UseInfiniteScrollOptions {
+    hasMore: boolean;
+    loading?: boolean;
+    onLoadMore: () => void;
+    rootMargin?: string;
+}
+/**
+ * `useIntersection` wired for pagination: it stops observing once there is
+ * nothing more to load, and never re-enters while a page is in flight.
+ */
+export declare function useInfiniteScroll<T extends HTMLElement = HTMLDivElement>({ hasMore, loading, onLoadMore, rootMargin, }: UseInfiniteScrollOptions): React.RefObject<T | null>;
+//# sourceMappingURL=use-intersection.d.ts.map

package/dist/hooks/use-intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-intersection.d.ts","sourceRoot":"","sources":["../../src/hooks/use-intersection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,WAAW,GAAG,cAAc,EACpE,WAAW,EAAE,MAAM,IAAI,EACvB,EACE,OAAc,EACd,UAAoB,EACpB,SAAa,GACd,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,6BAoBvE;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,WAAW,GAAG,cAAc,EAAE,EACxE,OAAO,EACP,OAAe,EACf,UAAU,EACV,UAAU,GACX,EAAE,wBAAwB,6BAO1B"}

package/dist/hooks/use-intersection.js

@@ -0,0 +1,38 @@
+import * as c from "react";
+function l(e, {
+  enabled: n = !0,
+  rootMargin: t = "600px",
+  threshold: r = 0
+} = {}) {
+  const s = c.useRef(null), u = c.useRef(e);
+  return u.current = e, c.useEffect(() => {
+    const f = s.current;
+    if (!f || !n || typeof IntersectionObserver > "u") return;
+    const i = new IntersectionObserver(
+      (b) => {
+        var o;
+        (o = b[0]) != null && o.isIntersecting && u.current();
+      },
+      { rootMargin: t, threshold: r }
+    );
+    return i.observe(f), () => i.disconnect();
+  }, [n, t, r]), s;
+}
+function p({
+  hasMore: e,
+  loading: n = !1,
+  onLoadMore: t,
+  rootMargin: r
+}) {
+  return l(
+    () => {
+      e && !n && t();
+    },
+    { enabled: e && !n, rootMargin: r }
+  );
+}
+export {
+  p as useInfiniteScroll,
+  l as useIntersection
+};
+//# sourceMappingURL=use-intersection.js.map

package/dist/hooks/use-intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-intersection.js","sources":["../../src/hooks/use-intersection.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * Fire `onIntersect` while a sentinel element is (near) the viewport.\n *\n * The paged-reveal counterpart to `VirtualList`'s `onEndReached`: put the\n * returned ref on a div at the bottom of a plain grid and it loads the next\n * page before the user reaches it (`rootMargin` looks ahead by default).\n */\nexport function useIntersection<T extends HTMLElement = HTMLDivElement>(\n  onIntersect: () => void,\n  {\n    enabled = true,\n    rootMargin = '600px',\n    threshold = 0,\n  }: { enabled?: boolean; rootMargin?: string; threshold?: number } = {},\n) {\n  const ref = React.useRef<T | null>(null);\n  const cb = React.useRef(onIntersect);\n  cb.current = onIntersect;\n\n  React.useEffect(() => {\n    const el = ref.current;\n    if (!el || !enabled || typeof IntersectionObserver === 'undefined') return;\n    const io = new IntersectionObserver(\n      (entries) => {\n        if (entries[0]?.isIntersecting) cb.current();\n      },\n      { rootMargin, threshold },\n    );\n    io.observe(el);\n    return () => io.disconnect();\n  }, [enabled, rootMargin, threshold]);\n\n  return ref;\n}\n\nexport interface UseInfiniteScrollOptions {\n  hasMore: boolean;\n  loading?: boolean;\n  onLoadMore: () => void;\n  rootMargin?: string;\n}\n\n/**\n * `useIntersection` wired for pagination: it stops observing once there is\n * nothing more to load, and never re-enters while a page is in flight.\n */\nexport function useInfiniteScroll<T extends HTMLElement = HTMLDivElement>({\n  hasMore,\n  loading = false,\n  onLoadMore,\n  rootMargin,\n}: UseInfiniteScrollOptions) {\n  return useIntersection<T>(\n    () => {\n      if (hasMore && !loading) onLoadMore();\n    },\n    { enabled: hasMore && !loading, rootMargin },\n  );\n}\n"],"names":["useIntersection","onIntersect","enabled","rootMargin","threshold","ref","React","cb","el","io","entries","_a","useInfiniteScroll","hasMore","loading","onLoadMore"],"mappings":";AASO,SAASA,EACdC,GACA;AAAA,EACE,SAAAC,IAAU;AAAA,EACV,YAAAC,IAAa;AAAA,EACb,WAAAC,IAAY;AACd,IAAoE,IACpE;AACA,QAAMC,IAAMC,EAAM,OAAiB,IAAI,GACjCC,IAAKD,EAAM,OAAOL,CAAW;AACnC,SAAAM,EAAG,UAAUN,GAEbK,EAAM,UAAU,MAAM;AACpB,UAAME,IAAKH,EAAI;AACf,QAAI,CAACG,KAAM,CAACN,KAAW,OAAO,uBAAyB,IAAa;AACpE,UAAMO,IAAK,IAAI;AAAA,MACb,CAACC,MAAY;;AACX,SAAIC,IAAAD,EAAQ,CAAC,MAAT,QAAAC,EAAY,oBAAmB,QAAA;AAAA,MACrC;AAAA,MACA,EAAE,YAAAR,GAAY,WAAAC,EAAA;AAAA,IAAU;AAE1B,WAAAK,EAAG,QAAQD,CAAE,GACN,MAAMC,EAAG,WAAA;AAAA,EAClB,GAAG,CAACP,GAASC,GAAYC,CAAS,CAAC,GAE5BC;AACT;AAaO,SAASO,EAA0D;AAAA,EACxE,SAAAC;AAAA,EACA,SAAAC,IAAU;AAAA,EACV,YAAAC;AAAA,EACA,YAAAZ;AACF,GAA6B;AAC3B,SAAOH;AAAA,IACL,MAAM;AACJ,MAAIa,KAAW,CAACC,KAASC,EAAA;AAAA,IAC3B;AAAA,IACA,EAAE,SAASF,KAAW,CAACC,GAAS,YAAAX,EAAA;AAAA,EAAW;AAE/C;"}

package/dist/hooks/use-local-storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `useState` backed by `localStorage` (or `sessionStorage`).
+ *
+ * Reads once on mount, writes on every change, and swallows quota/private-mode
+ * errors so a full disk can never crash the app. Tabs stay in sync: a `storage`
+ * event from another tab, or a write from another hook instance on the same
+ * key, updates every subscriber.
+ */
+export declare function useLocalStorage<T>(key: string, initial: T, { session }?: {
+    session?: boolean;
+}): [T, (value: T | ((prev: T) => T)) => void];
+//# sourceMappingURL=use-local-storage.d.ts.map

package/dist/hooks/use-local-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-local-storage.d.ts","sourceRoot":"","sources":["../../src/hooks/use-local-storage.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,EACV,EAAE,OAAe,EAAE,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9C,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC,CAkD5C"}

package/dist/hooks/use-local-storage.js

@@ -0,0 +1,43 @@
+import * as s from "react";
+function v(e, i, { session: c = !1 } = {}) {
+  const l = () => typeof window > "u" ? null : c ? window.sessionStorage : window.localStorage, r = s.useCallback(() => {
+    var t;
+    try {
+      const n = (t = l()) == null ? void 0 : t.getItem(e);
+      return n == null ? i : JSON.parse(n);
+    } catch {
+      return i;
+    }
+  }, [e, c]), [w, a] = s.useState(r);
+  s.useEffect(() => {
+    a(r());
+    const t = (o) => {
+      (o.key === e || o.key === null) && a(r());
+    }, n = (o) => {
+      o.detail === e && a(r());
+    };
+    return window.addEventListener("storage", t), window.addEventListener(d, n), () => {
+      window.removeEventListener("storage", t), window.removeEventListener(d, n);
+    };
+  }, [e, r]);
+  const f = s.useCallback(
+    (t) => {
+      a((n) => {
+        var u;
+        const o = typeof t == "function" ? t(n) : t;
+        try {
+          (u = l()) == null || u.setItem(e, JSON.stringify(o)), window.dispatchEvent(new CustomEvent(d, { detail: e }));
+        } catch {
+        }
+        return o;
+      });
+    },
+    [e, c]
+  );
+  return [w, f];
+}
+const d = "gabvdl-ui:storage";
+export {
+  v as useLocalStorage
+};
+//# sourceMappingURL=use-local-storage.js.map

package/dist/hooks/use-local-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-local-storage.js","sources":["../../src/hooks/use-local-storage.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * `useState` backed by `localStorage` (or `sessionStorage`).\n *\n * Reads once on mount, writes on every change, and swallows quota/private-mode\n * errors so a full disk can never crash the app. Tabs stay in sync: a `storage`\n * event from another tab, or a write from another hook instance on the same\n * key, updates every subscriber.\n */\nexport function useLocalStorage<T>(\n  key: string,\n  initial: T,\n  { session = false }: { session?: boolean } = {},\n): [T, (value: T | ((prev: T) => T)) => void] {\n  const store = () =>\n    typeof window === 'undefined' ? null : session ? window.sessionStorage : window.localStorage;\n\n  const read = React.useCallback((): T => {\n    try {\n      const raw = store()?.getItem(key);\n      return raw == null ? initial : (JSON.parse(raw) as T);\n    } catch {\n      return initial;\n    }\n    // `initial` is intentionally not a dep: it is the mount-time default only.\n  }, [key, session]);\n\n  const [value, setValue] = React.useState<T>(read);\n\n  // A key change (or a cross-tab write) re-reads from storage.\n  React.useEffect(() => {\n    setValue(read());\n    const onStorage = (e: StorageEvent) => {\n      if (e.key === key || e.key === null) setValue(read());\n    };\n    const onLocal = (e: Event) => {\n      if ((e as CustomEvent<string>).detail === key) setValue(read());\n    };\n    window.addEventListener('storage', onStorage);\n    window.addEventListener(SYNC_EVENT, onLocal);\n    return () => {\n      window.removeEventListener('storage', onStorage);\n      window.removeEventListener(SYNC_EVENT, onLocal);\n    };\n  }, [key, read]);\n\n  const set = React.useCallback(\n    (next: T | ((prev: T) => T)) => {\n      setValue((prev) => {\n        const resolved = typeof next === 'function' ? (next as (p: T) => T)(prev) : next;\n        try {\n          store()?.setItem(key, JSON.stringify(resolved));\n          window.dispatchEvent(new CustomEvent(SYNC_EVENT, { detail: key }));\n        } catch {\n          /* quota exceeded / storage disabled — keep the in-memory value */\n        }\n        return resolved;\n      });\n    },\n    [key, session],\n  );\n\n  return [value, set];\n}\n\nconst SYNC_EVENT = 'gabvdl-ui:storage';\n"],"names":["useLocalStorage","key","initial","session","store","read","React","raw","_a","value","setValue","onStorage","e","onLocal","SYNC_EVENT","set","next","prev","resolved"],"mappings":";AAUO,SAASA,EACdC,GACAC,GACA,EAAE,SAAAC,IAAU,GAAA,IAAiC,IACD;AAC5C,QAAMC,IAAQ,MACZ,OAAO,SAAW,MAAc,OAAOD,IAAU,OAAO,iBAAiB,OAAO,cAE5EE,IAAOC,EAAM,YAAY,MAAS;;AACtC,QAAI;AACF,YAAMC,KAAMC,IAAAJ,QAAA,gBAAAI,EAAS,QAAQP;AAC7B,aAAOM,KAAO,OAAOL,IAAW,KAAK,MAAMK,CAAG;AAAA,IAChD,QAAQ;AACN,aAAOL;AAAA,IACT;AAAA,EAEF,GAAG,CAACD,GAAKE,CAAO,CAAC,GAEX,CAACM,GAAOC,CAAQ,IAAIJ,EAAM,SAAYD,CAAI;AAGhD,EAAAC,EAAM,UAAU,MAAM;AACpB,IAAAI,EAASL,GAAM;AACf,UAAMM,IAAY,CAACC,MAAoB;AACrC,OAAIA,EAAE,QAAQX,KAAOW,EAAE,QAAQ,SAAMF,EAASL,GAAM;AAAA,IACtD,GACMQ,IAAU,CAACD,MAAa;AAC5B,MAAKA,EAA0B,WAAWX,KAAKS,EAASL,GAAM;AAAA,IAChE;AACA,kBAAO,iBAAiB,WAAWM,CAAS,GAC5C,OAAO,iBAAiBG,GAAYD,CAAO,GACpC,MAAM;AACX,aAAO,oBAAoB,WAAWF,CAAS,GAC/C,OAAO,oBAAoBG,GAAYD,CAAO;AAAA,IAChD;AAAA,EACF,GAAG,CAACZ,GAAKI,CAAI,CAAC;AAEd,QAAMU,IAAMT,EAAM;AAAA,IAChB,CAACU,MAA+B;AAC9B,MAAAN,EAAS,CAACO,MAAS;;AACjB,cAAMC,IAAW,OAAOF,KAAS,aAAcA,EAAqBC,CAAI,IAAID;AAC5E,YAAI;AACF,WAAAR,IAAAJ,EAAA,MAAA,QAAAI,EAAS,QAAQP,GAAK,KAAK,UAAUiB,CAAQ,IAC7C,OAAO,cAAc,IAAI,YAAYJ,GAAY,EAAE,QAAQb,EAAA,CAAK,CAAC;AAAA,QACnE,QAAQ;AAAA,QAER;AACA,eAAOiB;AAAA,MACT,CAAC;AAAA,IACH;AAAA,IACA,CAACjB,GAAKE,CAAO;AAAA,EAAA;AAGf,SAAO,CAACM,GAAOM,CAAG;AACpB;AAEA,MAAMD,IAAa;"}

package/dist/hooks/use-long-press.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+export interface LongPressPoint {
+    x: number;
+    y: number;
+}
+export interface UseLongPressOptions {
+    /** Hold duration before it fires, in ms. */
+    delay?: number;
+    /** Movement (px) that cancels the press — a scroll, not a hold. */
+    moveTolerance?: number;
+    /** Also fire on a desktop right-click (contextmenu). Default true. */
+    contextMenu?: boolean;
+    /** Fired on a plain tap/click that never became a long press. */
+    onClick?: (e: React.MouseEvent) => void;
+}
+/**
+ * Long-press (and right-click) as a gesture, with the press coordinates — so a
+ * context menu can be anchored where the finger actually landed.
+ *
+ * Spread the returned props onto any element. After the gesture fires, the
+ * ensuing `click` is swallowed once: without that, a long press on a link both
+ * opens the menu and follows the link.
+ */
+export declare function useLongPress(onLongPress: (point: LongPressPoint) => void, { delay, moveTolerance, contextMenu, onClick }?: UseLongPressOptions): {
+    onPointerDown: (e: React.PointerEvent) => void;
+    onPointerMove: (e: React.PointerEvent) => void;
+    onPointerUp: () => void;
+    onPointerLeave: () => void;
+    onPointerCancel: () => void;
+    onContextMenu: (e: React.MouseEvent) => void;
+    onClick: (e: React.MouseEvent) => void;
+    style: {
+        WebkitTouchCallout: "none";
+        touchAction: "manipulation";
+    };
+};
+//# sourceMappingURL=use-long-press.d.ts.map

package/dist/hooks/use-long-press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-long-press.d.ts","sourceRoot":"","sources":["../../src/hooks/use-long-press.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,mBAAmB;IAClC,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sEAAsE;IACtE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iEAAiE;IACjE,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,EAC5C,EAAE,KAAW,EAAE,aAAkB,EAAE,WAAkB,EAAE,OAAO,EAAE,GAAE,mBAAwB;uBAyBrE,KAAK,CAAC,YAAY;uBAIlB,KAAK,CAAC,YAAY;;;;uBAQlB,KAAK,CAAC,UAAU;iBAOtB,KAAK,CAAC,UAAU;;;;;EAYhC"}

package/dist/hooks/use-long-press.js

@@ -0,0 +1,39 @@
+import * as r from "react";
+function m(l, { delay: a = 450, moveTolerance: s = 10, contextMenu: f = !0, onClick: o } = {}) {
+  const c = r.useRef(void 0), u = r.useRef(null), n = r.useRef(!1), e = r.useCallback(() => {
+    clearTimeout(c.current), u.current = null;
+  }, []);
+  r.useEffect(() => e, [e]);
+  const p = (t) => {
+    n.current = !1, u.current = t, clearTimeout(c.current), c.current = setTimeout(() => {
+      n.current = !0, u.current = null, l(t);
+    }, a);
+  };
+  return {
+    onPointerDown: (t) => {
+      t.pointerType === "mouse" && t.button !== 0 || p({ x: t.clientX, y: t.clientY });
+    },
+    onPointerMove: (t) => {
+      const i = u.current;
+      i && Math.hypot(t.clientX - i.x, t.clientY - i.y) > s && e();
+    },
+    onPointerUp: e,
+    onPointerLeave: e,
+    onPointerCancel: e,
+    onContextMenu: (t) => {
+      f && (t.preventDefault(), e(), n.current = !0, l({ x: t.clientX, y: t.clientY }));
+    },
+    onClick: (t) => {
+      if (n.current) {
+        t.preventDefault(), t.stopPropagation(), n.current = !1;
+        return;
+      }
+      o == null || o(t);
+    },
+    style: { WebkitTouchCallout: "none", touchAction: "manipulation" }
+  };
+}
+export {
+  m as useLongPress
+};
+//# sourceMappingURL=use-long-press.js.map

package/dist/hooks/use-long-press.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-long-press.js","sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import * as React from 'react';\n\nexport interface LongPressPoint {\n  x: number;\n  y: number;\n}\n\nexport interface UseLongPressOptions {\n  /** Hold duration before it fires, in ms. */\n  delay?: number;\n  /** Movement (px) that cancels the press — a scroll, not a hold. */\n  moveTolerance?: number;\n  /** Also fire on a desktop right-click (contextmenu). Default true. */\n  contextMenu?: boolean;\n  /** Fired on a plain tap/click that never became a long press. */\n  onClick?: (e: React.MouseEvent) => void;\n}\n\n/**\n * Long-press (and right-click) as a gesture, with the press coordinates — so a\n * context menu can be anchored where the finger actually landed.\n *\n * Spread the returned props onto any element. After the gesture fires, the\n * ensuing `click` is swallowed once: without that, a long press on a link both\n * opens the menu and follows the link.\n */\nexport function useLongPress(\n  onLongPress: (point: LongPressPoint) => void,\n  { delay = 450, moveTolerance = 10, contextMenu = true, onClick }: UseLongPressOptions = {},\n) {\n  const timer = React.useRef<ReturnType<typeof setTimeout> | undefined>(undefined);\n  const start = React.useRef<LongPressPoint | null>(null);\n  const fired = React.useRef(false);\n\n  const cancel = React.useCallback(() => {\n    clearTimeout(timer.current);\n    start.current = null;\n  }, []);\n\n  React.useEffect(() => cancel, [cancel]);\n\n  const begin = (point: LongPressPoint) => {\n    fired.current = false;\n    start.current = point;\n    clearTimeout(timer.current);\n    timer.current = setTimeout(() => {\n      fired.current = true;\n      start.current = null;\n      onLongPress(point);\n    }, delay);\n  };\n\n  return {\n    onPointerDown: (e: React.PointerEvent) => {\n      if (e.pointerType === 'mouse' && e.button !== 0) return; // right-click has its own path\n      begin({ x: e.clientX, y: e.clientY });\n    },\n    onPointerMove: (e: React.PointerEvent) => {\n      const from = start.current;\n      if (!from) return;\n      if (Math.hypot(e.clientX - from.x, e.clientY - from.y) > moveTolerance) cancel();\n    },\n    onPointerUp: cancel,\n    onPointerLeave: cancel,\n    onPointerCancel: cancel,\n    onContextMenu: (e: React.MouseEvent) => {\n      if (!contextMenu) return;\n      e.preventDefault();\n      cancel();\n      fired.current = true;\n      onLongPress({ x: e.clientX, y: e.clientY });\n    },\n    onClick: (e: React.MouseEvent) => {\n      if (fired.current) {\n        // The gesture already handled this press — don't also navigate.\n        e.preventDefault();\n        e.stopPropagation();\n        fired.current = false;\n        return;\n      }\n      onClick?.(e);\n    },\n    style: { WebkitTouchCallout: 'none' as const, touchAction: 'manipulation' as const },\n  };\n}\n"],"names":["useLongPress","onLongPress","delay","moveTolerance","contextMenu","onClick","timer","React","start","fired","cancel","begin","point","e","from"],"mappings":";AA0BO,SAASA,EACdC,GACA,EAAE,OAAAC,IAAQ,KAAK,eAAAC,IAAgB,IAAI,aAAAC,IAAc,IAAM,SAAAC,EAAA,IAAiC,CAAA,GACxF;AACA,QAAMC,IAAQC,EAAM,OAAkD,MAAS,GACzEC,IAAQD,EAAM,OAA8B,IAAI,GAChDE,IAAQF,EAAM,OAAO,EAAK,GAE1BG,IAASH,EAAM,YAAY,MAAM;AACrC,iBAAaD,EAAM,OAAO,GAC1BE,EAAM,UAAU;AAAA,EAClB,GAAG,CAAA,CAAE;AAEL,EAAAD,EAAM,UAAU,MAAMG,GAAQ,CAACA,CAAM,CAAC;AAEtC,QAAMC,IAAQ,CAACC,MAA0B;AACvC,IAAAH,EAAM,UAAU,IAChBD,EAAM,UAAUI,GAChB,aAAaN,EAAM,OAAO,GAC1BA,EAAM,UAAU,WAAW,MAAM;AAC/B,MAAAG,EAAM,UAAU,IAChBD,EAAM,UAAU,MAChBP,EAAYW,CAAK;AAAA,IACnB,GAAGV,CAAK;AAAA,EACV;AAEA,SAAO;AAAA,IACL,eAAe,CAACW,MAA0B;AACxC,MAAIA,EAAE,gBAAgB,WAAWA,EAAE,WAAW,KAC9CF,EAAM,EAAE,GAAGE,EAAE,SAAS,GAAGA,EAAE,SAAS;AAAA,IACtC;AAAA,IACA,eAAe,CAACA,MAA0B;AACxC,YAAMC,IAAON,EAAM;AACnB,MAAKM,KACD,KAAK,MAAMD,EAAE,UAAUC,EAAK,GAAGD,EAAE,UAAUC,EAAK,CAAC,IAAIX,KAAeO,EAAA;AAAA,IAC1E;AAAA,IACA,aAAaA;AAAA,IACb,gBAAgBA;AAAA,IAChB,iBAAiBA;AAAA,IACjB,eAAe,CAACG,MAAwB;AACtC,MAAKT,MACLS,EAAE,eAAA,GACFH,EAAA,GACAD,EAAM,UAAU,IAChBR,EAAY,EAAE,GAAGY,EAAE,SAAS,GAAGA,EAAE,SAAS;AAAA,IAC5C;AAAA,IACA,SAAS,CAACA,MAAwB;AAChC,UAAIJ,EAAM,SAAS;AAEjB,QAAAI,EAAE,eAAA,GACFA,EAAE,gBAAA,GACFJ,EAAM,UAAU;AAChB;AAAA,MACF;AACA,MAAAJ,KAAA,QAAAA,EAAUQ;AAAA,IACZ;AAAA,IACA,OAAO,EAAE,oBAAoB,QAAiB,aAAa,eAAA;AAAA,EAAwB;AAEvF;"}

package/dist/hooks/use-media-query.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Subscribe to a CSS media query.
+ *
+ * SSR-safe (`false` on the server, resolved on hydration) and driven by
+ * `useSyncExternalStore`, so several components watching the same query share
+ * one listener and never tear.
+ */
+export declare function useMediaQuery(query: string): boolean;
+/** True below the `md` breakpoint (768px) — the phone/desktop split. */
+export declare function useIsMobile(breakpoint?: number): boolean;
+/** True on a coarse pointer (finger) — use for tap targets, not for width. */
+export declare function useIsTouch(): boolean;
+/** The OS colour-scheme preference. See `useTheme` for the resolved theme. */
+export declare function usePrefersDark(): boolean;
+/** True when the user asked for less motion — gate animations on it. */
+export declare function usePrefersReducedMotion(): boolean;
+//# sourceMappingURL=use-media-query.d.ts.map