@surdeddd/bottom-sheet 0.12.0 → 0.13.0

package/dist/features.cjs

@@ -0,0 +1,533 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+
+// src/core/features/history-coordinator.ts
+var entries = [];
+var subscribers = /* @__PURE__ */ new Set();
+var suppress = 0;
+var internalDepth = 0;
+var pendingRebrands = [];
+var listenerInstalled = false;
+var patchInstalled = false;
+var origPushState = null;
+var origReplaceState = null;
+var patchedPushState = null;
+var patchedReplaceState = null;
+var hasWindow = () => typeof window !== "undefined";
+var hasHistory = () => typeof history !== "undefined";
+var brandMarker = (surface) => ({
+  ...surface.markerState(),
+  __bs: true
+});
+var runInternal = (fn) => {
+  internalDepth += 1;
+  try {
+    fn();
+  } finally {
+    internalDepth -= 1;
+  }
+};
+var notifyRouteChange = () => {
+  const snapshot = Array.from(subscribers);
+  for (const fn of snapshot) fn();
+};
+var ensureListener = () => {
+  if (listenerInstalled || !hasWindow()) return;
+  window.addEventListener("popstate", onPopState);
+  listenerInstalled = true;
+};
+var maybeTeardownListener = () => {
+  if (!listenerInstalled) return;
+  if (entries.length > 0 || subscribers.size > 0 || suppress > 0) return;
+  if (hasWindow()) window.removeEventListener("popstate", onPopState);
+  listenerInstalled = false;
+};
+var installPatch = () => {
+  if (patchInstalled || !hasHistory()) return;
+  origPushState = history.pushState;
+  origReplaceState = history.replaceState;
+  patchedPushState = function(...args) {
+    origPushState.apply(this, args);
+    if (internalDepth === 0) notifyRouteChange();
+  };
+  patchedReplaceState = function(...args) {
+    origReplaceState.apply(this, args);
+    if (internalDepth === 0) notifyRouteChange();
+  };
+  history.pushState = patchedPushState;
+  history.replaceState = patchedReplaceState;
+  patchInstalled = true;
+};
+var removePatch = () => {
+  if (!patchInstalled) return;
+  if (history.pushState === patchedPushState && origPushState) {
+    history.pushState = origPushState;
+  }
+  if (history.replaceState === patchedReplaceState && origReplaceState) {
+    history.replaceState = origReplaceState;
+  }
+  origPushState = null;
+  origReplaceState = null;
+  patchedPushState = null;
+  patchedReplaceState = null;
+  patchInstalled = false;
+};
+function onPopState() {
+  if (suppress > 0) {
+    suppress -= 1;
+    const rebrand = pendingRebrands.shift();
+    if (rebrand) rebrand();
+    maybeTeardownListener();
+    return;
+  }
+  if (entries.length === 0) {
+    notifyRouteChange();
+    maybeTeardownListener();
+    return;
+  }
+  let target = null;
+  let targetIdx = -1;
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (!entry.surface.isOpen()) continue;
+    if (!target) {
+      target = entry;
+      targetIdx = i;
+    }
+    if (entry.surface.isTop()) {
+      target = entry;
+      targetIdx = i;
+      break;
+    }
+  }
+  if (!target) {
+    const removed = entries.pop();
+    if (removed) removed.live = false;
+    maybeTeardownListener();
+    return;
+  }
+  target.live = false;
+  entries.splice(targetIdx, 1);
+  const settled = target;
+  void Promise.resolve(settled.surface.close()).then(() => {
+    if (settled.surface.isOpen()) restore(settled);
+  });
+  maybeTeardownListener();
+}
+function restore(entry) {
+  if (!hasWindow() || !hasHistory()) return;
+  entry.live = true;
+  runInternal(() => {
+    try {
+      history.pushState(brandMarker(entry.surface), "", entry.surface.url);
+    } catch {
+      entry.live = false;
+    }
+  });
+  if (entry.live) {
+    entries.push(entry);
+    ensureListener();
+  }
+}
+function pushBackMarker(surface) {
+  const entry = { surface, priorUrl: void 0, live: false };
+  if (!hasWindow() || !hasHistory()) {
+    return entry;
+  }
+  entry.priorUrl = surface.url !== void 0 ? location.href : void 0;
+  runInternal(() => {
+    try {
+      history.pushState(brandMarker(surface), "", surface.url);
+      entry.live = true;
+    } catch {
+      entry.live = false;
+    }
+  });
+  if (entry.live) {
+    entries.push(entry);
+    ensureListener();
+  }
+  return entry;
+}
+function popBackMarker(handle) {
+  if (!hasWindow() || !hasHistory()) return;
+  const entry = handle;
+  const idx = entries.indexOf(entry);
+  if (idx === -1 || !entry.live) return;
+  const last = entries.length - 1;
+  entry.live = false;
+  entries.splice(idx, 1);
+  let rebrand = null;
+  if (idx !== last) {
+    const rebrandSurface = entries[entries.length - 1].surface;
+    const rebrandUrl = entry.priorUrl;
+    rebrand = () => {
+      runInternal(() => {
+        history.replaceState(
+          brandMarker(rebrandSurface),
+          "",
+          rebrandUrl !== void 0 ? rebrandUrl : location.href
+        );
+      });
+    };
+  }
+  pendingRebrands.push(rebrand);
+  suppress += 1;
+  runInternal(() => {
+    try {
+      history.back();
+    } catch {
+      suppress = Math.max(0, suppress - 1);
+      pendingRebrands.pop();
+    }
+  });
+  maybeTeardownListener();
+}
+function subscribeRouteChange(fn) {
+  if (!hasWindow() || !hasHistory()) return () => {
+  };
+  subscribers.add(fn);
+  if (subscribers.size === 1) installPatch();
+  ensureListener();
+  return () => {
+    if (!subscribers.has(fn)) return;
+    subscribers.delete(fn);
+    if (subscribers.size === 0) removePatch();
+    maybeTeardownListener();
+  };
+}
+
+// src/core/features/route.ts
+function installRoute(deps) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  if (!deps.routedTo && !deps.closeOnBack) {
+    return () => {
+    };
+  }
+  let handle = null;
+  const onOpen = () => {
+    if (handle) return;
+    handle = pushBackMarker({
+      isOpen: () => !deps.isDestroyed() && deps.getSize() > 0,
+      isTop: deps.isTopSheet,
+      close: deps.close,
+      markerState: () => deps.routedTo !== void 0 ? { __bsRouted: deps.sheetId } : { __bsSheet: deps.sheetId },
+      url: deps.routedTo
+    });
+  };
+  const onClose = () => {
+    if (!handle) return;
+    popBackMarker(handle);
+    handle = null;
+  };
+  const unsubscribeOpen = deps.on("open", onOpen);
+  const unsubscribeClose = deps.on("close", onClose);
+  if (deps.getSize() > 0) onOpen();
+  return () => {
+    unsubscribeOpen();
+    unsubscribeClose();
+    if (handle) {
+      popBackMarker(handle);
+      handle = null;
+    }
+  };
+}
+function installRouteChange(deps) {
+  return subscribeRouteChange(() => {
+    if (deps.isDestroyed() || deps.getSize() <= 0) return;
+    void deps.close();
+  });
+}
+
+// src/core/features/persist.ts
+function installPersist(engine, key) {
+  const unsubscribe = engine.on("snap", ({ id }) => {
+    if (typeof window === "undefined") return;
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(key, id);
+    } catch {
+    }
+  });
+  return unsubscribe;
+}
+
+// src/core/features/auto-collapse.ts
+function installAutoCollapse(deps) {
+  const { ms } = deps;
+  if (ms === void 0 || ms <= 0) {
+    return () => {
+    };
+  }
+  let timer = null;
+  const clearTimer = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  const fire = () => {
+    if (deps.isDestroyed()) return;
+    if (deps.isDragging()) return;
+    const active = deps.resolveSnap(deps.getActiveId());
+    if (!active || active.size === 0) return;
+    let target = null;
+    for (const id of deps.getAllowedIds()) {
+      const snap = deps.resolveSnap(id);
+      if (!snap || snap.size <= 0) continue;
+      if (!target || snap.size < target.size) target = snap;
+    }
+    if (!target) return;
+    if (target.id === active.id || target.size >= active.size) return;
+    deps.snapTo(target.id);
+  };
+  const reset = () => {
+    clearTimer();
+    if (deps.isDestroyed()) return;
+    timer = setTimeout(() => {
+      timer = null;
+      fire();
+    }, ms);
+  };
+  const unsubscribe = deps.on("snap", () => reset());
+  if ((deps.resolveSnap(deps.getActiveId())?.size ?? 0) > 0) reset();
+  return () => {
+    clearTimer();
+    unsubscribe();
+  };
+}
+
+// src/core/features/content-swipe.ts
+var CONTENT_PULL_THRESHOLD = 60;
+function installContentSwipe(deps) {
+  const { container } = deps;
+  let startY = 0;
+  let startScrollTop = 0;
+  let moved = false;
+  const onTouchStart = (e) => {
+    const t = e.touches[0];
+    if (!t) return;
+    startY = t.clientY;
+    startScrollTop = container.scrollTop;
+    moved = false;
+  };
+  const onTouchMove = (e) => {
+    const t = e.touches[0];
+    if (!t) return;
+    if (Math.abs(t.clientY - startY) > CONTENT_PULL_THRESHOLD) moved = true;
+  };
+  const onTouchEnd = (e) => {
+    if (!moved) return;
+    if (deps.isDragging() || deps.isAnimating()) return;
+    if (container.scrollTop !== startScrollTop) return;
+    const t = e.changedTouches[0];
+    if (!t) return;
+    const deltaY = t.clientY - startY;
+    const atTop = container.scrollTop <= 0;
+    const allowed = deps.getAllowedIds();
+    const idx = allowed.indexOf(deps.getActiveId());
+    if (idx === -1) return;
+    if (atTop && deltaY > CONTENT_PULL_THRESHOLD && idx > 0) {
+      deps.snapTo(allowed[idx - 1]);
+    } else if (deltaY < -CONTENT_PULL_THRESHOLD && idx < allowed.length - 1) {
+      deps.snapTo(allowed[idx + 1]);
+    }
+  };
+  container.addEventListener("touchstart", onTouchStart, { passive: true });
+  container.addEventListener("touchmove", onTouchMove, { passive: true });
+  container.addEventListener("touchend", onTouchEnd, { passive: true });
+  return () => {
+    container.removeEventListener("touchstart", onTouchStart);
+    container.removeEventListener("touchmove", onTouchMove);
+    container.removeEventListener("touchend", onTouchEnd);
+  };
+}
+
+// src/core/features/visual-viewport.ts
+var SAFETY_PAD = 8;
+function installVisualViewport(deps) {
+  if (typeof window === "undefined" || !window.visualViewport) {
+    return () => {
+    };
+  }
+  const vv = window.visualViewport;
+  let rafId = null;
+  const onResize = () => {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      if (deps.isDestroyed()) return;
+      deps.recomputeSnaps();
+      const isVertical = deps.isVerticalAxis();
+      const visible = isVertical ? vv.height : vv.width;
+      const windowSize = isVertical ? window.innerHeight : window.innerWidth;
+      const clamp = Math.max(0, Math.min(windowSize, visible) - SAFETY_PAD);
+      if (clamp < deps.getMaxAxisSize()) {
+        deps.setMaxAxisSize(clamp);
+      }
+      const wasAnimating = deps.isAnimating?.() ?? false;
+      deps.cancelInFlight();
+      deps.newCycle();
+      const max = deps.getMaxAxisSize();
+      deps.setSize(Math.min(deps.getSize(), max));
+      const current = deps.resolveActiveSnap();
+      if (current && !deps.isDragging()) {
+        deps.applySize(Math.min(current.size, max));
+        if (wasAnimating) deps.resyncAfterCancel?.();
+      } else {
+        deps.applySize(deps.getSize());
+      }
+    });
+  };
+  vv.addEventListener("resize", onResize);
+  return () => {
+    vv.removeEventListener("resize", onResize);
+    if (rafId !== null) cancelAnimationFrame(rafId);
+  };
+}
+
+// src/core/primitives/teardown-stack.ts
+var TeardownStack = class {
+  constructor() {
+    __publicField(this, "fns", []);
+  }
+  add(fn) {
+    if (fn) this.fns.push(fn);
+  }
+  drain() {
+    while (this.fns.length) {
+      try {
+        this.fns.pop()();
+      } catch (err) {
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+    }
+  }
+};
+
+// src/core/features/engine-features.ts
+function routeFeature() {
+  return {
+    name: "route",
+    install: (ctx) => {
+      const teardowns = new TeardownStack();
+      if (ctx.options.closeOnRouteChange) {
+        teardowns.add(
+          installRouteChange({
+            isDestroyed: ctx.isDestroyed,
+            getSize: ctx.getSize,
+            close: () => ctx.close()
+          })
+        );
+      }
+      teardowns.add(
+        installRoute({
+          routedTo: ctx.options.routedTo,
+          closeOnBack: ctx.options.closeOnBack,
+          isTopSheet: ctx.isTopSheet,
+          getSize: ctx.getSize,
+          isDestroyed: ctx.isDestroyed,
+          close: () => ctx.close("back"),
+          on: ctx.on,
+          sheetId: ctx.sheetId
+        })
+      );
+      return () => teardowns.drain();
+    }
+  };
+}
+function persistFeature() {
+  return {
+    name: "persist",
+    install: (ctx) => {
+      const key = ctx.options.persistKey;
+      if (!key) return;
+      return installPersist({ on: ctx.on }, key);
+    }
+  };
+}
+function autoCollapseFeature() {
+  return {
+    name: "auto-collapse",
+    install: (ctx) => installAutoCollapse({
+      ms: ctx.options.autoCollapseAfter,
+      isDestroyed: ctx.isDestroyed,
+      isDragging: ctx.isDragging,
+      getAllowedIds: ctx.getAllowedIds,
+      getActiveId: ctx.getActiveId,
+      resolveSnap: ctx.resolveSnap,
+      snapTo: ctx.snapTo,
+      on: ctx.on
+    })
+  };
+}
+function contentSwipeFeature() {
+  return {
+    name: "content-swipe",
+    stage: "attach",
+    install: (ctx) => {
+      if (!ctx.scrollContainer) return;
+      return installContentSwipe({
+        container: ctx.scrollContainer,
+        isDragging: ctx.isDragging,
+        isAnimating: ctx.isAnimating,
+        getAllowedIds: ctx.allowedIdsBySize,
+        getActiveId: ctx.getActiveId,
+        snapTo: ctx.snapTo
+      });
+    }
+  };
+}
+function visualViewportFeature() {
+  return {
+    name: "visual-viewport",
+    install: (ctx) => {
+      if (typeof window === "undefined") return;
+      return installVisualViewport({
+        element: ctx.element,
+        isVerticalAxis: ctx.isVerticalAxis,
+        isDestroyed: ctx.isDestroyed,
+        isDragging: ctx.isDragging,
+        recomputeSnaps: ctx.recomputeSnaps,
+        resolveActiveSnap: ctx.resolveActiveSnap,
+        getMaxAxisSize: ctx.getMaxAxisSize,
+        getSize: ctx.getSize,
+        setMaxAxisSize: ctx.setMaxAxisSize,
+        setSize: ctx.setSize,
+        applySize: ctx.applySize,
+        cancelInFlight: ctx.cancelInFlight,
+        newCycle: ctx.newCycle,
+        isAnimating: ctx.isAnimating,
+        resyncAfterCancel: ctx.resyncAfterResize
+      });
+    }
+  };
+}
+
+// src/core/default-features.ts
+function defaultEngineFeatures() {
+  return [
+    contentSwipeFeature(),
+    visualViewportFeature(),
+    persistFeature(),
+    autoCollapseFeature(),
+    routeFeature()
+  ];
+}
+
+exports.autoCollapseFeature = autoCollapseFeature;
+exports.contentSwipeFeature = contentSwipeFeature;
+exports.defaultEngineFeatures = defaultEngineFeatures;
+exports.persistFeature = persistFeature;
+exports.routeFeature = routeFeature;
+exports.visualViewportFeature = visualViewportFeature;
+//# sourceMappingURL=features.cjs.map
+//# sourceMappingURL=features.cjs.map

package/dist/features.d.cts

@@ -0,0 +1,13 @@
+import { l as EngineFeature } from './BottomSheetCore-CsIjyq7C.cjs';
+export { m as EngineFeatureContext, n as EngineFeatureOptions, o as EngineFeatureStage } from './BottomSheetCore-CsIjyq7C.cjs';
+import './transform-jVfAikE9.cjs';
+
+declare function defaultEngineFeatures(): EngineFeature[];
+
+declare function routeFeature(): EngineFeature;
+declare function persistFeature(): EngineFeature;
+declare function autoCollapseFeature(): EngineFeature;
+declare function contentSwipeFeature(): EngineFeature;
+declare function visualViewportFeature(): EngineFeature;
+
+export { EngineFeature, autoCollapseFeature, contentSwipeFeature, defaultEngineFeatures, persistFeature, routeFeature, visualViewportFeature };

package/dist/features.d.ts

@@ -0,0 +1,13 @@
+import { l as EngineFeature } from './BottomSheetCore-D16lsa6g.js';
+export { m as EngineFeatureContext, n as EngineFeatureOptions, o as EngineFeatureStage } from './BottomSheetCore-D16lsa6g.js';
+import './transform-jVfAikE9.js';
+
+declare function defaultEngineFeatures(): EngineFeature[];
+
+declare function routeFeature(): EngineFeature;
+declare function persistFeature(): EngineFeature;
+declare function autoCollapseFeature(): EngineFeature;
+declare function contentSwipeFeature(): EngineFeature;
+declare function visualViewportFeature(): EngineFeature;
+
+export { EngineFeature, autoCollapseFeature, contentSwipeFeature, defaultEngineFeatures, persistFeature, routeFeature, visualViewportFeature };