@leavepulse/ui 0.37.3 → 0.37.4

package/dist/chunks/{LpAppShell-Cs9jDoqJ.js → LpAppShell-1rTB24lI.js}

@@ -3,7 +3,7 @@ import { _ as _sfc_main$2 } from "./LpButton-5VXXCjwF.js";
 import { _ as _sfc_main$3 } from "./LpIcon-CCnX5_2j.js";
 import { _ as _sfc_main$5 } from "./LpScrollArea-D8xyKXcF.js";
 import { _ as _sfc_main$4 } from "./LpShift-DXNsauQZ.js";
-import { _ as _sfc_main$1 } from "./LpSidebar-DvGfofv6.js";
+import { _ as _sfc_main$1 } from "./LpSidebar-DvxMte3k.js";
 import { useMergedAttrs } from "../composables/useMergedClass.js";
 const _hoisted_1 = { class: "flex min-w-0 flex-1 flex-col" };
 const _hoisted_2 = { class: "relative flex h-16 shrink-0 items-center gap-3 border-b border-line bg-surface px-4 md:px-6" };

package/dist/chunks/{LpDrawer-CslZtgUm.js → LpDrawer-E67O8fFP.js}

@@ -1,10 +1,9 @@
-import { defineComponent, computed, watch, onBeforeUnmount, ref, useSlots, openBlock, createElementBlock, Fragment, createElementVNode, normalizeStyle, normalizeClass, withDirectives, vShow, toDisplayString, createCommentVNode, createVNode, unref, withCtx, createBlock, renderSlot, createTextVNode } from "vue";
-import { usePointerSwipe } from "@vueuse/core";
+import { ref, defineComponent, computed, watch, onBeforeUnmount, useSlots, openBlock, createElementBlock, Fragment, withDirectives, createElementVNode, normalizeStyle, unref, vShow, normalizeClass, toDisplayString, createCommentVNode, renderSlot, createVNode, withCtx, createBlock, createTextVNode } from "vue";
 import { DrawerRoot, DrawerPortal, DrawerOverlay, DrawerContent, DrawerHandle, DrawerTitle, DrawerDescription, DrawerClose } from "vaul-vue";
 import { CLOSE_ICON } from "../components/dropdown.js";
 import { _ as _sfc_main$1 } from "./LpIcon-CCnX5_2j.js";
 import { _ as _sfc_main$2 } from "./LpScrollArea-D8xyKXcF.js";
-import { useModalLayer } from "../components/modalDepth.js";
+import { useModalLayer, anyModalOpen } from "../components/modalDepth.js";
 const _hoisted_1 = { class: "text-base font-semibold text-ink" };
 const _hoisted_2 = { class: "flex flex-col gap-1" };
 const _hoisted_3 = ["data-vaul-no-drag"];
@@ -12,7 +11,7 @@ const _hoisted_4 = {
   key: 3,
   class: "flex justify-end gap-2 px-5 pb-5 pt-4"
 };
-const NO_DRAG_SELECTOR = "input, textarea, select, button, a[href], label, [contenteditable=''], [contenteditable='true']";
+const edgeOwner = ref(null);
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "LpDrawer",
   props: {
@@ -104,6 +103,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       return "p-5";
     });
     const headerClass = computed(() => showHandle.value ? "px-5 pb-4 pt-1" : "px-5 pb-4 pt-5");
+    const NO_DRAG_SELECTOR = "input, textarea, select, button, a[href], label, [contenteditable=''], [contenteditable='true']";
     function tagNoDrag(el, { value }) {
       if (!value) return;
       for (const node of el.querySelectorAll(NO_DRAG_SELECTOR)) {
@@ -114,97 +114,183 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       mounted: tagNoDrag,
       updated: tagNoDrag
     };
-    const edgeStrip = ref(null);
+    const EDGE_SLOP = 10;
+    const FLICK_SPEED = 0.45;
+    const BREAKPOINT_PX = { sm: 640, md: 768, lg: 1024, xl: 1280 };
+    const EDGE_IGNORE = "input, textarea, select, [contenteditable=''], [contenteditable='true'], [data-vaul-no-drag], [data-lp-no-edge-pull]";
     const peek = ref(0);
     const peeking = ref(false);
     const handingOff = ref(false);
+    const skipOpenSlide = ref(false);
+    watch(
+      () => props.open,
+      (open) => {
+        if (!open) skipOpenSlide.value = false;
+      }
+    );
     function panelPx() {
       const vw = typeof window === "undefined" ? 0 : window.innerWidth;
       const cap = props.width ? Number.parseFloat(props.width) : SIZES[props.size] * 16;
       return Math.min(vw * 0.94, Number.isFinite(cap) ? cap : SIZES[props.size] * 16);
     }
-    usePointerSwipe(edgeStrip, {
-      threshold: 0,
-      pointerTypes: ["touch", "pen"],
-      onSwipeStart() {
-        if (!props.edgeOpen || props.open) return;
+    function edgeEnabled() {
+      if (!props.edgeOpen || !isHorizontal.value || props.open || handingOff.value) return false;
+      const bp = props.edgeBreakpoint ? BREAKPOINT_PX[props.edgeBreakpoint] : null;
+      return bp === null || window.innerWidth < bp;
+    }
+    let track = null;
+    const owner = /* @__PURE__ */ Symbol("edge-pull");
+    function reducedMotion() {
+      return typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+    }
+    function scrollsWithPull(target) {
+      let el = target instanceof Element ? target : null;
+      const pullsRight = dir.value === "left";
+      while (el && el !== document.body) {
+        if (el.closest(EDGE_IGNORE) === el) return true;
+        if (el.scrollWidth > el.clientWidth) {
+          const overflow = getComputedStyle(el).overflowX;
+          if (overflow === "auto" || overflow === "scroll") {
+            if (pullsRight ? el.scrollLeft > 0 : el.scrollLeft + el.clientWidth < el.scrollWidth) return true;
+          }
+        }
+        el = el.parentElement;
+      }
+      return false;
+    }
+    function inward(x) {
+      return dir.value === "right" ? window.innerWidth - x : x;
+    }
+    function onTouchStart(e) {
+      if (track) dropTrack();
+      if (e.touches.length !== 1 || !edgeEnabled() || anyModalOpen() || edgeOwner.value) return;
+      const t = e.touches[0];
+      if (inward(t.clientX) > props.edgeSize || scrollsWithPull(e.target)) return;
+      track = { id: t.identifier, x: t.clientX, y: t.clientY, t: e.timeStamp, lastX: t.clientX, lastT: e.timeStamp, speed: 0 };
+    }
+    function onTouchMove(e) {
+      if (!track) return;
+      const t = Array.from(e.changedTouches).find((x) => x.identifier === track.id);
+      if (!t) return;
+      const sign = dir.value === "right" ? -1 : 1;
+      const dx = (t.clientX - track.x) * sign;
+      const dy = t.clientY - track.y;
+      if (!peeking.value) {
+        if (Math.abs(dy) > EDGE_SLOP && Math.abs(dy) > Math.abs(dx)) {
+          track = null;
+          return;
+        }
+        if (dx < EDGE_SLOP || Math.abs(dx) < Math.abs(dy)) return;
+        if (edgeOwner.value && edgeOwner.value !== owner) {
+          track = null;
+          return;
+        }
+        edgeOwner.value = owner;
         peeking.value = true;
-      },
-      onSwipe(e) {
-        if (!peeking.value) return;
-        const fromRight = dir.value === "right";
-        const dx = fromRight ? window.innerWidth - e.clientX : e.clientX;
-        peek.value = Math.max(0, Math.min(1, dx / panelPx()));
-      },
-      onSwipeEnd() {
-        if (!peeking.value) return;
-        peeking.value = false;
-        if (peek.value >= props.edgeOpenThreshold) {
-          peek.value = 1;
-          handingOff.value = true;
+      }
+      if (e.cancelable) e.preventDefault();
+      const dt = e.timeStamp - track.lastT;
+      if (dt > 0) track.speed = (t.clientX - track.lastX) * sign / dt * 0.6 + track.speed * 0.4;
+      track.lastX = t.clientX;
+      track.lastT = e.timeStamp;
+      peek.value = Math.max(0, Math.min(1, inward(t.clientX) / panelPx()));
+    }
+    function dropTrack() {
+      track = null;
+      if (edgeOwner.value === owner) edgeOwner.value = null;
+    }
+    function settle() {
+      const flick = track !== null && track.speed > FLICK_SPEED && peek.value > 0.05;
+      dropTrack();
+      if (!peeking.value) return;
+      peeking.value = false;
+      if (peek.value >= props.edgeOpenThreshold || flick) {
+        peek.value = 1;
+        handingOff.value = true;
+        skipOpenSlide.value = true;
+        timers.push(
           window.setTimeout(() => {
             emit("update:open", true);
-            window.setTimeout(() => {
-              handingOff.value = false;
-              peek.value = 0;
-            }, 60);
-          }, 160);
-        } else {
-          peek.value = 0;
-        }
+            timers.push(
+              window.setTimeout(() => {
+                handingOff.value = false;
+                peek.value = 0;
+              }, 60)
+            );
+          }, reducedMotion() ? 0 : 180)
+        );
+      } else {
+        peek.value = 0;
       }
+    }
+    const timers = [];
+    onBeforeUnmount(() => {
+      for (const id of timers) window.clearTimeout(id);
+      if (edgeOwner.value === owner) edgeOwner.value = null;
     });
+    function onTouchEnd(e) {
+      if (track && !Array.from(e.changedTouches).some((x) => x.identifier === track.id)) return;
+      settle();
+    }
+    if (typeof document !== "undefined") {
+      watch(
+        () => props.edgeOpen && isHorizontal.value,
+        (on, _, onCleanup) => {
+          if (!on) return;
+          const passive = { passive: true };
+          document.addEventListener("touchstart", onTouchStart, passive);
+          document.addEventListener("touchmove", onTouchMove, { passive: false });
+          document.addEventListener("touchend", onTouchEnd, passive);
+          document.addEventListener("touchcancel", onTouchEnd, passive);
+          onCleanup(() => {
+            document.removeEventListener("touchstart", onTouchStart);
+            document.removeEventListener("touchmove", onTouchMove);
+            document.removeEventListener("touchend", onTouchEnd);
+            document.removeEventListener("touchcancel", onTouchEnd);
+          });
+        },
+        { immediate: true }
+      );
+    }
     const previewStyle = computed(() => {
       if (!props.edgeOpen || props.open && !handingOff.value) return { display: "none" };
       const off = (1 - peek.value) * 100;
       const axis = dir.value === "right" ? off : -off;
       return {
         transform: `translateX(${axis}%)`,
-        transition: peeking.value ? "none" : "transform 0.16s ease-out",
+        transition: peeking.value || reducedMotion() ? "none" : "transform 0.18s cubic-bezier(0.32, 0.72, 0, 1)",
         pointerEvents: "none"
       };
     });
-    const edgeStripStyle = computed(() => {
-      const w = `${props.edgeSize}px`;
-      return dir.value === "right" ? { right: "0", width: w } : { left: "0", width: w };
-    });
-    const EDGE_STRIP_HIDDEN = {
-      sm: "sm:hidden",
-      md: "md:hidden",
-      lg: "lg:hidden",
-      xl: "xl:hidden"
-    };
-    const edgeStripClass = computed(
-      () => props.edgeBreakpoint ? EDGE_STRIP_HIDDEN[props.edgeBreakpoint] : ""
-    );
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock(Fragment, null, [
         __props.edgeOpen && isHorizontal.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
-          createElementVNode("div", {
-            ref_key: "edgeStrip",
-            ref: edgeStrip,
-            class: normalizeClass(["fixed inset-y-0 z-(--z-overlay) touch-none", edgeStripClass.value]),
-            style: normalizeStyle(edgeStripStyle.value),
-            "aria-hidden": "true"
-          }, null, 6),
           withDirectives(createElementVNode("div", {
-            class: "pointer-events-none fixed inset-0 z-(--z-overlay) bg-black/50",
-            style: normalizeStyle({ opacity: peek.value })
+            class: "lp-scrim pointer-events-none fixed inset-0",
+            style: normalizeStyle({ zIndex: unref(layer).scrim, opacity: peek.value, transition: peeking.value || reducedMotion() ? "none" : "opacity 0.18s ease-out" })
           }, null, 4), [
             [vShow, peeking.value || peek.value > 0]
           ]),
-          createElementVNode("div", {
+          withDirectives(createElementVNode("div", {
             class: normalizeClass(contentClass.value),
-            style: normalizeStyle([sizeStyle.value, previewStyle.value]),
-            "aria-hidden": "true"
+            style: normalizeStyle([sizeStyle.value, previewStyle.value, { zIndex: unref(layer).panel }]),
+            "aria-hidden": "true",
+            inert: ""
           }, [
-            hasHeader.value ? (openBlock(), createElementBlock("div", {
+            hasHeader.value ? (openBlock(), createElementBlock("header", {
               key: 0,
               class: normalizeClass(["flex items-start justify-between gap-4", headerClass.value])
             }, [
               createElementVNode("span", _hoisted_1, toDisplayString(__props.title), 1)
-            ], 2)) : createCommentVNode("", true)
-          ], 6)
+            ], 2)) : createCommentVNode("", true),
+            createElementVNode("div", {
+              class: normalizeClass(["flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden", padClass.value])
+            }, [
+              peeking.value || peek.value > 0 ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true)
+            ], 2)
+          ], 6), [
+            [vShow, peeking.value || peek.value > 0]
+          ])
         ], 64)) : createCommentVNode("", true),
         createVNode(unref(DrawerRoot), {
           open: __props.open,
@@ -226,7 +312,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 createVNode(unref(DrawerContent), {
                   class: normalizeClass(contentClass.value),
                   style: normalizeStyle([sizeStyle.value, { zIndex: unref(layer).panel }]),
-                  "data-vaul-animate": handingOff.value ? "false" : void 0
+                  "data-vaul-animate": handingOff.value || skipOpenSlide.value ? "false" : void 0
                 }, {
                   default: withCtx(() => [
                     __props.resizable && isHorizontal.value ? (openBlock(), createElementBlock("div", {

package/dist/chunks/{LpModalNav-Dkogc3O_.js → LpModalNav--a3i7c89.js}

@@ -2,7 +2,7 @@ import { defineComponent, ref, computed, openBlock, createBlock, createSlots, wi
 import { _ as _sfc_main$2 } from "./LpButton-5VXXCjwF.js";
 import { _ as _sfc_main$3 } from "./LpIcon-CCnX5_2j.js";
 import { _ as _sfc_main$1 } from "./LpModal-D3QxgWaT.js";
-import { _ as _sfc_main$4 } from "./LpSidebar-DvGfofv6.js";
+import { _ as _sfc_main$4 } from "./LpSidebar-DvxMte3k.js";
 const _hoisted_1 = { class: "flex items-center gap-2" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "LpModalNav",

package/dist/chunks/{LpSidebar-DvGfofv6.js → LpSidebar-DvxMte3k.js}

@@ -1,5 +1,5 @@
 import { defineComponent, computed, ref, useId, openBlock, createElementBlock, Fragment, createElementVNode, mergeProps, normalizeClass, renderSlot, createCommentVNode, createBlock, createVNode, createSlots, withCtx, normalizeProps, guardReactiveProps } from "vue";
-import { _ as _sfc_main$3 } from "./LpDrawer-CslZtgUm.js";
+import { _ as _sfc_main$3 } from "./LpDrawer-E67O8fFP.js";
 import { _ as _sfc_main$1 } from "./LpInput-9EXWUM9B.js";
 import { _ as _sfc_main$2 } from "./LpSidebarNav-CqwvT4H8.js";
 const _hoisted_1 = {

package/dist/components/LpAppShell.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpAppShell-Cs9jDoqJ.js";
+import { _ as _sfc_main } from "../chunks/LpAppShell-1rTB24lI.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpDrawer.vue.d.ts

@@ -1,8 +1,9 @@
-type Direction = "top" | "bottom" | "left" | "right";
-type __VLS_Props = {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<{
     open?: boolean;
     /** Edge the drawer attaches to. `side` is a back-compat alias (left/right). */
-    direction?: Direction;
+    direction?: "left" | "right" | "top" | "bottom";
     side?: "left" | "right";
     title?: string;
     description?: string;
@@ -35,21 +36,20 @@ type __VLS_Props = {
      */
     noDragContent?: boolean;
     /**
-     * Open by dragging in from the screen edge (Discord-style). Renders an
-     * invisible edge strip; a pull from it drags a preview panel that follows
-     * the finger, and a release past `edgeOpenThreshold` opens the drawer. Only
-     * meaningful for left/right drawers.
+     * Open by dragging in from the screen edge (Discord-style). A touch that
+     * starts within `edgeSize` of the edge and travels inward drags a preview of
+     * the panel (with its content) under the finger; a release past
+     * `edgeOpenThreshold`, or a quick flick, opens the drawer. Nothing is laid
+     * over the edge, so taps there still reach the page. Left/right drawers only.
      */
     edgeOpen?: boolean;
     /**
-     * Tailwind breakpoint above which the edge strip is disabled. Edge
-     * swipe-to-open only makes sense on mobile: the strip listens for
-     * touch/pen pointers only, so on a desktop it can never open the drawer
-     * but still overlays the screen edge and swallows clicks. Pass the same
-     * breakpoint at which the host switches to the drawer (LpSidebar does).
+     * Tailwind breakpoint at and above which the edge pull is ignored. Pass the
+     * same breakpoint at which the host switches to the drawer (LpSidebar
+     * does), so a wide touch screen with the rail visible doesn't pull it too.
      */
     edgeBreakpoint?: "sm" | "md" | "lg" | "xl";
-    /** Width (px) of the edge grab strip. */
+    /** Distance (px) from the edge within which a touch can start a pull. */
     edgeSize?: number;
     /** Fraction (0–1) of the panel width the pull must reach to open on release. */
     edgeOpenThreshold?: number;
@@ -63,18 +63,72 @@ type __VLS_Props = {
     minSize?: string;
     /** Max main-axis size while resizing (any CSS length). Default 96vw. */
     maxSize?: string;
-};
-declare var __VLS_37: {}, __VLS_62: {}, __VLS_64: {};
-type __VLS_Slots = {} & {
-    title?: (props: typeof __VLS_37) => any;
-} & {
-    default?: (props: typeof __VLS_62) => any;
-} & {
-    footer?: (props: typeof __VLS_64) => any;
-};
-declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     "update:open": (value: boolean) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<{
+    open?: boolean;
+    /** Edge the drawer attaches to. `side` is a back-compat alias (left/right). */
+    direction?: "left" | "right" | "top" | "bottom";
+    side?: "left" | "right";
+    title?: string;
+    description?: string;
+    /** Size preset along the drawer's main axis (width for left/right, height for top/bottom). */
+    size?: "sm" | "md" | "lg" | "xl";
+    /** Explicit size override (any CSS length), wins over `size`. */
+    width?: string;
+    /** Drag-to-dismiss + click-outside. Set false to force a controlled close. */
+    dismissible?: boolean;
+    /** Fractions (0–1) or px strings the drawer snaps between, nearest edge first. */
+    snapPoints?: (number | string)[];
+    /** Show the drag handle (auto-on for bottom/top sheets). */
+    handle?: boolean;
+    /** Only the handle initiates a drag — frees inner content to scroll. */
+    handleOnly?: boolean;
+    /** Scale the [vaul-drawer-wrapper] background while open. */
+    scaleBackground?: boolean;
+    /** Drag fraction (0–1) past which a release dismisses. */
+    closeThreshold?: number;
+    /**
+     * Auto-tag interactive descendants (input, textarea, select, button, links,
+     * [contenteditable]) with data-vaul-no-drag so a drag can't start on them —
+     * you can select text / use controls without dragging the drawer. On by
+     * default; the drawer still drags from empty space, the handle and header.
+     */
+    noDragControls?: boolean;
+    /**
+     * Mark the entire body as non-draggable: the drawer then only drags from the
+     * handle/header. Stronger than noDragControls — use for form-heavy drawers.
+     */
+    noDragContent?: boolean;
+    /**
+     * Open by dragging in from the screen edge (Discord-style). A touch that
+     * starts within `edgeSize` of the edge and travels inward drags a preview of
+     * the panel (with its content) under the finger; a release past
+     * `edgeOpenThreshold`, or a quick flick, opens the drawer. Nothing is laid
+     * over the edge, so taps there still reach the page. Left/right drawers only.
+     */
+    edgeOpen?: boolean;
+    /**
+     * Tailwind breakpoint at and above which the edge pull is ignored. Pass the
+     * same breakpoint at which the host switches to the drawer (LpSidebar
+     * does), so a wide touch screen with the rail visible doesn't pull it too.
+     */
+    edgeBreakpoint?: "sm" | "md" | "lg" | "xl";
+    /** Distance (px) from the edge within which a touch can start a pull. */
+    edgeSize?: number;
+    /** Fraction (0–1) of the panel width the pull must reach to open on release. */
+    edgeOpenThreshold?: number;
+    /**
+     * Let the user drag the inner edge to resize the panel (horizontal drawers
+     * only — e.g. a logs panel whose long lines overflow). The new size is kept
+     * for the session. Min/max bound the drag.
+     */
+    resizable?: boolean;
+    /** Min main-axis size while resizing (any CSS length). Default 22rem. */
+    minSize?: string;
+    /** Max main-axis size while resizing (any CSS length). Default 96vw. */
+    maxSize?: string;
+}> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg" | "xl";
@@ -85,10 +139,15 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {},
     edgeOpenThreshold: number;
     minSize: string;
     maxSize: string;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default: typeof __VLS_export;
-export default _default;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+} & {
+    title?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    footer?: (props: {}) => any;
+}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/LpDrawer.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpDrawer-CslZtgUm.js";
+import { _ as _sfc_main } from "../chunks/LpDrawer-E67O8fFP.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpModalNav.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpModalNav-Dkogc3O_.js";
+import { _ as _sfc_main } from "../chunks/LpModalNav--a3i7c89.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpSidebar.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpSidebar-DvGfofv6.js";
+import { _ as _sfc_main } from "../chunks/LpSidebar-DvxMte3k.js";
 export {
   _sfc_main as default
 };

package/dist/components/modalDepth.d.ts

@@ -11,3 +11,5 @@ export declare function useModalLayer(): {
         panel: string;
     }>;
 };
+/** True while any dialog or drawer holds a level — e.g. to keep a gesture from opening another one over it. */
+export declare function anyModalOpen(): boolean;

package/dist/components/modalDepth.js

@@ -24,6 +24,10 @@ function useModalLayer() {
     })
   };
 }
+function anyModalOpen() {
+  return stack.value.length > 0;
+}
 export {
+  anyModalOpen,
   useModalLayer
 };

package/dist/index.js

@@ -4,7 +4,7 @@ import { _ as _3 } from "./chunks/LpMapPicker-ul4oYno6.js";
 import { OSM_TILES, createNominatimProvider, emptyAddress, formatAddress, project, tileUrl, unproject } from "./components/address.js";
 import { _ as _4 } from "./chunks/LpActionBar-BlvtGB2P.js";
 import { _ as _5 } from "./chunks/LpAlert-BAYHDSS1.js";
-import { _ as _6 } from "./chunks/LpAppShell-Cs9jDoqJ.js";
+import { _ as _6 } from "./chunks/LpAppShell-1rTB24lI.js";
 import { _ as _7 } from "./chunks/LpAutocomplete-DExlIZe_.js";
 import { _ as _8 } from "./chunks/LpAvatar-D3l4nabg.js";
 import { _ as _9 } from "./chunks/LpBadge-Fe0D1bYx.js";
@@ -24,7 +24,7 @@ import { _ as _18 } from "./chunks/LpContextMenu-B6WBLleS.js";
 import { _ as _19 } from "./chunks/LpDatePicker-BPbvu3cZ.js";
 import { _ as _20 } from "./chunks/LpDisclosure-ChQYmjlR.js";
 import { _ as _21 } from "./chunks/LpDivider-CUX46KR0.js";
-import { _ as _22 } from "./chunks/LpDrawer-CslZtgUm.js";
+import { _ as _22 } from "./chunks/LpDrawer-E67O8fFP.js";
 import { _ as _23 } from "./chunks/LpDropdownMenu-DJpoqRCb.js";
 import { default as default4 } from "./components/LpDropzone.vue.js";
 import { _ as _24 } from "./chunks/LpEmptyState-Dsdqz1Wj.js";
@@ -41,7 +41,7 @@ import { _ as _31 } from "./chunks/LpLink-DCND-zyu.js";
 import { _ as _32 } from "./chunks/LpLogViewer-y53ZqSVq.js";
 import { _ as _33 } from "./chunks/LpMediaGallery-Cid7PGYx.js";
 import { _ as _34 } from "./chunks/LpModal-D3QxgWaT.js";
-import { _ as _35 } from "./chunks/LpModalNav-Dkogc3O_.js";
+import { _ as _35 } from "./chunks/LpModalNav--a3i7c89.js";
 import { _ as _36 } from "./chunks/LpNotificationBell-lHePf89W.js";
 import { _ as _37 } from "./chunks/LpNumberField-CWuX08iX.js";
 import { _ as _38 } from "./chunks/LpNumberFlow-amWYaeuA.js";
@@ -63,7 +63,7 @@ import { _ as _52 } from "./chunks/LpSelect-ANIVtrpM.js";
 import { _ as _53 } from "./chunks/LpServiceNode-D8uJ8sGk.js";
 import { _ as _54 } from "./chunks/LpShift-DXNsauQZ.js";
 import { default as default6 } from "./components/LpShortcutsDialog.vue.js";
-import { _ as _55 } from "./chunks/LpSidebar-DvGfofv6.js";
+import { _ as _55 } from "./chunks/LpSidebar-DvxMte3k.js";
 import { _ as _56 } from "./chunks/LpSkeleton-CTI-vBgW.js";
 import { _ as _57 } from "./chunks/LpSlider-BwNIBkAK.js";
 import { _ as _58 } from "./chunks/LpSparkline-C6xQ2dwv.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leavepulse/ui",
-  "version": "0.37.3",
+  "version": "0.37.4",
   "type": "module",
   "description": "LeavePulse token-driven Vue component kit.",
   "repository": {

package/src/components/LpDrawer.vue

@@ -1,3 +1,10 @@
+<script lang="ts">
+import { ref as sharedRef } from "vue"
+
+// One pull at a time across every edge-open drawer on the page.
+const edgeOwner = sharedRef<symbol | null>(null)
+</script>
+
 <script setup lang="ts">
 /*
  * Side / bottom panel built on vaul-vue (drag-driven drawer over reka's Dialog
@@ -12,7 +19,6 @@
  * solid background) for vaul to find and transform. Without it the drawer still
  * works — the background just doesn't scale.
  */
-import { usePointerSwipe } from "@vueuse/core"
 import {
   DrawerClose,
   DrawerContent,
@@ -27,7 +33,7 @@ import { computed, onBeforeUnmount, ref, useSlots, watch } from "vue"
 import { CLOSE_ICON } from "./dropdown"
 import LpIcon from "./LpIcon.vue"
 import LpScrollArea from "./LpScrollArea.vue"
-import { useModalLayer } from "./modalDepth"
+import { anyModalOpen, useModalLayer } from "./modalDepth"
 
 type Direction = "top" | "bottom" | "left" | "right"
 
@@ -68,21 +74,20 @@ const props = withDefaults(
      */
     noDragContent?: boolean
     /**
-     * Open by dragging in from the screen edge (Discord-style). Renders an
-     * invisible edge strip; a pull from it drags a preview panel that follows
-     * the finger, and a release past `edgeOpenThreshold` opens the drawer. Only
-     * meaningful for left/right drawers.
+     * Open by dragging in from the screen edge (Discord-style). A touch that
+     * starts within `edgeSize` of the edge and travels inward drags a preview of
+     * the panel (with its content) under the finger; a release past
+     * `edgeOpenThreshold`, or a quick flick, opens the drawer. Nothing is laid
+     * over the edge, so taps there still reach the page. Left/right drawers only.
      */
     edgeOpen?: boolean
     /**
-     * Tailwind breakpoint above which the edge strip is disabled. Edge
-     * swipe-to-open only makes sense on mobile: the strip listens for
-     * touch/pen pointers only, so on a desktop it can never open the drawer
-     * but still overlays the screen edge and swallows clicks. Pass the same
-     * breakpoint at which the host switches to the drawer (LpSidebar does).
+     * Tailwind breakpoint at and above which the edge pull is ignored. Pass the
+     * same breakpoint at which the host switches to the drawer (LpSidebar
+     * does), so a wide touch screen with the rail visible doesn't pull it too.
      */
     edgeBreakpoint?: "sm" | "md" | "lg" | "xl"
-    /** Width (px) of the edge grab strip. */
+    /** Distance (px) from the edge within which a touch can start a pull. */
     edgeSize?: number
     /** Fraction (0–1) of the panel width the pull must reach to open on release. */
     edgeOpenThreshold?: number
@@ -226,19 +231,40 @@ const vNoDragControls = {
 }
 
 // ── Edge-drag-to-open (Discord-style) ──────────────────────────────────────
-// vaul opens/closes programmatically and only drags an *already-open* drawer,
-// so the pull-from-edge gesture is ours: an invisible edge strip captures the
-// pointer, we translate a preview panel that follows the finger, and a release
-// past the threshold flips `open` (vaul then animates the rest). Horizontal
-// drawers only.
-const edgeStrip = ref<HTMLElement | null>(null)
-// 0 (closed) … 1 (fully pulled in). Drives the preview transform + overlay.
+// vaul only drags an *already-open* drawer, so the pull-from-edge gesture is
+// ours. It is detected on the document rather than on an overlay strip: a strip
+// covering the screen edge swallowed every tap there, and the app burger lives
+// exactly in that corner. A touch near the edge is only a candidate; it becomes
+// a pull once the finger travels inward past EDGE_SLOP and mostly sideways, so a
+// tap still reaches the control under it and a vertical scroll stays a scroll.
+// While pulling, a preview of the real panel content follows the finger; on
+// release we open if the pull passed the threshold or was a quick flick, then
+// hand off to the real drawer without a second slide.
+const EDGE_SLOP = 10
+const FLICK_SPEED = 0.45
+const BREAKPOINT_PX = { sm: 640, md: 768, lg: 1024, xl: 1280 } as const
+// Controls whose own drag must win over the pull, plus explicit opt-outs.
+const EDGE_IGNORE =
+  "input, textarea, select, [contenteditable=''], [contenteditable='true'], [data-vaul-no-drag], [data-lp-no-edge-pull]"
+
+// 0 (closed) … 1 (fully pulled in). Drives the preview transform + scrim.
 const peek = ref(0)
 const peeking = ref(false)
 // True while we hand off from the finger-preview to the real drawer, so vaul's
 // own open animation is suppressed — the preview has already slid it in, a
 // second slide would look like a double-open.
 const handingOff = ref(false)
+// vaul plays slideFromLeft whenever data-vaul-animate is absent, so lifting it
+// right after the hand-off restarted the open slide from off-screen — the panel
+// visibly opened twice. It stays on for as long as the drawer is open and goes
+// with the close, which keeps vaul's close animation.
+const skipOpenSlide = ref(false)
+watch(
+  () => props.open,
+  (open) => {
+    if (!open) skipOpenSlide.value = false
+  },
+)
 
 // Resolve the panel's main-axis size in px to map drag distance → progress.
 function panelPx(): number {
@@ -248,44 +274,140 @@ function panelPx(): number {
   return Math.min(vw * 0.94, Number.isFinite(cap) ? cap : SIZES[props.size] * 16)
 }
 
-usePointerSwipe(edgeStrip, {
-  threshold: 0,
-  pointerTypes: ["touch", "pen"],
-  onSwipeStart() {
-    if (!props.edgeOpen || props.open) return
+function edgeEnabled(): boolean {
+  if (!props.edgeOpen || !isHorizontal.value || props.open || handingOff.value) return false
+  const bp = props.edgeBreakpoint ? BREAKPOINT_PX[props.edgeBreakpoint] : null
+  return bp === null || window.innerWidth < bp
+}
+
+let track: { id: number; x: number; y: number; t: number; lastX: number; lastT: number; speed: number } | null = null
+const owner = Symbol("edge-pull")
+
+function reducedMotion(): boolean {
+  return typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches
+}
+
+// A horizontally scrollable ancestor that can still move the way the finger
+// pulls (a carousel, a wide table) keeps the gesture: the pull only claims
+// what nothing under the finger wants.
+function scrollsWithPull(target: EventTarget | null): boolean {
+  let el = target instanceof Element ? target : null
+  const pullsRight = dir.value === "left"
+  while (el && el !== document.body) {
+    if (el.closest(EDGE_IGNORE) === el) return true
+    if (el.scrollWidth > el.clientWidth) {
+      const overflow = getComputedStyle(el).overflowX
+      if (overflow === "auto" || overflow === "scroll") {
+        if (pullsRight ? el.scrollLeft > 0 : el.scrollLeft + el.clientWidth < el.scrollWidth) return true
+      }
+    }
+    el = el.parentElement
+  }
+  return false
+}
+
+function inward(x: number): number {
+  return dir.value === "right" ? window.innerWidth - x : x
+}
+
+function onTouchStart(e: TouchEvent) {
+  if (track) dropTrack()
+  if (e.touches.length !== 1 || !edgeEnabled() || anyModalOpen() || edgeOwner.value) return
+  const t = e.touches[0]
+  if (inward(t.clientX) > props.edgeSize || scrollsWithPull(e.target)) return
+  track = { id: t.identifier, x: t.clientX, y: t.clientY, t: e.timeStamp, lastX: t.clientX, lastT: e.timeStamp, speed: 0 }
+}
+
+function onTouchMove(e: TouchEvent) {
+  if (!track) return
+  const t = Array.from(e.changedTouches).find((x) => x.identifier === track!.id)
+  if (!t) return
+  const sign = dir.value === "right" ? -1 : 1
+  const dx = (t.clientX - track.x) * sign
+  const dy = t.clientY - track.y
+  if (!peeking.value) {
+    if (Math.abs(dy) > EDGE_SLOP && Math.abs(dy) > Math.abs(dx)) {
+      track = null
+      return
+    }
+    if (dx < EDGE_SLOP || Math.abs(dx) < Math.abs(dy)) return
+    if (edgeOwner.value && edgeOwner.value !== owner) {
+      track = null
+      return
+    }
+    edgeOwner.value = owner
     peeking.value = true
-  },
-  onSwipe(e) {
-    if (!peeking.value) return
-    // Inward pull distance: from the right edge we move left (−x), from the
-    // left edge we move right (+x). Normalise to 0…1 of the panel width.
-    const fromRight = dir.value === "right"
-    const dx = fromRight ? window.innerWidth - e.clientX : e.clientX
-    peek.value = Math.max(0, Math.min(1, dx / panelPx()))
-  },
-  onSwipeEnd() {
-    if (!peeking.value) return
-    peeking.value = false
-    if (peek.value >= props.edgeOpenThreshold) {
-      // Open: let the preview finish sliding to fully-in, then swap in the real
-      // drawer *without* a vaul slide (handingOff) so there's no second anim.
-      peek.value = 1
-      handingOff.value = true
+  }
+  if (e.cancelable) e.preventDefault()
+  const dt = e.timeStamp - track.lastT
+  if (dt > 0) track.speed = (((t.clientX - track.lastX) * sign) / dt) * 0.6 + track.speed * 0.4
+  track.lastX = t.clientX
+  track.lastT = e.timeStamp
+  peek.value = Math.max(0, Math.min(1, inward(t.clientX) / panelPx()))
+}
+
+function dropTrack() {
+  track = null
+  if (edgeOwner.value === owner) edgeOwner.value = null
+}
+
+function settle() {
+  const flick = track !== null && track.speed > FLICK_SPEED && peek.value > 0.05
+  dropTrack()
+  if (!peeking.value) return
+  peeking.value = false
+  if (peek.value >= props.edgeOpenThreshold || flick) {
+    peek.value = 1
+    handingOff.value = true
+    skipOpenSlide.value = true
+    timers.push(
       window.setTimeout(() => {
         emit("update:open", true)
-        // Clear after the real drawer has mounted in place.
-        window.setTimeout(() => {
-          handingOff.value = false
-          peek.value = 0
-        }, 60)
-      }, 160)
-    } else {
-      // Below threshold: snap the preview back out.
-      peek.value = 0
-    }
-  },
+        timers.push(
+          window.setTimeout(() => {
+            handingOff.value = false
+            peek.value = 0
+          }, 60),
+        )
+      }, reducedMotion() ? 0 : 180),
+    )
+  } else {
+    peek.value = 0
+  }
+}
+
+const timers: number[] = []
+onBeforeUnmount(() => {
+  for (const id of timers) window.clearTimeout(id)
+  if (edgeOwner.value === owner) edgeOwner.value = null
 })
 
+function onTouchEnd(e: TouchEvent) {
+  if (track && !Array.from(e.changedTouches).some((x) => x.identifier === track!.id)) return
+  settle()
+}
+
+if (typeof document !== "undefined") {
+  watch(
+    () => props.edgeOpen && isHorizontal.value,
+    (on, _, onCleanup) => {
+      if (!on) return
+      const passive = { passive: true }
+      document.addEventListener("touchstart", onTouchStart, passive)
+      document.addEventListener("touchmove", onTouchMove, { passive: false })
+      document.addEventListener("touchend", onTouchEnd, passive)
+      document.addEventListener("touchcancel", onTouchEnd, passive)
+      onCleanup(() => {
+        document.removeEventListener("touchstart", onTouchStart)
+        document.removeEventListener("touchmove", onTouchMove)
+        document.removeEventListener("touchend", onTouchEnd)
+        document.removeEventListener("touchcancel", onTouchEnd)
+      })
+    },
+    { immediate: true },
+  )
+}
+
 // The preview panel slides with the finger: translate from fully-off (100%)
 // toward 0 as peek → 1. Kept visible through the hand-off so the real drawer
 // can appear underneath without a flash.
@@ -295,51 +417,34 @@ const previewStyle = computed(() => {
   const axis = dir.value === "right" ? off : -off
   return {
     transform: `translateX(${axis}%)`,
-    transition: peeking.value ? "none" : "transform 0.16s ease-out",
+    transition: peeking.value || reducedMotion() ? "none" : "transform 0.18s cubic-bezier(0.32, 0.72, 0, 1)",
     pointerEvents: "none" as const,
   }
 })
-
-const edgeStripStyle = computed(() => {
-  const w = `${props.edgeSize}px`
-  return dir.value === "right"
-    ? { right: "0", width: w }
-    : { left: "0", width: w }
-})
-
-// The strip must only exist below the host's mobile breakpoint. It is hidden
-// with the same Tailwind breakpoint classes the rest of the mobile logic
-// (LpSidebar rail, burger) uses — no JS media query needed.
-const EDGE_STRIP_HIDDEN: Record<NonNullable<typeof props.edgeBreakpoint>, string> = {
-  sm: "sm:hidden",
-  md: "md:hidden",
-  lg: "lg:hidden",
-  xl: "xl:hidden",
-}
-const edgeStripClass = computed(() =>
-  props.edgeBreakpoint ? EDGE_STRIP_HIDDEN[props.edgeBreakpoint] : "",
-)
 </script>
 
 <template>
-  <!-- Edge-drag-to-open: an invisible grab strip + a finger-following preview
-       of the panel, shown only while closed. Horizontal drawers only. -->
+  <!-- Edge-drag-to-open: a finger-following preview of the panel (with its
+       real content, inert) and a scrim that darkens with the pull. Nothing
+       overlays the screen edge, so taps there reach the page. -->
   <template v-if="edgeOpen && isHorizontal">
     <div
-      ref="edgeStrip"
-      class="fixed inset-y-0 z-(--z-overlay) touch-none"
-      :class="edgeStripClass"
-      :style="edgeStripStyle"
-      aria-hidden="true"
+      v-show="peeking || peek > 0"
+      class="lp-scrim pointer-events-none fixed inset-0"
+      :style="{ zIndex: layer.scrim, opacity: peek, transition: peeking || reducedMotion() ? 'none' : 'opacity 0.18s ease-out' }"
     />
     <div
       v-show="peeking || peek > 0"
-      class="pointer-events-none fixed inset-0 z-(--z-overlay) bg-black/50"
-      :style="{ opacity: peek }"
-    />
-    <div :class="contentClass" :style="[sizeStyle, previewStyle]" aria-hidden="true">
-      <div v-if="hasHeader" class="flex items-start justify-between gap-4" :class="headerClass">
+      :class="contentClass"
+      :style="[sizeStyle, previewStyle, { zIndex: layer.panel }]"
+      aria-hidden="true"
+      inert
+    >
+      <header v-if="hasHeader" class="flex items-start justify-between gap-4" :class="headerClass">
         <span class="text-base font-semibold text-ink">{{ title }}</span>
+      </header>
+      <div class="flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden" :class="padClass">
+        <slot v-if="peeking || peek > 0" />
       </div>
     </div>
   </template>
@@ -362,7 +467,7 @@ const edgeStripClass = computed(() =>
       <DrawerContent
         :class="contentClass"
         :style="[sizeStyle, { zIndex: layer.panel }]"
-        :data-vaul-animate="handingOff ? 'false' : undefined"
+        :data-vaul-animate="handingOff || skipOpenSlide ? 'false' : undefined"
       >
         <!-- Resize grip on the inner edge (horizontal drawers). data-vaul-no-drag
              so grabbing it resizes the panel instead of starting a vaul drag. -->

package/src/components/modalDepth.ts

@@ -77,3 +77,8 @@ export function useModalLayer(): {
     }),
   }
 }
+
+/** True while any dialog or drawer holds a level — e.g. to keep a gesture from opening another one over it. */
+export function anyModalOpen(): boolean {
+  return stack.value.length > 0
+}