@leavepulse/ui 0.93.3 → 0.94.1

package/dist/composables/gesture.d.ts

@@ -0,0 +1,141 @@
+import type { Direction } from "./spatialNav";
+export interface GesturePoint {
+    x: number;
+    y: number;
+}
+export type GestureAxis = "x" | "y";
+/** How far a touch may drift before a press stops being a tap or a hold. */
+export declare const TOUCH_SLOP = 8;
+/** A mouse is steadier: a press that moves this far is a drag. */
+export declare const MOUSE_SLOP = 4;
+/** Px/ms at release past which a short swipe still counts (a flick). */
+export declare const FLICK_VELOCITY = 0.45;
+/** How long a finger holds still before it drags (selects, paints) rather than scrolls the page. */
+export declare const HOLD_TO_DRAG_MS = 320;
+/** How long a press must stay for a long press, in ms. */
+export declare const LONG_PRESS_MS = 500;
+/** The slop for a pointer type: a finger gets more room than a mouse. */
+export declare function slopFor(pointerType: string): number;
+export interface VelocityTracker {
+    /** Record where the pointer is at `time` (ms, an event's timeStamp). */
+    add: (point: GesturePoint, time: number) => void;
+    /** Px/ms over the last moments, zero when the pointer rested before `now`. */
+    velocity: (now?: number) => GesturePoint;
+    reset: () => void;
+}
+/**
+ * Velocity from the samples in the last VELOCITY_WINDOW_MS rather than from
+ * the last two events: a jittery final frame (two events a millisecond apart)
+ * would otherwise decide how far a flick travels.
+ */
+export declare function createVelocityTracker(): VelocityTracker;
+/**
+ * Which axis a movement has committed to, or null while it is still inside
+ * the slop or too diagonal to call. `ratio` is how much the winning axis must
+ * lead by: 1 takes any lead, higher waits for a clearer one.
+ */
+export declare function lockAxis(movement: GesturePoint, slop: number, ratio?: number): GestureAxis | null;
+export interface SwipeOptions {
+    /** Distance in px that is a swipe at any speed. Default 60. */
+    distance?: number;
+    /** Px/ms that turns a shorter move into a swipe. Default FLICK_VELOCITY. */
+    velocity?: number;
+    /** A flick must still travel this far, so a twitch is not one. Default 16. */
+    minDistance?: number;
+    /** Only these axes count. Default both. */
+    axis?: GestureAxis;
+    /** How much the swipe's axis must lead the other. Default 1.5. */
+    ratio?: number;
+}
+/** Which way a released movement swiped, or null when it was not a swipe. */
+export declare function swipeDirection(movement: GesturePoint, velocity: GesturePoint, options?: SwipeOptions): Direction | null;
+/**
+ * How far an edge moves when pulled `overshoot` px past it: the further the
+ * pull, the less each pixel gives, approaching `size` and never passing it.
+ * The sign follows the overshoot. `c` is the stiffness, iOS uses 0.55.
+ */
+export declare function rubberBand(overshoot: number, size: number, c?: number): number;
+/** Clamp `value` into [min, max], letting it stretch past either end by rubberBand. */
+export declare function rubberClamp(value: number, min: number, max: number, size: number, c?: number): number;
+export interface DismissOptions {
+    /** Offset toward the dismissing side, in px (positive is toward it). */
+    offset: number;
+    /** Velocity toward the dismissing side, px/ms. */
+    velocity: number;
+    /** The size of what is being swiped away along the swipe, in px. */
+    size: number;
+    /** Fraction of `size` past which a slow release dismisses. Default 0.5. */
+    ratio?: number;
+    /** Px/ms past which a release dismisses from any distance. Default FLICK_VELOCITY. */
+    flick?: number;
+}
+/** Swipe to dismiss: whether a release should carry it away or let it spring back. */
+export declare function shouldDismiss({ offset, velocity, size, ratio, flick }: DismissOptions): boolean;
+export interface PageSwipeOptions {
+    index: number;
+    count: number;
+    /** Drag offset along the strip in px, positive toward the previous item. */
+    offset: number;
+    /** Velocity in px/ms, same sign as `offset`. */
+    velocity: number;
+    /** Width of one item in px. */
+    size: number;
+    /** Fraction of `size` that pages at any speed. Default 0.25. */
+    ratio?: number;
+    flick?: number;
+    /** Wrap past the ends instead of stopping. */
+    loop?: boolean;
+}
+/** Swipe between items: the index a release lands on, one step at most. */
+export declare function pageAfterSwipe({ index, count, offset, velocity, size, ratio, flick, loop }: PageSwipeOptions): number;
+/** Where a fling at `velocity` px/ms comes to rest with exponential friction of time constant `tau` ms. */
+export declare function momentumDistance(velocity: number, tau?: number): number;
+export interface PinchFrame {
+    /** Distance between the two pointers now, over the distance at the start. */
+    scale: number;
+    /** Midpoint of the two pointers. */
+    origin: GesturePoint;
+    distance: number;
+}
+export declare function distance(a: GesturePoint, b: GesturePoint): number;
+export declare function midpoint(a: GesturePoint, b: GesturePoint): GesturePoint;
+/** The pinch between two pointers, measured against the distance it started at. */
+export declare function pinchFrame(a: GesturePoint, b: GesturePoint, startDistance: number): PinchFrame;
+/** The wheel's delta in pixels, whatever unit the device reported it in. */
+export declare function wheelPixels(delta: number, mode: number, page: number): number;
+export interface DragSessionOptions {
+    /** Px of travel before a press becomes a drag. */
+    slop: number;
+    /** Only a drag along this axis counts; one along the other is rejected. `lock` takes whichever comes first. */
+    axis?: GestureAxis | "lock";
+}
+export interface DragFrame {
+    /** `pending` inside the slop, `drag` once committed, `rejected` when it went the other way. */
+    phase: "pending" | "drag" | "rejected";
+    /** True on the frame the drag committed. */
+    first: boolean;
+    start: GesturePoint;
+    point: GesturePoint;
+    movement: GesturePoint;
+    delta: GesturePoint;
+    velocity: GesturePoint;
+    axis: GestureAxis | null;
+    elapsed: number;
+}
+export interface DragSession {
+    readonly phase: DragFrame["phase"];
+    /** Feed the pointer's position; returns where the gesture stands. */
+    move: (point: GesturePoint, time: number) => DragFrame;
+    /** The final frame at release, with the swipe it made (if it was a drag). */
+    end: (point: GesturePoint, time: number, swipe?: SwipeOptions) => DragFrame & {
+        swipe: Direction | null;
+    };
+}
+/**
+ * One press followed from down to up, whatever events carry it: useGesture
+ * feeds it pointer events, a pull from the screen edge feeds it touches. It
+ * decides when the press becomes a drag, along which axis, how fast it moves
+ * and whether the release was a swipe, so every gesture in the kit draws the
+ * line in the same place.
+ */
+export declare function createDragSession(start: GesturePoint, time: number, options: DragSessionOptions): DragSession;

package/dist/composables/gesture.js

@@ -0,0 +1,176 @@
+import { clamp } from "./clamp.js";
+const TOUCH_SLOP = 8;
+const MOUSE_SLOP = 4;
+const FLICK_VELOCITY = 0.45;
+const HOLD_TO_DRAG_MS = 320;
+const LONG_PRESS_MS = 500;
+const VELOCITY_WINDOW_MS = 100;
+const REST_MS = 90;
+function slopFor(pointerType) {
+  return pointerType === "mouse" ? MOUSE_SLOP : TOUCH_SLOP;
+}
+function createVelocityTracker() {
+  let samples = [];
+  return {
+    add(point, time) {
+      samples.push({ x: point.x, y: point.y, t: time });
+      const cut = time - VELOCITY_WINDOW_MS;
+      while (samples.length > 2 && samples[0].t < cut) samples.shift();
+    },
+    velocity(now) {
+      if (samples.length < 2) return { x: 0, y: 0 };
+      const last = samples[samples.length - 1];
+      if (now !== void 0 && now - last.t > REST_MS) return { x: 0, y: 0 };
+      const first = samples[0];
+      const dt = last.t - first.t;
+      if (dt <= 0) return { x: 0, y: 0 };
+      return { x: (last.x - first.x) / dt, y: (last.y - first.y) / dt };
+    },
+    reset() {
+      samples = [];
+    }
+  };
+}
+function lockAxis(movement, slop, ratio = 1) {
+  const ax = Math.abs(movement.x);
+  const ay = Math.abs(movement.y);
+  if (Math.hypot(ax, ay) < slop) return null;
+  if (ax > ay * ratio) return "x";
+  if (ay > ax * ratio) return "y";
+  return null;
+}
+function swipeDirection(movement, velocity, options = {}) {
+  const { distance: distance2 = 60, velocity: flick = FLICK_VELOCITY, minDistance = 16, ratio = 1.5 } = options;
+  const ax = Math.abs(movement.x);
+  const ay = Math.abs(movement.y);
+  const axis = options.axis ?? (ax > ay * ratio ? "x" : ay > ax * ratio ? "y" : null);
+  if (!axis) return null;
+  const along = axis === "x" ? movement.x : movement.y;
+  const across = axis === "x" ? ay : ax;
+  if (Math.abs(along) <= across * ratio) return null;
+  const speed = axis === "x" ? velocity.x : velocity.y;
+  const far = Math.abs(along) >= distance2;
+  const flung = Math.abs(along) >= minDistance && Math.abs(speed) >= flick && Math.sign(speed) === Math.sign(along);
+  if (!far && !flung) return null;
+  if (axis === "x") return along < 0 ? "left" : "right";
+  return along < 0 ? "up" : "down";
+}
+function rubberBand(overshoot, size, c = 0.55) {
+  if (!overshoot || size <= 0) return 0;
+  const distance2 = Math.abs(overshoot);
+  return Math.sign(overshoot) * (1 - 1 / (distance2 * c / size + 1)) * size;
+}
+function rubberClamp(value, min, max, size, c) {
+  if (value < min) return min + rubberBand(value - min, size, c);
+  if (value > max) return max + rubberBand(value - max, size, c);
+  return value;
+}
+function shouldDismiss({ offset, velocity, size, ratio = 0.5, flick = FLICK_VELOCITY }) {
+  if (offset <= 0) return false;
+  if (velocity >= flick && offset > 4) return true;
+  return offset >= size * ratio && velocity > -flick;
+}
+function pageAfterSwipe({ index, count, offset, velocity, size, ratio = 0.25, flick = FLICK_VELOCITY, loop = false }) {
+  if (count <= 0) return 0;
+  const far = Math.abs(offset) >= size * ratio;
+  const flung = Math.abs(velocity) >= flick && Math.sign(velocity) === Math.sign(offset) && Math.abs(offset) > 8;
+  if (!far && !flung) return index;
+  const next = index + (offset < 0 ? 1 : -1);
+  if (loop) return (next + count) % count;
+  return clamp(next, 0, count - 1);
+}
+function momentumDistance(velocity, tau = 240) {
+  return velocity * tau;
+}
+function distance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function midpoint(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function pinchFrame(a, b, startDistance) {
+  const now = Math.max(1, distance(a, b));
+  return { scale: now / Math.max(1, startDistance), origin: midpoint(a, b), distance: now };
+}
+function wheelPixels(delta, mode, page) {
+  if (mode === 1) return delta * 16;
+  if (mode === 2) return delta * page;
+  return delta;
+}
+function createDragSession(start, time, options) {
+  const tracker = createVelocityTracker();
+  tracker.add(start, time);
+  let phase = "pending";
+  let axis = null;
+  let last = start;
+  function frame(point, at, first) {
+    const f = {
+      phase,
+      first,
+      start,
+      point,
+      movement: { x: point.x - start.x, y: point.y - start.y },
+      delta: { x: point.x - last.x, y: point.y - last.y },
+      velocity: tracker.velocity(at),
+      axis,
+      elapsed: at - time
+    };
+    last = point;
+    return f;
+  }
+  return {
+    get phase() {
+      return phase;
+    },
+    move(point, at) {
+      tracker.add(point, at);
+      let first = false;
+      if (phase === "pending") {
+        const movement = { x: point.x - start.x, y: point.y - start.y };
+        if (Math.hypot(movement.x, movement.y) >= options.slop) {
+          if (!options.axis) {
+            phase = "drag";
+            first = true;
+          } else {
+            const taken = lockAxis(movement, options.slop);
+            if (taken && options.axis !== "lock" && taken !== options.axis) phase = "rejected";
+            else if (taken) {
+              axis = taken;
+              phase = "drag";
+              first = true;
+            }
+          }
+        }
+      }
+      if (phase !== "drag") return frame(point, at, false);
+      return frame(point, at, first);
+    },
+    end(point, at, swipe) {
+      tracker.add(point, at);
+      const f = frame(point, at, false);
+      const direction = phase === "drag" ? swipeDirection(f.movement, f.velocity, { axis: axis ?? void 0, ...swipe }) : null;
+      return { ...f, swipe: direction };
+    }
+  };
+}
+export {
+  FLICK_VELOCITY,
+  HOLD_TO_DRAG_MS,
+  LONG_PRESS_MS,
+  MOUSE_SLOP,
+  TOUCH_SLOP,
+  createDragSession,
+  createVelocityTracker,
+  distance,
+  lockAxis,
+  midpoint,
+  momentumDistance,
+  pageAfterSwipe,
+  pinchFrame,
+  rubberBand,
+  rubberClamp,
+  shouldDismiss,
+  slopFor,
+  swipeDirection,
+  wheelPixels
+};

package/dist/composables/scroll.d.ts

@@ -17,8 +17,12 @@ export interface ScrollToElementOptions {
     behavior?: ScrollBehavior;
     /** Room kept between the element and the scroller's edge. */
     margin?: number;
+    /** Which way to scroll: vertical (default) or horizontal, for a strip. */
+    axis?: "y" | "x";
+    /** Scroll this element rather than the nearest scroller along `axis`. */
+    container?: HTMLElement | null;
 }
 /** Scroll the nearest scroller, and only it, so that `el` is in view. */
 /** The element's own `scroll-margin-top`, the gap it asks to keep above it when scrolled to. */
 export declare function scrollMarginTop(el: Element): number;
-export declare function scrollToElement(el: Element | null | undefined, { block, behavior, margin }?: ScrollToElementOptions): void;
+export declare function scrollToElement(el: Element | null | undefined, { block, behavior, margin, axis, container }?: ScrollToElementOptions): void;

package/dist/composables/scroll.js

@@ -20,21 +20,28 @@ function atScrollEnd(el, slack = 2) {
 function scrollMarginTop(el) {
   return Number.parseFloat(nodeWindow(el).getComputedStyle(el).scrollMarginTop) || 0;
 }
-function scrollToElement(el, { block = "nearest", behavior = "auto", margin = 0 } = {}) {
+function scrollToElement(el, { block = "nearest", behavior = "auto", margin = 0, axis = "y", container } = {}) {
   if (!el) return;
   const doc = el.ownerDocument;
   const win = doc.defaultView ?? window;
-  const box = scrollParent(el) ?? doc.scrollingElement;
+  const box = container ?? scrollParent(el, { axis }) ?? doc.scrollingElement;
   if (!box) return;
   const outer = box === doc.scrollingElement ? new DOMRect(0, 0, win.innerWidth, win.innerHeight) : box.getBoundingClientRect();
   const inner = el.getBoundingClientRect();
-  const top = inner.top - outer.top + box.scrollTop;
-  let target = box.scrollTop;
-  if (block === "start") target = top - margin;
-  else if (block === "center") target = top - (box.clientHeight - inner.height) / 2;
-  else if (inner.top < outer.top + margin) target = top - margin;
-  else if (inner.bottom > outer.bottom - margin) target = top - box.clientHeight + inner.height + margin;
-  if (target !== box.scrollTop) box.scrollTo({ top: target, behavior });
+  const x = axis === "x";
+  const from = x ? box.scrollLeft : box.scrollTop;
+  const view = x ? box.clientWidth : box.clientHeight;
+  const size = x ? inner.width : inner.height;
+  const lo = x ? inner.left - outer.left : inner.top - outer.top;
+  const hi = x ? inner.right - outer.right : inner.bottom - outer.bottom;
+  const at = lo + from;
+  let target = from;
+  if (block === "start") target = at - margin;
+  else if (block === "center") target = at - (view - size) / 2;
+  else if (lo < margin) target = at - margin;
+  else if (hi > -margin) target = at - view + size + margin;
+  if (target === from) return;
+  box.scrollTo(x ? { left: target, behavior } : { top: target, behavior });
 }
 export {
   atScrollEnd,

package/dist/composables/useAppUpdate.d.ts

@@ -0,0 +1,26 @@
+import { type Ref } from "vue";
+export interface AppUpdateOptions {
+    /** The build this page is running. */
+    current: string;
+    /** The build that is live now, or null when it cannot be told. */
+    latest: () => Promise<string | null>;
+    /** Unsaved work the kit cannot see, such as a dirty form outside a dialog. */
+    busy?: () => boolean;
+    /** Ms without input before a visible tab may reload. */
+    idleMs?: number;
+    /** Ms between background checks; 0 turns the timer off. */
+    everyMs?: number;
+    /** sessionStorage key for the scroll position carried over the reload. */
+    storageKey?: string;
+}
+export interface AppUpdate {
+    /** A newer build is live and the tab is waiting for a safe moment. */
+    pending: Readonly<Ref<boolean>>;
+    /** This page load is the reload of an update. */
+    restored: Readonly<Ref<boolean>>;
+    /** Ask the server now. */
+    check: () => Promise<void>;
+    /** Reload at once, keeping the scroll position. */
+    reloadNow: () => void;
+}
+export declare function useAppUpdate(options: AppUpdateOptions): AppUpdate;

package/dist/composables/useAppUpdate.js

@@ -0,0 +1,91 @@
+import { ref, onScopeDispose, readonly } from "vue";
+const OVERLAY = '[role="dialog"], [role="alertdialog"], [role="menu"], [role="listbox"], [data-state="open"][data-side]';
+const INPUT_EVENTS = ["pointerdown", "keydown", "wheel", "touchstart", "input"];
+const CARRY_MS = 6e4;
+function editableFocused() {
+  const el = document.activeElement;
+  if (!(el instanceof HTMLElement)) return false;
+  if (el.isContentEditable) return true;
+  if (el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) return true;
+  return el instanceof HTMLInputElement && !["button", "checkbox", "radio", "range", "submit", "reset"].includes(el.type);
+}
+function overlayOpen() {
+  return [...document.querySelectorAll(OVERLAY)].some((el) => el.getClientRects().length > 0);
+}
+function readCarried(key) {
+  try {
+    const raw = sessionStorage.getItem(key);
+    sessionStorage.removeItem(key);
+    if (!raw) return null;
+    const value = JSON.parse(raw);
+    if (typeof value.href !== "string" || typeof value.top !== "number" || typeof value.at !== "number") return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function useAppUpdate(options) {
+  const key = options.storageKey ?? "lp:app-update";
+  const idleMs = options.idleMs ?? 3e4;
+  const pending = ref(false);
+  const restored = ref(false);
+  let lastInput = Date.now();
+  let timer;
+  const carried = readCarried(key);
+  if (carried && carried.href === location.href && Date.now() - carried.at < CARRY_MS) {
+    restored.value = true;
+    const top = carried.top;
+    const restore = () => window.scrollTo({ top, behavior: "instant" });
+    requestAnimationFrame(() => requestAnimationFrame(restore));
+    window.addEventListener("load", restore, { once: true });
+  }
+  function reloadNow() {
+    try {
+      sessionStorage.setItem(key, JSON.stringify({ href: location.href, top: window.scrollY, at: Date.now() }));
+    } catch {
+    }
+    location.reload();
+  }
+  function safe() {
+    if (document.hidden) return true;
+    if (Date.now() - lastInput < idleMs) return false;
+    return !overlayOpen() && !editableFocused() && !options.busy?.();
+  }
+  function attempt() {
+    if (pending.value && safe()) reloadNow();
+  }
+  async function check() {
+    if (pending.value) return attempt();
+    let live = null;
+    try {
+      live = await options.latest();
+    } catch {
+      return;
+    }
+    if (!live || live === options.current) return;
+    pending.value = true;
+    attempt();
+  }
+  const onInput = () => {
+    lastInput = Date.now();
+  };
+  const onVisibility = () => {
+    if (document.hidden) attempt();
+    else void check();
+  };
+  for (const name of INPUT_EVENTS) window.addEventListener(name, onInput, { passive: true, capture: true });
+  document.addEventListener("visibilitychange", onVisibility);
+  const every = options.everyMs ?? 5 * 6e4;
+  const tick = setInterval(attempt, 5e3);
+  if (every > 0) timer = setInterval(() => void check(), every);
+  onScopeDispose(() => {
+    for (const name of INPUT_EVENTS) window.removeEventListener(name, onInput, { capture: true });
+    document.removeEventListener("visibilitychange", onVisibility);
+    clearInterval(tick);
+    if (timer) clearInterval(timer);
+  });
+  return { pending: readonly(pending), restored: readonly(restored), check, reloadNow };
+}
+export {
+  useAppUpdate
+};

package/dist/composables/useGesture.d.ts

@@ -0,0 +1,107 @@
+import { type MaybeRefOrGetter, type Ref } from "vue";
+import { type GestureAxis, type GesturePoint, type PinchFrame, type SwipeOptions } from "./gesture";
+import type { Direction } from "./spatialNav";
+export interface GestureState {
+    event: PointerEvent;
+    pointerType: string;
+    /** Where the press started, client coordinates. */
+    start: GesturePoint;
+    /** Where the pointer is now. */
+    point: GesturePoint;
+    /** Travel since the press. */
+    movement: GesturePoint;
+    /** Travel since the previous report. */
+    delta: GesturePoint;
+    /** Px/ms over the last moments. */
+    velocity: GesturePoint;
+    /** The axis the drag committed to, with `axis` set. */
+    axis: GestureAxis | null;
+    /** Ms since the press. */
+    elapsed: number;
+    /** A drag that ended without being completed: do not commit it. */
+    cancelled: boolean;
+}
+export interface GestureEnd extends GestureState {
+    /** The swipe this release made, or null. */
+    swipe: Direction | null;
+}
+export interface GesturePinch extends PinchFrame {
+    event: PointerEvent;
+}
+export interface GestureOptions {
+    /** Off while false; read on every press. */
+    enabled?: MaybeRefOrGetter<boolean | undefined>;
+    /** Pointer types that may start a gesture. Default all. */
+    pointerTypes?: readonly ("mouse" | "pen" | "touch")[];
+    /** Restrict drags to an axis, or `lock` to the first one taken. */
+    axis?: GestureAxis | "lock";
+    /** Override the slop in px (default by pointer type). */
+    threshold?: number;
+    /** Presses starting inside an element matching this selector are ignored. */
+    ignore?: string;
+    /** Capture the pointer once dragging. Default true. */
+    capture?: boolean;
+    /** Swallow the click a drag ends with. Default true. */
+    preventClick?: boolean;
+    /** Options for the swipe reported on release. */
+    swipe?: SwipeOptions;
+    /** A press landed (before any threshold). Return false to ignore this press. */
+    onPress?: (event: PointerEvent) => boolean | void;
+    onDragStart?: (state: GestureState) => void;
+    onDrag?: (state: GestureState) => void;
+    onDragEnd?: (state: GestureEnd) => void;
+    /** Released after a swipe; also reported on onDragEnd as `swipe`. */
+    onSwipe?: (direction: Direction, state: GestureEnd) => void;
+    /** A press that never became a drag, released. */
+    onTap?: (event: PointerEvent) => void;
+    onPinchStart?: (pinch: GesturePinch) => void;
+    onPinch?: (pinch: GesturePinch) => void;
+    onPinchEnd?: (pinch: GesturePinch & {
+        cancelled: boolean;
+    }) => void;
+    /** A press held still for `delay` ms (default LONG_PRESS_MS); the click its release makes is swallowed. */
+    longPress?: {
+        delay?: MaybeRefOrGetter<number | undefined>;
+        pointerTypes?: readonly ("mouse" | "pen" | "touch")[];
+        handler: (event: PointerEvent) => void;
+    };
+}
+export interface Gesture {
+    /** True while a drag (past the slop) is in flight. */
+    dragging: Ref<boolean>;
+    /** True while two pointers are pinching. */
+    pinching: Ref<boolean>;
+    /** End whatever is in flight as cancelled. */
+    cancel: () => void;
+    /** Bind these to the element when not using useGesture. */
+    handlers: {
+        onPointerdown: (event: PointerEvent) => void;
+        onPointermove: (event: PointerEvent) => void;
+        onPointerup: (event: PointerEvent) => void;
+        onPointercancel: (event: PointerEvent) => void;
+        onLostpointercapture: (event: PointerEvent) => void;
+        onClickCapture: (event: MouseEvent) => void;
+        onDragstart: (event: DragEvent) => void;
+        onContextmenu: (event: Event) => void;
+    };
+    /** Detach window listeners and timers; useGesture calls it on unmount. */
+    dispose: () => void;
+}
+/** The engine without an element: bind `handlers` yourself (to compose with other handlers). */
+export declare function createGesture(options: GestureOptions): Gesture;
+/** The engine bound to `target`: listeners follow the element and leave on unmount. */
+export declare function useGesture(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options: GestureOptions): Gesture;
+export interface Glide {
+    stop: () => void;
+}
+/**
+ * Momentum after a fling: keep moving at `velocity` px/ms and bleed the speed
+ * off exponentially (time constant `tau` ms), so letting go drifts to a stop.
+ * Time-based, so it feels the same at 60 and 144 Hz. `step` gets the px to
+ * move this frame and returns false to stop early (an edge was hit). Under
+ * reduced motion nothing glides.
+ */
+export declare function glide(velocity: GesturePoint, step: (dx: number, dy: number) => boolean | void, { tau, win }?: {
+    tau?: number;
+    win?: Window;
+}): Glide;