@astryxdesign/core 0.4.4 → 0.4.5-canary.1dc3e5d

package/dist/BottomSheet/useSheetGestures.d.ts

@@ -15,14 +15,16 @@
  * the part the scrolling area gives up as layout height, and the remainder is
  * a transform. Gestures and snaps only ever move the transform, so they stay
  * on the compositor; layout height changes at rest, in one transition-free
- * render whose visible geometry is identical. The peek detent keeps the full
- * height and slides below the viewport instead of reflowing to a sliver.
+ * render whose visible geometry is identical. A peek detent — a stop that is
+ * only a sliver of the sheet — keeps the full height and slides below the
+ * viewport instead of reflowing to that sliver.
  *
- * Those are pixels, and the detents behind them are viewport fractions, so a
- * sheet at rest re-resolves its detent on `resize` / `orientationchange` and
- * re-anchors to the new geometry without animating. The detent it returns to
- * is tracked by index: the pixels stop meaning the same thing when the
- * viewport changes, the stop the user chose does not.
+ * Those are pixels, and the stops behind them are relative to the viewport, so
+ * a sheet at rest re-resolves its detent on `resize` / `orientationchange`,
+ * and whenever the host swaps the snap points, and re-anchors to the new
+ * geometry without animating. The detent it returns to is tracked by index:
+ * the pixels stop meaning the same thing when the viewport changes, the stop
+ * the user chose does not.
  *
  * On touch, the scrolling body hands the gesture to the sheet at a scroll
  * edge. Two shapes, because the browser only offers one of them a choice: a
@@ -70,6 +72,9 @@ export interface UseSheetGesturesOptions {
      * (rotation, a resized desktop window, collapsing browser chrome). The fully
      * open height is always the tallest detent. Omit for a single-height sheet
      * (a drag then only dismisses or springs back).
+     *
+     * Keep the identity stable: a new function is read as new stops, and
+     * re-anchors a resting sheet to them.
      */
     snapHeights?: () => number[];
     /** Notified when the settled visible detent height (px) changes. */
@@ -153,7 +158,7 @@ export interface UseSheetGesturesResult {
     /**
      * How much of `settledOffset` is expressed as layout height rather than as a
      * transform. Equals `settledOffset` at the resizing detents; 0 at fully open
-     * and at the peek, which keep the sheet's full height (see isPeekOffset).
+     * and at the peek, which keep the sheet's full height (see peekOffsetFor).
      */
     settledLayoutOffset: number;
 }

package/dist/BottomSheet/useSheetGestures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSheetGestures.d.ts","sourceRoot":"","sources":["../../src/BottomSheet/useSheetGestures.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"useSheetGestures.d.ts","sourceRoot":"","sources":["../../src/BottomSheet/useSheetGestures.ts"],"names":[],"mappings":"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"}

package/dist/BottomSheet/useSheetGestures.js

@@ -19,14 +19,16 @@
  * the part the scrolling area gives up as layout height, and the remainder is
  * a transform. Gestures and snaps only ever move the transform, so they stay
  * on the compositor; layout height changes at rest, in one transition-free
- * render whose visible geometry is identical. The peek detent keeps the full
- * height and slides below the viewport instead of reflowing to a sliver.
+ * render whose visible geometry is identical. A peek detent — a stop that is
+ * only a sliver of the sheet — keeps the full height and slides below the
+ * viewport instead of reflowing to that sliver.
  *
- * Those are pixels, and the detents behind them are viewport fractions, so a
- * sheet at rest re-resolves its detent on `resize` / `orientationchange` and
- * re-anchors to the new geometry without animating. The detent it returns to
- * is tracked by index: the pixels stop meaning the same thing when the
- * viewport changes, the stop the user chose does not.
+ * Those are pixels, and the stops behind them are relative to the viewport, so
+ * a sheet at rest re-resolves its detent on `resize` / `orientationchange`,
+ * and whenever the host swaps the snap points, and re-anchors to the new
+ * geometry without animating. The detent it returns to is tracked by index:
+ * the pixels stop meaning the same thing when the viewport changes, the stop
+ * the user chose does not.
  *
  * On touch, the scrolling body hands the gesture to the sheet at a scroll
  * edge. Two shapes, because the browser only offers one of them a choice: a
@@ -51,7 +53,12 @@
  */
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { useMediaQuery } from "../hooks/index.js";
-import { computeDetentOffsets, isPeekOffset, resolveSettleOffset, scrimOpacityForOffset } from "./snapOffsets.js";
+import { computeDetentOffsets, peekOffsetFor, resolveSettleOffset, scrimOpacityForOffset } from "./snapOffsets.js";
+
+/**
+ * The stops a sheet of a given height rests at: offsets from fully-open in px,
+ * ascending, plus which of them (if any) is the peek.
+ */
 
 // A flick (fast throw) dismisses (down) or expands (up) regardless of where
 // it ends. Requires both a speed and a distance floor so a small nudge
@@ -64,6 +71,18 @@ const DISMISS_OVERSHOOT_RATIO = 0.4;
 // Within this many px of a detent, the live drag is magnetically eased toward
 // it so it "clicks" into place instead of hovering just off the mark.
 const MAGNET_RANGE = 40;
+// The touch path drives the sheet through the same machinery the pointer path
+// uses, by handing it a pointer-shaped object built from a `Touch`. On iOS
+// Safari that object is indistinguishable from the real thing: WebKit raises
+// PointerEvents for a finger under the SAME numeric id it puts in
+// `Touch.identifier`, so such a drag is keyed to a live pointer and the
+// handlers that guard a mouse drag fire against it. Mark the synthetic object
+// so they can tell the two apart.
+
+function isSyntheticTouch(event) {
+  return event.syntheticTouch === true;
+}
+
 // Rubber-band factor for dragging up past fully-open, capped at OVERSCROLL_MAX
 // (the sheet reserves that much bottom padding for the lift to reveal).
 const OVERSCROLL_RESISTANCE = 0.35;
@@ -174,7 +193,7 @@ export function useSheetGestures({
   const [scrollPreservationInset, setScrollPreservationInset] = useState(0);
   // How much of the settled travel is expressed as layout height. Equal to
   // settledOffset for the resizing detents, and 0 at fully open and at the
-  // peek (see isPeekOffset), which keep the full height and use a transform.
+  // peek (see peekOffsetFor), which keep the full height and use a transform.
   const [settledLayoutOffset, setSettledLayoutOffset] = useState(0);
   const settledLayoutOffsetRef = useRef(0);
   // WHICH detent the sheet rests on, as an index into the resolved list. The
@@ -242,17 +261,22 @@ export function useSheetGestures({
   activeOffsetRef.current = isDragging ? dragOffset : settledOffset;
   const isOpenRef = useRef(isOpen);
   isOpenRef.current = isOpen;
+
+  // The resolver is refreshed during render, not with the callbacks below: the
+  // layout effect that re-anchors on a change to it runs BEFORE passive
+  // effects, so a resolver parked in one would still be the previous set of
+  // stops by the time the re-anchor read it.
+  const snapHeightsRef = useRef(snapHeights);
+  snapHeightsRef.current = snapHeights;
   const onDismissRef = useRef(onDismiss);
   const canDismissRef = useRef(canDismiss);
   const onSnapRef = useRef(onSnap);
   const onScrimOpacityRef = useRef(onScrimOpacity);
-  const snapHeightsRef = useRef(snapHeights);
   useEffect(() => {
     onDismissRef.current = onDismiss;
     canDismissRef.current = canDismiss;
     onSnapRef.current = onSnap;
     onScrimOpacityRef.current = onScrimOpacity;
-    snapHeightsRef.current = snapHeights;
   });
 
   // Live drag bookkeeping (refs so pointermove doesn't churn renders).
@@ -349,13 +373,18 @@ export function useSheetGestures({
     return sheetElRef.current?.getBoundingClientRect().height ?? 0;
   }, []);
 
-  // Detent translate offsets (px) from the tallest detent, ascending. Exclude
-  // the border-box portion reserved below the viewport before comparing the
-  // candidate visible heights; otherwise every snap point lands that many px
-  // too low. Snap heights are resolved lazily so they track the viewport.
-  const detentOffsets = useCallback(height => {
+  // Detent translate offsets (px) from the tallest detent, ascending, plus the
+  // peek among them. Exclude the border-box portion reserved below the
+  // viewport before comparing the candidate visible heights; otherwise every
+  // snap point lands that many px too low. Snap heights are resolved lazily so
+  // they track the viewport.
+  const resolveDetents = useCallback(height => {
     const visibleSheetHeight = visibleHeightForOffset(height, 0, offscreenBlockEndInsetRef.current);
-    return computeDetentOffsets(visibleSheetHeight, snapHeightsRef.current?.() ?? []);
+    const offsets = computeDetentOffsets(visibleSheetHeight, snapHeightsRef.current?.() ?? []);
+    return {
+      offsets,
+      peekOffset: peekOffsetFor(offsets, visibleSheetHeight)
+    };
   }, []);
 
   // The height the sheet WOULD have fully open, right now. While it rests at a
@@ -389,48 +418,71 @@ export function useSheetGestures({
   //
   // Re-resolve the SAME detent — by index, the one thing that survives the
   // units changing — against the new geometry, and re-anchor without
-  // animating: the viewport moved, not the user's finger, so there is no
+  // animating: the geometry moved, not the user's finger, so there is no
   // gesture to continue and nothing to ease.
+  const reanchorToSettledDetent = useCallback(() => {
+    // A closed sheet re-anchors on its way back open; a live drag re-measures
+    // on its own, and a settle in flight owns the layout until it lands.
+    if (!isOpenRef.current || dragStateRef.current != null || settlingLayoutOffsetRef.current != null) {
+      return;
+    }
+    const height = measureFullyOpenHeight();
+    if (height <= 0) {
+      return;
+    }
+    const {
+      offsets,
+      peekOffset
+    } = resolveDetents(height);
+    const index = Math.min(settledDetentIndexRef.current, offsets.length - 1);
+    const target = offsets[index];
+    const targetLayoutOffset = target === peekOffset ? 0 : target;
+    const baseLayoutOffset = settledLayoutOffsetRef.current;
+    if (height === sheetHeightRef.current && Math.abs(target - activeOffsetRef.current) <= 0.5 && Math.abs(targetLayoutOffset - baseLayoutOffset) <= 0.5) {
+      return;
+    }
+    sheetHeightRef.current = height;
+    // Re-anchoring is a measurement: the geometry it reads is only knowable
+    // after layout, so the state it corrects can only be set from an effect
+    // (or, on the resize path, from the listener). Both writes below are
+    // guarded by the equality check above, so a re-anchor that finds nothing
+    // to change sets nothing.
+    // eslint-disable-next-line @eslint-react/set-state-in-effect -- corrects settled geometry from a measurement
+    setSheetHeight(height);
+    settledDetentIndexRef.current = index;
+    prepareScrollAreaSettle(baseLayoutOffset, target, targetLayoutOffset, target, baseLayoutOffset, naturalEndGapFor(bodyNodeRef.current), false);
+    recordSettledLayoutOffset(targetLayoutOffset);
+    // eslint-disable-next-line @eslint-react/set-state-in-effect -- corrects settled geometry from a measurement
+    setSettledOffset(target);
+    onSnapRef.current?.(visibleHeightForOffset(height, target, offscreenBlockEndInsetRef.current));
+    const maxOffset = offsets[offsets.length - 1];
+    const shortestDetentHeight = visibleHeightForOffset(height, maxOffset, offscreenBlockEndInsetRef.current);
+    onScrimOpacityRef.current?.(scrimOpacityForOffset(target, offsets, maxOffset + shortestDetentHeight * DISMISS_OVERSHOOT_RATIO, peekOffset));
+  }, [measureFullyOpenHeight, prepareScrollAreaSettle, recordSettledLayoutOffset, resolveDetents]);
   useEffect(() => {
     if (!isOpen || typeof window === 'undefined') {
       return;
     }
-    const handleViewportChange = () => {
-      // A live drag re-measures on its own, and a settle in flight owns the
-      // layout until it lands.
-      if (dragStateRef.current != null || settlingLayoutOffsetRef.current != null) {
-        return;
-      }
-      const height = measureFullyOpenHeight();
-      if (height <= 0) {
-        return;
-      }
-      const offsets = detentOffsets(height);
-      const index = Math.min(settledDetentIndexRef.current, offsets.length - 1);
-      const target = offsets[index];
-      const targetLayoutOffset = isPeekOffset(target, offsets) ? 0 : target;
-      const baseLayoutOffset = settledLayoutOffsetRef.current;
-      if (height === sheetHeightRef.current && Math.abs(target - activeOffsetRef.current) <= 0.5 && Math.abs(targetLayoutOffset - baseLayoutOffset) <= 0.5) {
-        return;
-      }
-      sheetHeightRef.current = height;
-      setSheetHeight(height);
-      settledDetentIndexRef.current = index;
-      prepareScrollAreaSettle(baseLayoutOffset, target, targetLayoutOffset, target, baseLayoutOffset, naturalEndGapFor(bodyNodeRef.current), false);
-      recordSettledLayoutOffset(targetLayoutOffset);
-      setSettledOffset(target);
-      onSnapRef.current?.(visibleHeightForOffset(height, target, offscreenBlockEndInsetRef.current));
-      const maxOffset = offsets[offsets.length - 1];
-      const shortestDetentHeight = visibleHeightForOffset(height, maxOffset, offscreenBlockEndInsetRef.current);
-      onScrimOpacityRef.current?.(scrimOpacityForOffset(target, offsets, maxOffset + shortestDetentHeight * DISMISS_OVERSHOOT_RATIO));
-    };
-    window.addEventListener('resize', handleViewportChange);
-    window.addEventListener('orientationchange', handleViewportChange);
+    window.addEventListener('resize', reanchorToSettledDetent);
+    window.addEventListener('orientationchange', reanchorToSettledDetent);
     return () => {
-      window.removeEventListener('resize', handleViewportChange);
-      window.removeEventListener('orientationchange', handleViewportChange);
+      window.removeEventListener('resize', reanchorToSettledDetent);
+      window.removeEventListener('orientationchange', reanchorToSettledDetent);
     };
-  }, [detentOffsets, isOpen, measureFullyOpenHeight, prepareScrollAreaSettle, recordSettledLayoutOffset]);
+  }, [isOpen, reanchorToSettledDetent]);
+
+  // The other input to the same geometry: the snap points themselves. A host
+  // that swaps them while the sheet rests has moved the stops out from under
+  // it, exactly as a rotation does, so re-anchor the same way. Skipped on the
+  // first run — the sheet is already anchored to the detents it opened with.
+  const hasAnchoredSnapHeightsRef = useRef(false);
+  useLayoutEffect(() => {
+    if (!hasAnchoredSnapHeightsRef.current) {
+      hasAnchoredSnapHeightsRef.current = true;
+      return;
+    }
+    reanchorToSettledDetent();
+  }, [reanchorToSettledDetent, snapHeights]);
   const cancelDrag = useCallback(target => {
     const state = dragStateRef.current;
     if (state == null) {
@@ -450,12 +502,15 @@ export function useSheetGestures({
     // An interrupted drag returns to its previous resting detent. Restore
     // the matching scrim opacity as well so the modal shell cannot remain
     // dimmed with its sheet translated out of view.
-    const offsets = detentOffsets(state.height);
+    const {
+      offsets,
+      peekOffset
+    } = resolveDetents(state.height);
     const maxOffset = offsets[offsets.length - 1];
     const shortestDetentHeight = visibleHeightForOffset(state.height, maxOffset, offscreenBlockEndInsetRef.current);
     const dismissOffset = maxOffset + shortestDetentHeight * DISMISS_OVERSHOOT_RATIO;
-    onScrimOpacityRef.current?.(scrimOpacityForOffset(state.baseOffset, offsets, dismissOffset));
-  }, [detentOffsets, prepareScrollAreaSettle]);
+    onScrimOpacityRef.current?.(scrimOpacityForOffset(state.baseOffset, offsets, dismissOffset, peekOffset));
+  }, [prepareScrollAreaSettle, resolveDetents]);
   useEffect(() => {
     const handleWindowBlur = () => cancelDrag();
     const handleVisibilityChange = () => {
@@ -471,7 +526,10 @@ export function useSheetGestures({
     };
   }, [cancelDrag]);
   const settleFromDrag = useCallback((offset, velocity, height, dir, travel, baseOffset, baseLayoutOffset, renderedOffset, layoutOffset, naturalEndGap) => {
-    const offsets = detentOffsets(height);
+    const {
+      offsets,
+      peekOffset
+    } = resolveDetents(height);
     const maxOffset = offsets[offsets.length - 1];
     const shortestDetentHeight = visibleHeightForOffset(height, maxOffset, offscreenBlockEndInsetRef.current);
     const speed = Math.abs(velocity);
@@ -479,14 +537,14 @@ export function useSheetGestures({
     const settleAt = target => {
       // A peek keeps the full layout height and slides below the viewport;
       // every taller detent resizes the scrolling area to what it shows.
-      const targetLayoutOffset = isPeekOffset(target, offsets) ? 0 : target;
+      const targetLayoutOffset = target === peekOffset ? 0 : target;
       prepareScrollAreaSettle(baseLayoutOffset, target, targetLayoutOffset, renderedOffset, layoutOffset, naturalEndGap, true);
       recordSettledLayoutOffset(targetLayoutOffset);
       settledDetentIndexRef.current = Math.max(0, offsets.indexOf(target));
       setSettledOffset(target);
       onSnapRef.current?.(visibleHeightForOffset(height, target, offscreenBlockEndInsetRef.current));
       const dismissOffset = maxOffset + shortestDetentHeight * DISMISS_OVERSHOOT_RATIO;
-      onScrimOpacityRef.current?.(scrimOpacityForOffset(target, offsets, dismissOffset));
+      onScrimOpacityRef.current?.(scrimOpacityForOffset(target, offsets, dismissOffset, peekOffset));
       if (target !== baseOffset) {
         hapticTick();
       }
@@ -526,10 +584,19 @@ export function useSheetGestures({
     // the starting detent), de-duped and direction-clamped by the util.
     const target = resolveSettleOffset(offset, offsets, dir, baseOffset);
     settleAt(target);
-  }, [detentOffsets, prepareScrollAreaSettle, recordSettledLayoutOffset]);
+  }, [prepareScrollAreaSettle, recordSettledLayoutOffset, resolveDetents]);
   const beginDrag = useCallback((event, sheetHeight, startCoord) => {
     const target = event.currentTarget;
-    target.setPointerCapture?.(event.pointerId);
+    const syntheticTouch = isSyntheticTouch(event);
+    // Never capture for a touch drag. The id came from `Touch.identifier`,
+    // which on iOS names a live pointer: the capture succeeds, WebKit takes
+    // it straight back for its own gesture handling, and the
+    // `lostpointercapture` a millisecond later cancels the drag that just
+    // started. Touch drags need no capture — the listener is on the
+    // scroller itself.
+    if (!syntheticTouch) {
+      target.setPointerCapture?.(event.pointerId);
+    }
     // `startCoord` lets a body-overscroll drag anchor at the original
     // pointer-down position (not the promotion point), so the first frame's
     // delta reflects the full pull distance.
@@ -537,6 +604,7 @@ export function useSheetGestures({
     const naturalEndGap = naturalEndGapFor(bodyNodeRef.current);
     const baseLayoutOffset = settledLayoutOffsetRef.current;
     dragStateRef.current = {
+      syntheticTouch,
       pointerId: event.pointerId,
       startCoord: start,
       lastCoord: event.clientY,
@@ -573,6 +641,12 @@ export function useSheetGestures({
     cancelDrag(event.currentTarget);
   }, [cancelDrag]);
   const handleLostPointerCapture = useCallback(event => {
+    // A touch drag never took capture, so this is WebKit reclaiming its own
+    // pointer for the finger doing the dragging — not the drag losing its
+    // grip.
+    if (dragStateRef.current?.syntheticTouch) {
+      return;
+    }
     if (dragStateRef.current?.pointerId === event.pointerId) {
       cancelDrag();
     }
@@ -582,6 +656,11 @@ export function useSheetGestures({
     if (!state || state.pointerId !== event.pointerId) {
       return;
     }
+    // Same finger, real pointer event: the touch path already drove this
+    // move. Let it own the drag rather than driving it twice.
+    if (state.syntheticTouch && !isSyntheticTouch(event)) {
+      return;
+    }
     const delta = event.clientY - state.startCoord;
     const dt = event.timeStamp - state.lastTime;
     if (dt > 0) {
@@ -589,7 +668,10 @@ export function useSheetGestures({
       state.lastCoord = event.clientY;
       state.lastTime = event.timeStamp;
     }
-    const offsets = detentOffsets(state.height);
+    const {
+      offsets,
+      peekOffset
+    } = resolveDetents(state.height);
     const raw = state.baseOffset + delta;
     const maxDetentOffset = offsets[offsets.length - 1];
     let next;
@@ -618,19 +700,27 @@ export function useSheetGestures({
     const floorOffset = offsets[offsets.length - 1];
     const shortestDetentHeight = visibleHeightForOffset(state.height, floorOffset, offscreenBlockEndInsetRef.current);
     const dismissOffset = floorOffset + shortestDetentHeight * DISMISS_OVERSHOOT_RATIO;
-    onScrimOpacityRef.current?.(scrimOpacityForOffset(next, offsets, dismissOffset));
-  }, [detentOffsets, updateScrollPreservationInset]);
+    onScrimOpacityRef.current?.(scrimOpacityForOffset(next, offsets, dismissOffset, peekOffset));
+  }, [resolveDetents, updateScrollPreservationInset]);
   const endDrag = useCallback(event => {
     const state = dragStateRef.current;
     if (!state || state.pointerId !== event.pointerId) {
       return;
     }
+    // `pointercancel` fires for the finger the moment WebKit claims the
+    // gesture; ending a touch drag on it settles the sheet mid-pull. The
+    // touchend handler is what finishes a touch drag.
+    if (state.syntheticTouch && !isSyntheticTouch(event)) {
+      return;
+    }
     const target = event.currentTarget;
     const delta = event.clientY - state.startCoord;
     const offset = Math.max(0, state.baseOffset + delta);
     const dir = delta === 0 ? 0 : delta > 0 ? 1 : -1;
     dragStateRef.current = null;
-    target.releasePointerCapture?.(event.pointerId);
+    if (!state.syntheticTouch) {
+      target.releasePointerCapture?.(event.pointerId);
+    }
     setIsDragging(false);
     settleFromDrag(offset, state.velocity, state.height || 1, dir, Math.abs(delta), state.baseOffset, state.baseLayoutOffset, state.renderedOffset, state.layoutOffset, state.naturalEndGap);
   }, [settleFromDrag]);
@@ -677,6 +767,11 @@ export function useSheetGestures({
   }, [beginDrag, handlePointerMove, measureHeight]);
   const handleBodyEnd = useCallback(event => {
     armedBodyRef.current = null;
+    // The pointerup/pointercancel for a finger already driving a touch drag
+    // arrives here carrying that drag's own id; touchend ends those.
+    if (dragStateRef.current?.syntheticTouch) {
+      return;
+    }
     if (dragStateRef.current) {
       endDrag(event);
     }
@@ -705,6 +800,7 @@ export function useSheetGestures({
   });
   const bodyRef = useCallback(node => {
     const asPointer = (touch, target) => ({
+      syntheticTouch: true,
       pointerId: touch.identifier,
       clientY: touch.clientY,
       timeStamp: Date.now(),

package/dist/Calendar/Calendar.d.ts

@@ -22,6 +22,23 @@ interface CalendarBaseProps extends Omit<BaseProps<HTMLDivElement>, 'onChange' |
      * Use for complex rules like "weekdays only" or "no holidays".
      */
     dateConstraints?: ReadonlyArray<(date: Date) => boolean>;
+    /**
+     * Range mode only. Maximum number of days a selected range may span,
+     * counting both endpoints — `maxRangeSpan={7}` allows a 7-day window
+     * (start + 6 days). Once a start date is picked, days beyond this distance
+     * from it are disabled in either direction; before a start is picked every
+     * otherwise-valid day stays selectable. Use for rolling windows like "at
+     * most a week from the chosen day". For fixed calendar bounds use min/max.
+     */
+    maxRangeSpan?: number;
+    /**
+     * Range mode only. Minimum number of days a selected range must span,
+     * counting both endpoints — `minRangeSpan={2}` forbids a single-day range.
+     * Once a start date is picked, days closer than this to it are disabled —
+     * except the start itself, which stays selectable as the active anchor.
+     * Defaults to 1 (a same-day start and end is allowed).
+     */
+    minRangeSpan?: number;
     /**
      * Controlled focus date (which month is visible).
      * If not provided, defaults to selected date or today.

package/dist/Calendar/Calendar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Calendar.d.ts","sourceRoot":"","sources":["../../src/Calendar/Calendar.tsx"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AA+C5C,YAAY,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,GACV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,EACV,MAAM,oBAAoB,CAAC;AAK5B,+CAA+C;AAE/C,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,UAAU,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;CAC3C;AAID,UAAU,iBAAkB,SAAQ,IAAI,CACtC,SAAS,CAAC,cAAc,CAAC,EACzB,UAAU,GAAG,cAAc,CAC5B;IACC,kDAAkD;IAClD,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAChC,qDAAqD;IACrD,SAAS,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACtC,+CAA+C;IAC/C,cAAc,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEvB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,aAAa,CAAC;IAEpB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,aAAa,CAAC;IAEpB;;;OAGG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC;IAEzD;;;OAGG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC;IAE1B,yDAAyD;IACzD,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,IAAI,CAAC;IAEvD;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,GAAG,aAAa,CAAC;CAC1C;AAID,UAAU,mBAAoB,SAAQ,iBAAiB;IACrD,qBAAqB;IACrB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAEhB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,aAAa,CAAC;IAEtB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,aAAa,CAAC;IAE7B,qCAAqC;IACrC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,IAAI,KAAK,IAAI,CAAC;CAC9D;AAED,UAAU,kBAAmB,SAAQ,iBAAiB;IACpD,qBAAqB;IACrB,IAAI,EAAE,OAAO,CAAC;IAEd,0BAA0B;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC;IAElB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,SAAS,CAAC;IAEzB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,kBAAkB,CAAC;AAMrE;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EAAC,GAAG,EAAE,GAAG,KAAK,EAAC,EAAE,aAAa,+BA+VtD;yBA/Ve,QAAQ"}
+{"version":3,"file":"Calendar.d.ts","sourceRoot":"","sources":["../../src/Calendar/Calendar.tsx"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AA+C5C,YAAY,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,GACV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,SAAS,EACV,MAAM,oBAAoB,CAAC;AAK5B,+CAA+C;AAE/C,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,UAAU,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;CAC3C;AAID,UAAU,iBAAkB,SAAQ,IAAI,CACtC,SAAS,CAAC,cAAc,CAAC,EACzB,UAAU,GAAG,cAAc,CAC5B;IACC,kDAAkD;IAClD,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAChC,qDAAqD;IACrD,SAAS,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACtC,+CAA+C;IAC/C,cAAc,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEvB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,aAAa,CAAC;IAEpB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,aAAa,CAAC;IAEpB;;;OAGG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC;IAEzD;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC;IAE1B,yDAAyD;IACzD,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,IAAI,CAAC;IAEvD;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,GAAG,aAAa,CAAC;CAC1C;AAID,UAAU,mBAAoB,SAAQ,iBAAiB;IACrD,qBAAqB;IACrB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAEhB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,aAAa,CAAC;IAEtB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,aAAa,CAAC;IAE7B,qCAAqC;IACrC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,IAAI,KAAK,IAAI,CAAC;CAC9D;AAED,UAAU,kBAAmB,SAAQ,iBAAiB;IACpD,qBAAqB;IACrB,IAAI,EAAE,OAAO,CAAC;IAEd,0BAA0B;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC;IAElB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,SAAS,CAAC;IAEzB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,kBAAkB,CAAC;AAMrE;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EAAC,GAAG,EAAE,GAAG,KAAK,EAAC,EAAE,aAAa,+BAoXtD;yBApXe,QAAQ"}

package/dist/Calendar/Calendar.js

@@ -69,6 +69,8 @@ export function Calendar({
     min,
     max,
     dateConstraints,
+    maxRangeSpan,
+    minRangeSpan,
     focusDate: focusDateProp,
     onFocusDateChange,
     hasOutsideDays = true,
@@ -247,6 +249,20 @@ export function Calendar({
       } else {
         // Second click - complete the range
         const startPd = plainDateFromISO(rangeSelectionStart);
+
+        // Clicking the anchor again clears the in-progress start rather than
+        // committing a zero-length range. This is also the escape hatch when
+        // `minRangeSpan` disables the days around the anchor: without it the
+        // anchor would be the only clickable day left and the start could
+        // never be moved. `minRangeSpan` leaves the anchor itself enabled
+        // precisely so this toggle stays reachable.
+        if (plainDateIsEqual(date, startPd)) {
+          setRangeSelectionStart(null);
+          announce(t('@astryx.calendar.rangeClearedAnnounce', {
+            date: plainDateFormat(date, DATE_FORMAT_WITH_WEEKDAY)
+          }));
+          return;
+        }
         let start;
         let end;
 
@@ -339,6 +355,8 @@ export function Calendar({
         min: min,
         max: max,
         dateConstraints: dateConstraints,
+        maxRangeSpan: maxRangeSpan,
+        minRangeSpan: minRangeSpan,
         hasOutsideDays: hasOutsideDays,
         hasWeekNumbers: hasWeekNumbers,
         hasVariableRowCount: hasVariableRowCount,
@@ -369,6 +387,8 @@ function MonthGrid({
   min,
   max,
   dateConstraints,
+  maxRangeSpan,
+  minRangeSpan,
   hasOutsideDays,
   hasWeekNumbers,
   hasVariableRowCount,
@@ -394,12 +414,20 @@ function MonthGrid({
     weekStartsOn,
     hasVariableRowCount
   });
+  const dayNameHeaders = useMemo(() => dayNames.map((name, offset) => ({
+    dayOfWeek: (weekStartsOn + offset) % 7,
+    name
+  })), [dayNames, weekStartsOn]);
+  const rangeAnchor = useMemo(() => mode === 'range' && rangeSelectionStart ? plainDateFromISO(rangeSelectionStart) : null, [mode, rangeSelectionStart]);
   const {
     isDateDisabled
   } = useCalendarConstraints({
     min,
     max,
-    dateConstraints
+    dateConstraints,
+    maxRangeSpan,
+    minRangeSpan,
+    rangeAnchor
   });
 
   // Parse selected date for roving tabindex priority
@@ -585,11 +613,14 @@ function MonthGrid({
         ...stylex.props(monthGridStyles.weekRow),
         children: [hasWeekNumbers && /*#__PURE__*/_jsx("div", {
           ...stylex.props(monthGridStyles.dayName, monthGridStyles.weekNumberHeader)
-        }), dayNames.map(name => /*#__PURE__*/_jsx("div", {
+        }), dayNameHeaders.map(({
+          dayOfWeek,
+          name
+        }) => /*#__PURE__*/_jsx("div", {
           role: "columnheader",
           ...stylex.props(monthGridStyles.dayName),
           children: name
-        }, name))]
+        }, dayOfWeek))]
       }), weeks.map(week => {
         const weekDate = week.find(d => !d.isOutside)?.date || week[0].date;
         const weekNum = plainDateGetWeekNumber(weekDate);

package/dist/Calendar/getStandaloneShortWeekdayNames.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file getStandaloneShortWeekdayNames.ts
+ * @input Generated CLDR stand-alone-short weekday table
+ * @output Private locale resolver for Calendar weekday headers
+ * @position Calendar-internal pure utility; not exported from the package
+ */
+import { type StandaloneShortWeekdayNames } from './standaloneShortWeekdayNames.generated';
+/**
+ * Resolve generated weekday reference data as exact locale -> language -> English.
+ * Unicode extensions are ignored through Intl.Locale.baseName. Invalid tags and
+ * valid but unsupported languages safely use English.
+ */
+export declare function getStandaloneShortWeekdayNames(locale: string): StandaloneShortWeekdayNames;
+//# sourceMappingURL=getStandaloneShortWeekdayNames.d.ts.map

package/dist/Calendar/getStandaloneShortWeekdayNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStandaloneShortWeekdayNames.d.ts","sourceRoot":"","sources":["../../src/Calendar/getStandaloneShortWeekdayNames.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,yCAAyC,CAAC;AAOjD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,MAAM,GACb,2BAA2B,CAW7B"}

package/dist/Calendar/getStandaloneShortWeekdayNames.js

@@ -0,0 +1,26 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file getStandaloneShortWeekdayNames.ts
+ * @input Generated CLDR stand-alone-short weekday table
+ * @output Private locale resolver for Calendar weekday headers
+ * @position Calendar-internal pure utility; not exported from the package
+ */
+
+import { standaloneShortWeekdayNamesByLocale } from "./standaloneShortWeekdayNames.generated.js";
+const weekdayNamesByLocale = standaloneShortWeekdayNamesByLocale;
+const englishWeekdayNames = weekdayNamesByLocale.en;
+
+/**
+ * Resolve generated weekday reference data as exact locale -> language -> English.
+ * Unicode extensions are ignored through Intl.Locale.baseName. Invalid tags and
+ * valid but unsupported languages safely use English.
+ */
+export function getStandaloneShortWeekdayNames(locale) {
+  try {
+    const parsed = new Intl.Locale(locale);
+    return weekdayNamesByLocale[parsed.baseName] ?? weekdayNamesByLocale[parsed.language] ?? englishWeekdayNames;
+  } catch {
+    return englishWeekdayNames;
+  }
+}

package/dist/Calendar/hooks/useCalendarConstraints.d.ts

@@ -13,6 +13,25 @@ export interface UseCalendarConstraintsOptions {
      * Date is disabled if ANY function returns false.
      */
     dateConstraints?: ReadonlyArray<(date: Date) => boolean>;
+    /**
+     * Maximum number of days a range may span, counting both endpoints
+     * (a value of 7 allows a 7-day window). In range mode, once a start is
+     * picked, dates further than this from it are disabled. No effect until a
+     * range anchor exists.
+     */
+    maxRangeSpan?: number;
+    /**
+     * Minimum number of days a range must span, counting both endpoints
+     * (a value of 2 forbids a single-day range). In range mode, once a start
+     * is picked, dates closer than this to it are disabled.
+     */
+    minRangeSpan?: number;
+    /**
+     * The in-progress range start (first click, awaiting the second). Span
+     * constraints are measured from this date. Null when no selection is
+     * underway.
+     */
+    rangeAnchor?: PlainDate | null;
 }
 /**
  * Return type for useCalendarConstraints hook
@@ -29,13 +48,15 @@ export interface UseCalendarConstraintsReturn {
  * Hook for managing calendar date validation constraints.
  *
  * Provides a function to check if a date is disabled based on
- * min/max bounds and custom constraint functions.
+ * min/max bounds, range-span bounds, and custom constraint functions.
  *
  * @example
  * ```
  * const {isDateDisabled} = useCalendarConstraints({
  *   min: '2026-01-01',
  *   max: '2026-12-31',
+ *   maxRangeSpan: 7, // once a start is picked, cap the window at 7 days
+ *   rangeAnchor, // the in-progress start (null before the first click)
  *   dateConstraints: [
  *     (date) => date.getDay() !== 0, // No Sundays (receives native Date)
  *   ],