@maas/vue-equipment 1.0.1 → 1.1.0

package/dist/plugins/MagicTray/src/composables/private/useTrayDrag.mjs

@@ -21,7 +21,9 @@ import {
   isAndroid,
   isIOS,
   isWithinRange,
-  lockSelection
+  lockSelection,
+  snapCommit,
+  snapRelease
 } from "@maas/vue-equipment/utils";
 import { useMagicEmitter } from "@maas/vue-equipment/plugins/MagicEmitter";
 import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
@@ -37,7 +39,7 @@ export function useTrayDrag(args) {
   });
   const { initializeState } = useTrayState(toValue(id));
   const state = initializeState();
-  const { clampWithOvershoot, isVertical } = useTrayUtils();
+  const { clampWithOvershoot, isVertical, flattenSnapPoints } = useTrayUtils();
   const emitter = useMagicEmitter();
   const {
     dimension,
@@ -45,8 +47,12 @@ export function useTrayDrag(args) {
     maxInset,
     mapSnapPoint,
     mappedSnapPoints,
-    snapPointsMap,
-    findClosestSnapPoint,
+    mappedRanges,
+    rangeAt,
+    snapPointAt,
+    restingInset,
+    isSnapTarget,
+    findSnapTarget,
     interpolateDragged,
     snapTo
   } = useTraySnap({ id, state });
@@ -63,9 +69,11 @@ export function useTrayDrag(args) {
   }
   function openSnapPoint(side) {
     const points = mappedSnapPoints(side);
-    return points.length ? snapPointsMap(side)[points[0]] : void 0;
+    return points.length ? snapPointAt(side, points[0]) : void 0;
   }
   let lastPendingTarget = void 0;
+  let heldRangeSnap = false;
+  let flicked = false;
   let suppressClick = false;
   let cancelPointerup = void 0;
   let cancelPointermove = void 0;
@@ -86,8 +94,24 @@ export function useTrayDrag(args) {
   const preventEdgeNavigation = computed(
     () => state.options.preventEdgeNavigation
   );
-  function snapReference(side) {
-    return snapMode.value === "step" ? state.lastDragged[side] : state.dragged[side];
+  function snapDrag(side) {
+    return {
+      points: mappedSnapPoints(side),
+      ranges: mappedRanges(side),
+      mode: snapMode.value,
+      rest: state.snapped[side],
+      start: state.lastDragged[side],
+      position: state.dragged[side]
+    };
+  }
+  function settleTarget(side) {
+    const target = snapRelease({
+      ...snapDrag(side),
+      committed: state.interpolateTo,
+      flicked,
+      tapped: !hasDragged.value
+    });
+    return restingInset(side, target);
   }
   function isSnapDrag(side) {
     return typeof dragMode.value === "string" ? dragMode.value === "snap" : (dragMode.value?.[side] ?? "free") === "snap";
@@ -211,45 +235,57 @@ export function useTrayDrag(args) {
   }
   function snapDragged(side, coord) {
     const inset = computeInset(side, coord);
-    const target = findClosestSnapPoint({ side, value: inset });
+    const target = findSnapTarget(side, inset);
     if (target === void 0 || target === state.snapped[side]) {
       return;
     }
-    const snapPoint = snapPointsMap(side)[target];
     state.dragged[side] = target;
     state.snapped[side] = target;
-    state.activeSnapPoint[side] = snapPoint;
-    if (snapPoint || snapPoint === 0) {
-      emitter.emit("beforeSnap", {
-        id: toValue(id),
-        snapPoint: { side, point: snapPoint }
-      });
-      emitter.emit("afterSnap", {
-        id: toValue(id),
-        snapPoint: { side, point: snapPoint }
-      });
+    state.activeSnapPoint[side] = snapPointAt(side, target);
+    heldRangeSnap = !mappedSnapPoints(side).includes(target);
+    if (!heldRangeSnap) {
+      emitSnap(side);
     }
   }
-  function checkPosition(side) {
-    const delta = state.dragged[side] - state.lastDragged[side];
-    if (Math.abs(delta) > toValue(threshold).distance) {
-      state.interpolateTo = findClosestSnapPoint({
-        side,
-        value: snapReference(side),
-        direction: delta < 0 ? "below" : "above"
-      });
-    } else {
-      state.interpolateTo = void 0;
+  function releaseSnapDrag(side) {
+    if (heldRangeSnap) {
+      emitSnap(side);
     }
+    heldRangeSnap = false;
+  }
+  function emitSnap(side) {
+    const point = state.activeSnapPoint[side];
+    if (point === void 0) {
+      return;
+    }
+    emitter.emit("beforeSnap", {
+      id: toValue(id),
+      snapPoint: { side, point }
+    });
+    emitter.emit("afterSnap", {
+      id: toValue(id),
+      snapPoint: { side, point }
+    });
+  }
+  function checkPosition(side) {
+    const direction = state.relDirection[side];
+    state.interpolateTo = snapCommit({
+      ...snapDrag(side),
+      distance: toValue(threshold).distance,
+      flicked,
+      flickDirection: direction === "absolute" ? void 0 : direction
+    });
   }
   function emitWillSnapTo(side) {
-    const target = state.interpolateTo ?? state.snapped[side];
-    if (target === lastPendingTarget) {
+    const target = settleTarget(side);
+    const isPoint = mappedSnapPoints(side).includes(target);
+    const pending = !isPoint && rangeAt(side, target)?.range || target;
+    if (pending === lastPendingTarget) {
       return;
     }
-    lastPendingTarget = target;
-    const snapPoint = snapPointsMap(side)[target];
-    if (!snapPoint && snapPoint !== 0) {
+    lastPendingTarget = pending;
+    const snapPoint = snapPointAt(side, target);
+    if (snapPoint === void 0) {
       return;
     }
     emitter.emit("willSnapTo", {
@@ -262,13 +298,7 @@ export function useTrayDrag(args) {
     const elapsed = Date.now() - state.dragStart.getTime();
     const distance = Math.abs(state.dragged[side] - state.lastDragged[side]);
     const velocity = elapsed && distance ? distance / elapsed : 0;
-    if (velocity > toValue(threshold).momentum) {
-      state.interpolateTo = findClosestSnapPoint({
-        side,
-        value: snapReference(side),
-        direction: state.relDirection[side]
-      });
-    }
+    flicked = velocity > toValue(threshold).momentum;
   }
   function resetListeners() {
     cancelTouchmove?.();
@@ -286,13 +316,12 @@ export function useTrayDrag(args) {
     state.interpolateTo = void 0;
   }
   function settle(side) {
-    if (state.interpolateTo || state.interpolateTo === 0) {
-      interpolateDragged({ side, to: state.interpolateTo });
-      state.snapped[side] = state.interpolateTo;
-      state.activeSnapPoint[side] = snapPointsMap(side)[state.interpolateTo];
-    } else {
-      interpolateDragged({ side, to: state.snapped[side] });
+    const target = settleTarget(side);
+    if (target !== state.snapped[side] || state.interpolateTo !== void 0) {
+      state.snapped[side] = target;
+      state.activeSnapPoint[side] = snapPointAt(side, target);
     }
+    interpolateDragged({ side, to: target });
   }
   function onPointermove(e) {
     if (e.isTrusted && !e.isPrimary) {
@@ -323,7 +352,9 @@ export function useTrayDrag(args) {
     const side = state.draggingSide;
     if (side) {
       suppressClick = hasDragged.value;
-      if (!isSnapDrag(side)) {
+      if (isSnapDrag(side)) {
+        releaseSnapDrag(side);
+      } else {
         settle(side);
       }
       emitter.emit("afterDrag", {
@@ -369,7 +400,9 @@ export function useTrayDrag(args) {
     const side = state.draggingSide;
     if (side) {
       suppressClick = hasDragged.value;
-      if (!isSnapDrag(side)) {
+      if (isSnapDrag(side)) {
+        releaseSnapDrag(side);
+      } else {
         settle(side);
       }
       emitter.emit("afterDrag", {
@@ -389,6 +422,8 @@ export function useTrayDrag(args) {
     state.magnetic[side] = 0;
     state.lastDragged[side] = state.dragged[side];
     lastPendingTarget = void 0;
+    heldRangeSnap = false;
+    flicked = false;
     suppressClick = false;
     pointerdownTarget = target;
     releaseSelection = lockSelection();
@@ -484,6 +519,12 @@ export function useTrayDrag(args) {
       return;
     }
     await getSizes();
+    if (contentExtent(side) && !isSnapTarget(side, point)) {
+      logWarning(
+        `Cannot snap side "${side}" to ${point}, which is neither a snap point nor inside a range`
+      );
+      return;
+    }
     snapTo({
       side,
       snapPoint: point,
@@ -501,7 +542,14 @@ export function useTrayDrag(args) {
         pendingInitialSides.add(side);
         continue;
       }
-      const initial = state.options.initial.snapPoints?.[side] ?? openSnapPoint(side);
+      const configured = state.options.initial.snapPoints?.[side];
+      const isValid = configured === void 0 || isSnapTarget(side, configured);
+      if (!isValid) {
+        logWarning(
+          `initial.snapPoints.${side} (${configured}) is neither a snap point nor inside a range and is ignored`
+        );
+      }
+      const initial = (isValid ? configured : void 0) ?? openSnapPoint(side);
       if (initial === void 0) {
         continue;
       }
@@ -518,7 +566,7 @@ export function useTrayDrag(args) {
   }
   function validateSnapPoints() {
     for (const side of draggableSides.value) {
-      const points = state.options.snapPoints[side] ?? [];
+      const points = flattenSnapPoints(state.options.snapPoints[side] ?? []);
       const canOpen = points.some((point) => parseFloat(String(point)) === 0);
       const hasInitial = state.options.initial.snapPoints?.[side] !== void 0;
       if (!canOpen && !hasInitial) {

package/dist/plugins/MagicTray/src/composables/private/useTrayMagnetism.mjs

@@ -5,6 +5,7 @@ import { useMagicEmitter } from "@maas/vue-equipment/plugins/MagicEmitter";
 import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { useEasings } from "@maas/vue-equipment/composables/useEasings";
 import { useTraySnap } from "./useTraySnap.mjs";
+import { useTrayUtils } from "./useTrayUtils.mjs";
 const SIDES = ["top", "right", "bottom", "left"];
 const EPSILON = 0.5;
 export function useTrayMagnetism(args) {
@@ -17,6 +18,7 @@ export function useTrayMagnetism(args) {
     id,
     state
   });
+  const { flattenSnapPoints } = useTrayUtils();
   const emitter = useMagicEmitter();
   const easings = useEasings();
   const magnetism = computed(() => state.options.magnetism);
@@ -122,7 +124,7 @@ export function useTrayMagnetism(args) {
       if (!config) {
         continue;
       }
-      const configured = state.options.snapPoints[side] ?? [];
+      const configured = flattenSnapPoints(state.options.snapPoints[side] ?? []);
       for (const key of Object.keys(config)) {
         if (!configured.includes(coercePoint(key))) {
           throwError({

package/dist/plugins/MagicTray/src/composables/private/useTraySnap.d.ts

@@ -1,5 +1,5 @@
 import type { MaybeRef } from 'vue';
-import type { MagicTraySide, MagicTraySnapPoint, TrayState } from '../../types/index.js';
+import type { MagicTraySide, MagicTraySnapPoint, MagicTraySnapRange, TrayState } from '../../types/index.js';
 type UseTraySnapArgs = {
     id: MaybeRef<string>;
     state: TrayState;
@@ -16,10 +16,11 @@ type InterpolateDraggedArgs = {
     duration?: number;
     easing?: (t: number) => number;
 };
-type FindClosestSnapPointArgs = {
-    side: MagicTraySide;
-    value: number;
-    direction?: 'below' | 'above' | 'absolute';
+type MappedSnapRange = {
+    min: number;
+    max: number;
+    momentum?: boolean;
+    range: MagicTraySnapRange;
 };
 export declare function useTraySnap(args: UseTraySnapArgs): {
     dimension: (side: MagicTraySide) => number;
@@ -28,8 +29,12 @@ export declare function useTraySnap(args: UseTraySnapArgs): {
     maxInset: (side: MagicTraySide) => number;
     mapSnapPoint: (side: MagicTraySide, snapPoint: MagicTraySnapPoint) => any;
     mappedSnapPoints: (side: MagicTraySide) => any[];
-    snapPointsMap: (side: MagicTraySide) => Record<number, MagicTraySnapPoint>;
-    findClosestSnapPoint: (args: FindClosestSnapPointArgs) => number | undefined;
+    mappedRanges: (side: MagicTraySide) => Array<MappedSnapRange>;
+    rangeAt: (side: MagicTraySide, inset: number) => any;
+    snapPointAt: (side: MagicTraySide, inset: number) => MagicTraySnapPoint | undefined;
+    restingInset: (side: MagicTraySide, inset: number) => any;
+    isSnapTarget: (side: MagicTraySide, snapPoint: MagicTraySnapPoint) => boolean;
+    findSnapTarget: (side: MagicTraySide, inset: number) => any;
     interpolateDragged: (args: InterpolateDraggedArgs) => void;
     snapTo: (args: SnapToArgs) => Promise<void>;
 };

package/dist/plugins/MagicTray/src/composables/private/useTraySnap.mjs

@@ -1,10 +1,22 @@
 import { computed, nextTick, toValue } from "vue";
-import { clampValue, interpolate } from "@maas/vue-equipment/utils";
+import {
+  clampValue,
+  interpolate,
+  snapRangeAt,
+  snapTargetAt
+} from "@maas/vue-equipment/utils";
 import { useMagicEmitter } from "@maas/vue-equipment/plugins/MagicEmitter";
 import { useTrayUtils } from "./useTrayUtils.mjs";
+const SNAP_TOLERANCE = 0.01;
+function isMapped(value) {
+  return value !== void 0 && !Number.isNaN(value);
+}
+function roundDecimal(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
 export function useTraySnap(args) {
   const { id, state } = args;
-  const { isVertical, oppositeSide } = useTrayUtils();
+  const { isVertical, oppositeSide, isSnapRange, flattenSnapPoints } = useTrayUtils();
   const emitter = useMagicEmitter();
   const snapPoints = computed(() => state.options.snapPoints);
   const animation = computed(() => state.options.animation);
@@ -43,53 +55,80 @@ export function useTraySnap(args) {
     }
   }
   function mappedSnapPoints(side) {
-    const configured = snapPoints.value[side] ?? [];
-    const mapped = configured.map((snapPoint) => mapSnapPoint(side, snapPoint)).filter(
-      (value) => value === 0 || !!value && !Number.isNaN(value)
-    );
+    const configured = flattenSnapPoints(snapPoints.value[side] ?? []);
+    const mapped = configured.map((snapPoint) => mapSnapPoint(side, snapPoint)).filter(isMapped);
     return [...new Set(mapped)].sort((a, b) => a - b);
   }
   function snapPointsMap(side) {
-    const configured = snapPoints.value[side] ?? [];
+    const configured = flattenSnapPoints(snapPoints.value[side] ?? []);
     const map = {};
     for (const snapPoint of configured) {
       const mapped = mapSnapPoint(side, snapPoint);
-      if (mapped || mapped === 0) {
+      if (isMapped(mapped)) {
         map[mapped] = snapPoint;
       }
     }
     return map;
   }
-  function findClosestNumber(value, numbers, direction) {
-    if (!numbers.length) {
+  function mappedRanges(side) {
+    const configured = snapPoints.value[side] ?? [];
+    return configured.filter(isSnapRange).flatMap((range) => {
+      const min = mapSnapPoint(side, range.min);
+      const max = mapSnapPoint(side, range.max);
+      if (!isMapped(min) || !isMapped(max)) {
+        return [];
+      }
+      return [
+        {
+          min: Math.min(min, max),
+          max: Math.max(min, max),
+          momentum: range.momentum,
+          range
+        }
+      ];
+    });
+  }
+  function rangeAt(side, inset) {
+    return snapRangeAt({ ranges: mappedRanges(side), position: inset });
+  }
+  function snapPointAt(side, inset) {
+    const configured = snapPointsMap(side)[inset];
+    if (configured !== void 0) {
+      return configured;
+    }
+    const mapped = rangeAt(side, inset);
+    if (!mapped) {
       return void 0;
     }
-    let filtered = numbers;
-    switch (direction) {
-      case "above":
-        filtered = numbers.filter((num) => num > value);
-        break;
-      case "below":
-        filtered = numbers.filter((num) => num < value);
-        break;
+    const offset = inset - padding(side);
+    const { min, max } = mapped.range;
+    return typeof min === "number" && typeof max === "number" ? roundDecimal(offset / contentExtent(side)) : `${Math.round(offset)}px`;
+  }
+  function restingInset(side, inset) {
+    const range = rangeAt(side, inset);
+    const snapPoint = snapPointAt(side, inset);
+    if (!range || snapPoint === void 0) {
+      return inset;
     }
-    if (filtered.length === 0) {
-      switch (direction) {
-        case "above":
-          return Math.max(...numbers);
-        case "below":
-          return Math.min(...numbers);
-        default:
-          return void 0;
-      }
+    const mapped = mapSnapPoint(side, snapPoint);
+    return mapped === void 0 ? inset : clampValue(mapped, range.min, range.max);
+  }
+  function isSnapTarget(side, snapPoint) {
+    const mapped = mapSnapPoint(side, snapPoint);
+    if (mapped === void 0) {
+      return false;
     }
-    return filtered.reduce(
-      (closest, current) => Math.abs(current - value) < Math.abs(closest - value) ? current : closest
+    return !!rangeAt(side, mapped) || mappedSnapPoints(side).some(
+      (point) => Math.abs(point - mapped) < SNAP_TOLERANCE
     );
   }
-  function findClosestSnapPoint(args2) {
-    const { side, value, direction = "absolute" } = args2;
-    return findClosestNumber(value, mappedSnapPoints(side), direction);
+  function findSnapTarget(side, inset) {
+    const target = snapTargetAt({
+      points: mappedSnapPoints(side),
+      ranges: mappedRanges(side),
+      value: inset
+    });
+    return target === void 0 ? void 0 : restingInset(side, target);
   }
   function interpolateDragged(args2) {
     const {
@@ -98,8 +137,8 @@ export function useTraySnap(args) {
       duration = toValue(animation).snap.duration,
       easing = toValue(animation).snap.easing
     } = args2;
-    const snapPoint = snapPointsMap(side)[to];
-    if (!snapPoint && snapPoint !== 0) {
+    const snapPoint = snapPointAt(side, to);
+    if (snapPoint === void 0) {
       interpolate({
         from: state.dragged[side],
         to,
@@ -115,6 +154,13 @@ export function useTraySnap(args) {
       id: toValue(id),
       snapPoint: { side, point: snapPoint }
     });
+    if (state.dragged[side] === to) {
+      emitter.emit("afterSnap", {
+        id: toValue(id),
+        snapPoint: { side, point: snapPoint }
+      });
+      return;
+    }
     interpolate({
       from: state.dragged[side],
       to,
@@ -138,14 +184,14 @@ export function useTraySnap(args) {
     if (mapped === void 0) {
       return;
     }
-    const closest = findClosestSnapPoint({ side, value: mapped }) ?? mapped;
+    const closest = findSnapTarget(side, mapped) ?? mapped;
+    state.snapped[side] = closest;
+    state.activeSnapPoint[side] = snapPointAt(side, closest) ?? snapPoint;
     if (shouldInterpolate) {
       interpolateDragged({ side, to: closest, duration });
     } else {
       state.dragged[side] = closest;
     }
-    state.snapped[side] = closest;
-    state.activeSnapPoint[side] = snapPoint;
   }
   return {
     dimension,
@@ -154,8 +200,12 @@ export function useTraySnap(args) {
     maxInset,
     mapSnapPoint,
     mappedSnapPoints,
-    snapPointsMap,
-    findClosestSnapPoint,
+    mappedRanges,
+    rangeAt,
+    snapPointAt,
+    restingInset,
+    isSnapTarget,
+    findSnapTarget,
     interpolateDragged,
     snapTo
   };

package/dist/plugins/MagicTray/src/composables/private/useTrayUtils.d.ts

@@ -1,6 +1,8 @@
-import type { MagicTraySide } from '../../types/index.js';
+import type { MagicTraySide, MagicTraySnapEntry, MagicTraySnapRange } from '../../types/index.js';
 export declare function useTrayUtils(): {
     clampWithOvershoot: (value: number, min: number, max: number, outer: number, inner: number) => any;
     isVertical: (side: MagicTraySide) => side is "top" | "bottom";
     oppositeSide: (side: MagicTraySide) => MagicTraySide;
+    isSnapRange: (entry: MagicTraySnapEntry) => entry is MagicTraySnapRange;
+    flattenSnapPoints: (entries: Array<MagicTraySnapEntry>) => import("../../types/index.js").MagicTraySnapPoint[];
 };

package/dist/plugins/MagicTray/src/composables/private/useTrayUtils.mjs

@@ -24,9 +24,19 @@ export function useTrayUtils() {
         return "left";
     }
   }
+  function isSnapRange(entry) {
+    return typeof entry === "object";
+  }
+  function flattenSnapPoints(entries) {
+    return entries.flatMap(
+      (entry) => isSnapRange(entry) ? [entry.min, entry.max] : [entry]
+    );
+  }
   return {
     clampWithOvershoot,
     isVertical,
-    oppositeSide
+    oppositeSide,
+    isSnapRange,
+    flattenSnapPoints
   };
 }

package/dist/plugins/MagicTray/src/types/index.d.ts

@@ -2,6 +2,12 @@ import type { RequireAllNested } from '@maas/vue-equipment/utils';
 import type { EasingKey } from '@maas/vue-equipment/composables/useEasings';
 export type MagicTraySide = 'top' | 'right' | 'bottom' | 'left';
 export type MagicTraySnapPoint = number | `${number}px`;
+export interface MagicTraySnapRange {
+    min: MagicTraySnapPoint;
+    max: MagicTraySnapPoint;
+    momentum?: boolean;
+}
+export type MagicTraySnapEntry = MagicTraySnapPoint | MagicTraySnapRange;
 export interface MagicTraySnapPointPayload {
     side: MagicTraySide;
     point: MagicTraySnapPoint;
@@ -12,7 +18,7 @@ export interface MagicTraySidePayload {
 }
 export type MagicTraySnapMode = 'closest' | 'step';
 export type MagicTrayDragMode = 'free' | 'snap';
-export type TraySnapPoints = Partial<Record<MagicTraySide, MagicTraySnapPoint[]>>;
+export type TraySnapPoints = Partial<Record<MagicTraySide, Array<MagicTraySnapEntry>>>;
 export type TrayMagneticDirection = 'inner' | 'outer' | 'both';
 export type TrayMagneticSide = Partial<Record<MagicTraySnapPoint, TrayMagneticDirection>>;
 export type TrayMagneticSides = false | Partial<Record<MagicTraySide, TrayMagneticSide>>;

package/dist/utils/index.d.ts

@@ -88,6 +88,51 @@ interface SlugifyOptions {
 }
 declare function slugify(string: string, options?: SlugifyOptions): string;
 
+type SnapRange = {
+    min: number;
+    max: number;
+    momentum?: boolean;
+};
+type SnapDirection = 'below' | 'above';
+type SnapMode = 'closest' | 'step';
+type SnapDrag = {
+    points: Array<number>;
+    ranges: Array<SnapRange>;
+    mode: SnapMode;
+    rest: number;
+    start: number;
+    position: number;
+};
+type SnapRangeAtArgs<RangeType extends SnapRange> = {
+    ranges: Array<RangeType>;
+    position: number;
+};
+type ClosestSnapPointArgs = {
+    points: Array<number>;
+    value: number;
+    direction?: SnapDirection | 'absolute';
+};
+type SnapTargetAtArgs = {
+    points: Array<number>;
+    ranges: Array<SnapRange>;
+    value: number;
+};
+type SnapCommitArgs = SnapDrag & {
+    distance: number;
+    flicked: boolean;
+    flickDirection?: SnapDirection;
+};
+type SnapReleaseArgs = SnapDrag & {
+    committed: number | undefined;
+    flicked: boolean;
+    tapped: boolean;
+};
+declare function snapRangeAt<RangeType extends SnapRange>(args: SnapRangeAtArgs<RangeType>): RangeType | undefined;
+declare function closestSnapPoint(args: ClosestSnapPointArgs): number | undefined;
+declare function snapTargetAt(args: SnapTargetAtArgs): number | undefined;
+declare function snapCommit(args: SnapCommitArgs): number | undefined;
+declare function snapRelease(args: SnapReleaseArgs): number;
+
 declare function uniq<T extends unknown[]>(a: T): unknown[];
 
 type PickPartial<T, K extends keyof T> = {
@@ -100,4 +145,4 @@ type RequireAllNested<T> = {
 
 type ValueOf<T> = T[keyof T];
 
-export { type CreateStore, type InterpolateArgs, type PickPartial, type RequireAllNested, type SlugifyOptions, type ValueOf, cancelEdgeNavigation, clampValue, convertToPixels, createStateStore, easeInCubic, easeInOutCubic, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInQuad, easeInQuart, easeInQuint, easeOutBack, easeOutCubic, easeOutQuad, easeOutQuart, easeOutQuint, formatTime, guardedReleasePointerCapture, guardedSetPointerCapture, hasEdgeNavigationGestures, interpolate, isAndroid, isIOS, isWithinRange, linear, lockSelection, mapValue, matchClass, rubberband, scrollbarGutterSupport, scrollbarWidth, slugify, uniq };
+export { type CreateStore, type InterpolateArgs, type PickPartial, type RequireAllNested, type SlugifyOptions, type SnapDirection, type SnapDrag, type SnapMode, type SnapRange, type ValueOf, cancelEdgeNavigation, clampValue, closestSnapPoint, convertToPixels, createStateStore, easeInCubic, easeInOutCubic, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInQuad, easeInQuart, easeInQuint, easeOutBack, easeOutCubic, easeOutQuad, easeOutQuart, easeOutQuint, formatTime, guardedReleasePointerCapture, guardedSetPointerCapture, hasEdgeNavigationGestures, interpolate, isAndroid, isIOS, isWithinRange, linear, lockSelection, mapValue, matchClass, rubberband, scrollbarGutterSupport, scrollbarWidth, slugify, snapCommit, snapRangeAt, snapRelease, snapTargetAt, uniq };