@leavepulse/ui 0.93.3 → 0.94.0

package/dist/composables/useGesture.js

@@ -0,0 +1,281 @@
+import { ref, toValue, watch, onBeforeUnmount } from "vue";
+import { prefersReducedMotion } from "./easing.js";
+import { pinchFrame, distance, createDragSession, slopFor, LONG_PRESS_MS } from "./gesture.js";
+import { isElement, nodeWindow } from "./realm.js";
+const CLICK_AFTER_HOLD_MS = 350;
+function createGesture(options) {
+  const dragging = ref(false);
+  const pinching = ref(false);
+  const pointers = /* @__PURE__ */ new Map();
+  let press = null;
+  let pinchStart = 0;
+  let pinchLast = null;
+  let swallow = false;
+  let swallowTimer = 0;
+  let holdTimer = 0;
+  let held = false;
+  let bodyStyle = null;
+  let keyWindow = null;
+  const pt = (e) => ({ x: e.clientX, y: e.clientY });
+  function state(e, p, f, cancelled = false) {
+    return { event: e, pointerType: p.type, start: f.start, point: f.point, movement: f.movement, delta: f.delta, velocity: f.velocity, axis: f.axis, elapsed: f.elapsed, cancelled };
+  }
+  function clickSoon(win, within = 0) {
+    swallow = true;
+    win.clearTimeout(swallowTimer);
+    swallowTimer = win.setTimeout(() => swallow = false, within);
+  }
+  function stopHold() {
+    if (holdTimer) window.clearTimeout(holdTimer);
+    holdTimer = 0;
+  }
+  function onKey(e) {
+    if (e.key === "Escape" && dragging.value) {
+      e.preventDefault();
+      cancel();
+    }
+  }
+  function beginDrag(e, p, f) {
+    p.dragging = true;
+    dragging.value = true;
+    stopHold();
+    if (options.capture !== false && p.type !== "touch") {
+      try {
+        p.el.setPointerCapture(p.id);
+      } catch {
+      }
+    }
+    const doc = p.el.ownerDocument;
+    bodyStyle = { style: doc.body.style, userSelect: doc.body.style.userSelect };
+    doc.body.style.userSelect = "none";
+    doc.getSelection()?.removeAllRanges();
+    keyWindow = nodeWindow(p.el);
+    keyWindow.addEventListener("keydown", onKey, true);
+    options.onDragStart?.(state(e, p, f));
+  }
+  function release() {
+    if (bodyStyle) bodyStyle.style.userSelect = bodyStyle.userSelect;
+    bodyStyle = null;
+    keyWindow?.removeEventListener("keydown", onKey, true);
+    keyWindow = null;
+    dragging.value = false;
+  }
+  function endPress(e, cancelled) {
+    const p = press;
+    if (!p) return;
+    press = null;
+    stopHold();
+    if (p.el.hasPointerCapture?.(p.id)) {
+      try {
+        p.el.releasePointerCapture(p.id);
+      } catch {
+      }
+    }
+    if (!p.dragging) {
+      release();
+      if (held) {
+        if (cancelled) swallow = false;
+        else clickSoon(nodeWindow(p.el), CLICK_AFTER_HOLD_MS);
+        held = false;
+      } else if (!cancelled) options.onTap?.(e);
+      return;
+    }
+    const f = p.session.end(pt(e), e.timeStamp, options.swipe);
+    const s = state(e, p, f, cancelled);
+    const swipe = cancelled ? null : f.swipe;
+    if (!cancelled && options.preventClick !== false) clickSoon(nodeWindow(p.el));
+    release();
+    const end = { ...s, swipe };
+    options.onDragEnd?.(end);
+    if (swipe) options.onSwipe?.(swipe, end);
+  }
+  function endPinch(e, cancelled) {
+    if (!pinching.value) return;
+    pinching.value = false;
+    pinchStart = 0;
+    if (pinchLast) options.onPinchEnd?.({ ...pinchLast, event: e, cancelled });
+    pinchLast = null;
+  }
+  function allowed(e) {
+    if (toValue(options.enabled) === false) return false;
+    if (options.pointerTypes && !options.pointerTypes.includes(e.pointerType)) return false;
+    if (e.pointerType === "mouse" && e.button !== 0) return false;
+    if (options.ignore && isElement(e.target) && e.target.closest(options.ignore)) return false;
+    return true;
+  }
+  function onPointerdown(e) {
+    if (!allowed(e)) return;
+    pointers.set(e.pointerId, pt(e));
+    if (pointers.size === 2 && (options.onPinch || options.onPinchStart)) {
+      if (press) endPress(e, true);
+      const [a, b] = [...pointers.values()];
+      pinchStart = distance(a, b);
+      pinching.value = true;
+      pinchLast = { ...pinchFrame(a, b, pinchStart), event: e };
+      try {
+        ;
+        e.currentTarget.setPointerCapture(e.pointerId);
+      } catch {
+      }
+      options.onPinchStart?.(pinchLast);
+      return;
+    }
+    if (pointers.size > 1 || press) return;
+    if (options.onPress?.(e) === false) {
+      pointers.delete(e.pointerId);
+      return;
+    }
+    const el = e.currentTarget;
+    held = false;
+    const session = createDragSession(pt(e), e.timeStamp, { slop: options.threshold ?? slopFor(e.pointerType), axis: options.axis });
+    press = { id: e.pointerId, type: e.pointerType, el, session, dragging: false, first: e };
+    const lp = options.longPress;
+    if (lp && (!lp.pointerTypes || lp.pointerTypes.includes(e.pointerType))) {
+      holdTimer = window.setTimeout(() => {
+        holdTimer = 0;
+        if (!press || press.dragging) return;
+        held = true;
+        lp.handler(e);
+      }, toValue(lp.delay) ?? LONG_PRESS_MS);
+    }
+  }
+  function onPointermove(e) {
+    if (!pointers.has(e.pointerId)) return;
+    pointers.set(e.pointerId, pt(e));
+    if (pinching.value && pointers.size >= 2) {
+      const [a, b] = [...pointers.values()];
+      pinchLast = { ...pinchFrame(a, b, pinchStart), event: e };
+      options.onPinch?.(pinchLast);
+      return;
+    }
+    const p = press;
+    if (!p || e.pointerId !== p.id) return;
+    const f = p.session.move(pt(e), e.timeStamp);
+    if (f.phase === "rejected") {
+      press = null;
+      pointers.delete(e.pointerId);
+      stopHold();
+      return;
+    }
+    if (f.phase === "pending") return;
+    if (!p.dragging) {
+      stopHold();
+      if (held) return;
+      if (!options.onDrag && !options.onDragStart && !options.onDragEnd && !options.onSwipe) return;
+      beginDrag(e, p, f);
+    }
+    options.onDrag?.(state(e, p, f));
+  }
+  function onPointerup(e) {
+    if (!pointers.delete(e.pointerId)) return;
+    if (pinching.value) {
+      if (pointers.size < 2) endPinch(e, false);
+      return;
+    }
+    if (press?.id === e.pointerId) endPress(e, false);
+  }
+  function onPointercancel(e) {
+    if (!pointers.delete(e.pointerId)) return;
+    if (pinching.value) {
+      endPinch(e, true);
+      return;
+    }
+    if (press?.id === e.pointerId) endPress(e, true);
+  }
+  function onLostpointercapture(e) {
+    if (press?.dragging && press.id === e.pointerId) {
+      pointers.delete(e.pointerId);
+      endPress(e, true);
+    }
+  }
+  function onClickCapture(e) {
+    if (!swallow) return;
+    swallow = false;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+  }
+  function onDragstart(e) {
+    if (press) e.preventDefault();
+  }
+  function onContextmenu(e) {
+    if (holdTimer || held || dragging.value) e.preventDefault();
+  }
+  function cancel() {
+    const p = press;
+    if (p) {
+      pointers.delete(p.id);
+      endPress(p.first, true);
+    }
+    if (pinching.value && pinchLast) endPinch(pinchLast.event, true);
+    pointers.clear();
+  }
+  function dispose() {
+    stopHold();
+    if (press?.dragging) release();
+    press = null;
+    pointers.clear();
+  }
+  return {
+    dragging,
+    pinching,
+    cancel,
+    dispose,
+    handlers: { onPointerdown, onPointermove, onPointerup, onPointercancel, onLostpointercapture, onClickCapture, onDragstart, onContextmenu }
+  };
+}
+function useGesture(target, options) {
+  const gesture = createGesture(options);
+  const h = gesture.handlers;
+  const bindings = [
+    ["pointerdown", h.onPointerdown],
+    ["pointermove", h.onPointermove],
+    ["pointerup", h.onPointerup],
+    ["pointercancel", h.onPointercancel],
+    ["lostpointercapture", h.onLostpointercapture],
+    ["click", h.onClickCapture, { capture: true }],
+    ["dragstart", h.onDragstart],
+    ["contextmenu", h.onContextmenu]
+  ];
+  watch(
+    () => toValue(target),
+    (el, _, onCleanup) => {
+      if (!el) return;
+      for (const [name, fn, opts] of bindings) el.addEventListener(name, fn, opts);
+      onCleanup(() => {
+        for (const [name, fn, opts] of bindings) el.removeEventListener(name, fn, opts);
+        gesture.cancel();
+      });
+    },
+    { immediate: true, flush: "post" }
+  );
+  onBeforeUnmount(gesture.dispose);
+  return gesture;
+}
+function glide(velocity, step, { tau = 240, win = window } = {}) {
+  let v = { ...velocity };
+  let frame = 0;
+  const stop = () => {
+    if (frame) win.cancelAnimationFrame(frame);
+    frame = 0;
+  };
+  if (prefersReducedMotion(win) || Math.hypot(v.x, v.y) < 0.05) return { stop };
+  let previous = win.performance.now();
+  const tick = (now) => {
+    const dt = Math.min(now - previous, 32);
+    previous = now;
+    const friction = Math.exp(-dt / tau);
+    v = { x: v.x * friction, y: v.y * friction };
+    if (step(v.x * dt, v.y * dt) === false || Math.hypot(v.x, v.y) <= 0.015) {
+      frame = 0;
+      return;
+    }
+    frame = win.requestAnimationFrame(tick);
+  };
+  frame = win.requestAnimationFrame(tick);
+  return { stop };
+}
+export {
+  createGesture,
+  glide,
+  useGesture
+};

package/dist/composables/usePaintSelect.js

@@ -1,9 +1,8 @@
+import { TOUCH_SLOP, HOLD_TO_DRAG_MS } from "./gesture.js";
 import { ref, toValue, onMounted, onBeforeUnmount, readonly } from "vue";
 import { useHotkeys } from "./useHotkeys.js";
 import { scrollParent } from "./scroll.js";
 import { nodeWindow } from "./realm.js";
-const HOLD_MS = 320;
-const SLOP_PX = 8;
 const EDGE_PX = 40;
 const SCROLL_STEP = 14;
 function usePaintSelect(options) {
@@ -90,12 +89,12 @@ function usePaintSelect(options) {
         pending = null;
         begin(key, x, y);
         navigator.vibrate?.(8);
-      }, behaviour.hold ?? HOLD_MS)
+      }, behaviour.hold ?? HOLD_TO_DRAG_MS)
     };
   }
   function onMove(event) {
     if (pending && event.pointerId === pending.pointerId) {
-      if (Math.hypot(event.clientX - pending.x, event.clientY - pending.y) > SLOP_PX) cancelPending();
+      if (Math.hypot(event.clientX - pending.x, event.clientY - pending.y) > TOUCH_SLOP) cancelPending();
       return;
     }
     if (!stroke) return;

package/dist/composables/useScrollStrip.d.ts

@@ -0,0 +1,27 @@
+import { type MaybeRefOrGetter, type Ref } from "vue";
+export interface ScrollStripOptions {
+    /** Map a vertical wheel to sideways scrolling. Default true. */
+    wheel?: MaybeRefOrGetter<boolean | undefined>;
+    /** Drag to scroll with a mouse or pen. Default true. */
+    drag?: MaybeRefOrGetter<boolean | undefined>;
+    /** Room kept beside a focused item, so it clears the fade. Default 24. */
+    focusMargin?: number;
+}
+export interface ScrollStrip {
+    overflowing: Ref<boolean>;
+    atStart: Ref<boolean>;
+    atEnd: Ref<boolean>;
+    dragging: Ref<boolean>;
+    /** Scroll most of a view's width toward the start (-1) or the end (1). */
+    page: (direction: -1 | 1) => void;
+    /** Scroll by `px`, eased unless reduced motion asks otherwise. */
+    scrollBy: (px: number) => void;
+    /** Bring `el` into view within the strip only (`center` puts it in the middle). */
+    reveal: (el: Element | null | undefined, options?: {
+        smooth?: boolean;
+        block?: "nearest" | "center";
+    }) => void;
+    /** Measure again (after content changed in a way nothing observed). */
+    measure: () => void;
+}
+export declare function useScrollStrip(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: ScrollStripOptions): ScrollStrip;

package/dist/composables/useScrollStrip.js

@@ -0,0 +1,194 @@
+import { ref, watch, onBeforeUnmount, toValue } from "vue";
+import { prefersReducedMotion } from "./easing.js";
+import { wheelPixels, momentumDistance } from "./gesture.js";
+import { nodeWindow, isHTMLElement } from "./realm.js";
+import { scrollToElement } from "./scroll.js";
+import { useGesture } from "./useGesture.js";
+const PAGE_SHARE = 0.8;
+function useScrollStrip(target, options = {}) {
+  const overflowing = ref(false);
+  const atStart = ref(true);
+  const atEnd = ref(true);
+  const el = () => {
+    const box = toValue(target);
+    return isHTMLElement(box) ? box : null;
+  };
+  function measure() {
+    const box = el();
+    if (!box) return;
+    const max = box.scrollWidth - box.clientWidth;
+    const left = Math.abs(box.scrollLeft);
+    overflowing.value = max > 1;
+    atStart.value = left <= 1;
+    atEnd.value = left >= max - 1;
+  }
+  const maxScroll = (box) => Math.max(0, box.scrollWidth - box.clientWidth);
+  const snaps = (box) => {
+    const type = nodeWindow(box).getComputedStyle(box).scrollSnapType;
+    return !!type && type !== "none";
+  };
+  let frame = 0;
+  let goal = null;
+  let restoreBehavior = null;
+  function stopEase() {
+    const box = el();
+    if (frame && box) nodeWindow(box).cancelAnimationFrame(frame);
+    frame = 0;
+    goal = null;
+    restoreBehavior?.();
+    restoreBehavior = null;
+  }
+  function easeTo(box, to) {
+    const win = nodeWindow(box);
+    goal = Math.max(0, Math.min(maxScroll(box), to));
+    if (prefersReducedMotion(win)) {
+      box.scrollLeft = goal;
+      goal = null;
+      return;
+    }
+    if (frame) return;
+    let previous = win.performance.now();
+    let position = box.scrollLeft;
+    const behavior = box.style.scrollBehavior;
+    box.style.scrollBehavior = "auto";
+    restoreBehavior = () => box.style.scrollBehavior = behavior;
+    const done = () => {
+      frame = 0;
+      goal = null;
+      restoreBehavior?.();
+      restoreBehavior = null;
+    };
+    const tick = (now) => {
+      if (goal === null) {
+        done();
+        return;
+      }
+      const dt = Math.min(now - previous, 32);
+      previous = now;
+      position += (goal - position) * (1 - Math.exp(-dt / 70));
+      if (Math.abs(goal - position) < 0.5) position = goal;
+      box.scrollLeft = position;
+      if (position === goal) {
+        done();
+        return;
+      }
+      frame = win.requestAnimationFrame(tick);
+    };
+    frame = win.requestAnimationFrame(tick);
+  }
+  function scrollBy(px) {
+    const box = el();
+    if (!box) return;
+    if (snaps(box)) {
+      box.scrollBy({ left: px, behavior: prefersReducedMotion(nodeWindow(box)) ? "auto" : "smooth" });
+      return;
+    }
+    easeTo(box, (goal ?? box.scrollLeft) + px);
+  }
+  function page(direction) {
+    const box = el();
+    if (box) scrollBy(direction * box.clientWidth * PAGE_SHARE);
+  }
+  function reveal(item, { smooth = true, block = "nearest" } = {}) {
+    const box = el();
+    if (!box || !item || !box.contains(item)) return;
+    stopEase();
+    const behavior = smooth && !prefersReducedMotion(nodeWindow(box)) ? "smooth" : "auto";
+    scrollToElement(item, { axis: "x", container: box, margin: options.focusMargin ?? 24, behavior, block });
+  }
+  function onWheel(e) {
+    const box = el();
+    if (!box || toValue(options.wheel) === false || e.ctrlKey || e.defaultPrevented) return;
+    if (Math.abs(e.deltaX) >= Math.abs(e.deltaY)) return;
+    const max = maxScroll(box);
+    if (max <= 1) return;
+    const px = wheelPixels(e.shiftKey ? e.deltaX || e.deltaY : e.deltaY, e.deltaMode, box.clientWidth);
+    const from = goal ?? box.scrollLeft;
+    if (px > 0 && from >= max - 1 || px < 0 && from <= 1) return;
+    e.preventDefault();
+    const notch = e.deltaMode !== 0 || Math.abs(px) >= 50;
+    if (notch) scrollBy(px);
+    else {
+      stopEase();
+      box.scrollLeft += px;
+    }
+  }
+  function onFocusin(e) {
+    const item = e.target;
+    if (!isHTMLElement(item) || gesture.dragging.value) return;
+    try {
+      if (!item.matches(":focus-visible")) return;
+    } catch {
+    }
+    reveal(item);
+  }
+  let snapType = null;
+  const gesture = useGesture(el, {
+    pointerTypes: ["mouse", "pen"],
+    enabled: () => toValue(options.drag) !== false && overflowing.value,
+    onDragStart() {
+      const box = el();
+      if (!box) return;
+      stopEase();
+      if (snaps(box)) {
+        snapType = box.style.scrollSnapType;
+        box.style.scrollSnapType = "none";
+      }
+      box.style.scrollBehavior = "auto";
+    },
+    onDrag({ delta }) {
+      const box = el();
+      if (box) box.scrollLeft -= delta.x;
+    },
+    onDragEnd({ velocity, cancelled }) {
+      const box = el();
+      if (!box) return;
+      box.style.scrollBehavior = "";
+      const travel = cancelled ? 0 : -momentumDistance(velocity.x);
+      if (snapType !== null) {
+        box.style.scrollSnapType = snapType;
+        snapType = null;
+        box.scrollBy({ left: travel, behavior: prefersReducedMotion(nodeWindow(box)) ? "auto" : "smooth" });
+        return;
+      }
+      if (Math.abs(travel) > 4) easeTo(box, box.scrollLeft + travel);
+    }
+  });
+  watch(
+    () => el(),
+    (box, _, onCleanup) => {
+      if (!box) return;
+      const win = nodeWindow(box);
+      const resize = new win.ResizeObserver(measure);
+      const observeAll = () => {
+        resize.disconnect();
+        resize.observe(box);
+        for (const child of Array.from(box.children)) resize.observe(child);
+      };
+      const mutations = new win.MutationObserver(() => {
+        observeAll();
+        measure();
+      });
+      observeAll();
+      mutations.observe(box, { childList: true });
+      box.addEventListener("scroll", measure, { passive: true });
+      box.addEventListener("wheel", onWheel, { passive: false });
+      box.addEventListener("focusin", onFocusin);
+      measure();
+      onCleanup(() => {
+        resize.disconnect();
+        mutations.disconnect();
+        box.removeEventListener("scroll", measure);
+        box.removeEventListener("wheel", onWheel);
+        box.removeEventListener("focusin", onFocusin);
+        stopEase();
+      });
+    },
+    { immediate: true, flush: "post" }
+  );
+  onBeforeUnmount(stopEase);
+  return { overflowing, atStart, atEnd, dragging: gesture.dragging, page, scrollBy, reveal, measure };
+}
+export {
+  useScrollStrip
+};

package/dist/composables/useTouchHold.d.ts

@@ -12,8 +12,10 @@ export declare function useTouchHold(options: TouchHoldOptions): {
         onPointerdown: (event: PointerEvent) => void;
         onPointermove: (event: PointerEvent) => void;
         onPointerup: (event: PointerEvent) => void;
-        onPointercancel: (event?: PointerEvent) => void;
+        onPointercancel: (event: PointerEvent) => void;
+        onLostpointercapture: (event: PointerEvent) => void;
         onClickCapture: (event: MouseEvent) => void;
+        onDragstart: (event: DragEvent) => void;
         onContextmenu: (event: Event) => void;
     };
 };

package/dist/composables/useTouchHold.js

@@ -1,58 +1,16 @@
 import { onBeforeUnmount } from "vue";
-const SLOP = 8;
-const CLICK_AFTER_RELEASE_MS = 350;
+import { createGesture } from "./useGesture.js";
 function useTouchHold(options) {
-  let timer = 0;
-  let finger = null;
-  let start = { x: 0, y: 0 };
-  let held = false;
-  function stop() {
-    window.clearTimeout(timer);
-    timer = 0;
-  }
-  function onPointerDown(event) {
-    if (timer && event.pointerId !== finger) return;
-    held = false;
-    if (event.pointerType !== "touch" || !options.enabled()) return;
-    finger = event.pointerId;
-    start = { x: event.clientX, y: event.clientY };
-    stop();
-    timer = window.setTimeout(() => {
-      timer = 0;
-      held = true;
-      options.onHold();
-    }, options.delay());
-  }
-  function onPointerMove(event) {
-    if (!timer || event.pointerId !== finger) return;
-    if (Math.hypot(event.clientX - start.x, event.clientY - start.y) > SLOP) stop();
-  }
-  function onPointerUp(event) {
-    if (finger !== null && event.pointerId !== finger) return;
-    finger = null;
-    stop();
-    if (held) window.setTimeout(() => held = false, CLICK_AFTER_RELEASE_MS);
-  }
-  function onPointerCancel(event) {
-    if (event && finger !== null && event.pointerId !== finger) return;
-    finger = null;
-    stop();
-    held = false;
-  }
-  function onClickCapture(event) {
-    if (!held) return;
-    held = false;
-    event.preventDefault();
-    event.stopImmediatePropagation();
-  }
-  function onContextMenu(event) {
-    if (timer || held) event.preventDefault();
-  }
-  onBeforeUnmount(stop);
+  const gesture = createGesture({
+    enabled: options.enabled,
+    pointerTypes: ["touch"],
+    longPress: { delay: options.delay, handler: () => options.onHold() }
+  });
+  onBeforeUnmount(gesture.dispose);
   return {
     /** Drops a hold in progress, as if the finger had been lifted off the screen. */
-    cancel: () => onPointerCancel(),
-    handlers: { onPointerdown: onPointerDown, onPointermove: onPointerMove, onPointerup: onPointerUp, onPointercancel: onPointerCancel, onClickCapture, onContextmenu: onContextMenu }
+    cancel: gesture.cancel,
+    handlers: gesture.handlers
   };
 }
 export {

package/dist/composables/useZoomPan.js

@@ -1,4 +1,5 @@
 import { clamp } from "./clamp.js";
+import { pinchFrame, distance } from "./gesture.js";
 import { ref, computed, toValue } from "vue";
 function useZoomPan(options = {}) {
   const min = options.min ?? 1;
@@ -49,9 +50,6 @@ function useZoomPan(options = {}) {
     const point = relative(e);
     zoomAbout(scale.value * (e.deltaY < 0 ? step : 1 / step), point.x, point.y);
   }
-  function distance(a, b) {
-    return Math.hypot(a.x - b.x, a.y - b.y);
-  }
   function onPointerDown(e) {
     pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
     if (pointers.size === 2) {
@@ -72,9 +70,9 @@ function useZoomPan(options = {}) {
     pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
     if (pointers.size === 2 && pinchStartDistance > 0) {
       const [a, b] = [...pointers.values()];
-      const mid = { clientX: (a.x + b.x) / 2, clientY: (a.y + b.y) / 2 };
-      const point = relative(mid);
-      zoomAbout(pinchStartScale * (distance(a, b) / pinchStartDistance), point.x, point.y);
+      const pinch = pinchFrame(a, b, pinchStartDistance);
+      const point = relative({ clientX: pinch.origin.x, clientY: pinch.origin.y });
+      zoomAbout(pinchStartScale * pinch.scale, point.x, point.y);
       return;
     }
     if (!panning.value) return;

package/dist/index.d.ts

@@ -147,6 +147,7 @@ export { default as LpRadioGroup } from "./components/LpRadioGroup.vue";
 export type { RadioOption } from "./components/LpRadioGroup.vue";
 export { default as LpRollingText } from "./components/LpRollingText.vue";
 export { default as LpScrollArea } from "./components/LpScrollArea.vue";
+export { default as LpScrollStrip } from "./components/LpScrollStrip.vue";
 export { default as LpPageScrollbar } from "./components/LpPageScrollbar.vue";
 export { default as LpSegmented } from "./components/LpSegmented.vue";
 export type { SegmentedOption } from "./components/LpSegmented.vue";
@@ -333,6 +334,12 @@ export { useTilt } from "./composables/useTilt";
 export type { UseTilt, UseTiltOptions } from "./composables/useTilt";
 export { useZoomPan } from "./composables/useZoomPan";
 export type { UseZoomPan, UseZoomPanOptions } from "./composables/useZoomPan";
+export { createGesture, glide, useGesture } from "./composables/useGesture";
+export type { Gesture, GestureEnd, GestureOptions, GesturePinch, GestureState, Glide } from "./composables/useGesture";
+export { createDragSession, createVelocityTracker, FLICK_VELOCITY, HOLD_TO_DRAG_MS, LONG_PRESS_MS, lockAxis, MOUSE_SLOP, momentumDistance, pageAfterSwipe, pinchFrame, rubberBand, rubberClamp, shouldDismiss, slopFor, swipeDirection, TOUCH_SLOP, wheelPixels, } from "./composables/gesture";
+export type { DismissOptions, DragFrame, DragSession, DragSessionOptions, GestureAxis, GesturePoint, PageSwipeOptions, PinchFrame, SwipeOptions, VelocityTracker } from "./composables/gesture";
+export { useScrollStrip } from "./composables/useScrollStrip";
+export type { ScrollStrip, ScrollStripOptions } from "./composables/useScrollStrip";
 export { useToast } from "./composables/useToast";
 export type { ToastAction, ToastItem, ToastMessage, ToastOptions, ToastVariant, } from "./composables/useToast";
 export type { ToastPromiseMessages } from "./composables/useToast";
@@ -379,6 +386,8 @@ export type { PipelineStep, StepStatus } from "./components/pipeline";
 export { default as LpLoader } from "./components/LpLoader.vue";
 export type { LoaderLabels, LoaderSize, LoaderTone, LoaderVariant } from "./components/LpLoader.vue";
 export { useLoadingGate } from "./composables/useLoadingGate";
+export { useAppUpdate } from "./composables/useAppUpdate";
+export type { AppUpdate, AppUpdateOptions } from "./composables/useAppUpdate";
 export type { LoadingGateOptions } from "./composables/useLoadingGate";
 export { useNow } from "./composables/useNow";
 export type { UseNowOptions } from "./composables/useNow";