@delacour/react-native-bottom-sheet 0.1.0-alpha.0 → 0.1.0-alpha.20261006140348

package/src/state/use-sheet-intents.ts

@@ -19,7 +19,7 @@ export type SheetIntentDispatch = (request: IntentRequest) => void;
  * A JS write to a shared value is queued to the UI thread, so reading
  * `state.intent.value` straight after a `dispatch` still returns what was
  * there before — the root once read `null` that way, queued an `open` on top
- * of a ref's `expand`, and the sheet landed on the wrong detent. `clear`
+ * of a ref's `expand`, and the sheet landed on the wrong snap point. `clear`
  * writes `null` in order after whatever was queued, which is what a controlled
  * `isOpen: false` needs to cancel an open still waiting on layout.
  */
@@ -43,7 +43,7 @@ export type SheetIntents = {
  * jump rather than an animation when `animateOnMount` is off. `mountPending`
  * is the flag, and it clears on that first resolution whatever kind it was.
  *
- * A second reaction handles the detents moving under a settled sheet — dynamic
+ * A second reaction handles the snap points moving under a settled sheet — dynamic
  * content growing, a `snapPoints` change — by animating to the same index in
  * the new list, and a container resize by jumping there instead. Neither runs
  * while a gesture or an animation owns `base`.
@@ -84,14 +84,14 @@ export function useSheetIntents(
 			// a close during the open animation has to see an open sheet.
 			const effectiveIndex =
 				state.animStatus.value === ANIM_STATUS.RUNNING
-					? Math.round(indexForHeight(state.animTarget.value, geometry.detents.value, geometry.closedHeight.value))
+					? Math.round(indexForHeight(state.animTarget.value, geometry.snapPoints.value, geometry.closedHeight.value))
 					: state.currentIndex.value;
 			const resolution = resolveIntent(
 				{
 					currentIndex: effectiveIndex,
 					base: state.base.value,
 					layoutReady: current.ready,
-					detents: geometry.detents.value,
+					snapPoints: geometry.snapPoints.value,
 					closedHeight: geometry.closedHeight.value,
 					maxHeight: geometry.maxHeight.value,
 					initialIndex: state.config.value.initialIndex,
@@ -117,18 +117,21 @@ export function useSheetIntents(
 	);
 
 	useAnimatedReaction(
-		() => ({ detents: geometry.detents.value.join(","), container: state.containerHeight.value }),
+		() => ({ snapPoints: geometry.snapPoints.value.join(","), container: state.containerHeight.value }),
 		(current, previous) => {
-			if (previous === null || (current.detents === previous.detents && current.container === previous.container)) {
+			if (
+				previous === null ||
+				(current.snapPoints === previous.snapPoints && current.container === previous.container)
+			) {
 				return;
 			}
 			const busy = state.animStatus.value !== ANIM_STATUS.IDLE || state.gestureSource.value !== GESTURE_SOURCE.NONE;
 			const index = state.currentIndex.value;
 			if (busy || index < 0) return;
 
-			const detents = geometry.detents.value;
-			if (detents.length === 0) return;
-			const target = heightForIndex(Math.min(index, detents.length - 1), detents, geometry.closedHeight.value);
+			const snapPoints = geometry.snapPoints.value;
+			if (snapPoints.length === 0) return;
+			const target = heightForIndex(Math.min(index, snapPoints.length - 1), snapPoints, geometry.closedHeight.value);
 			if (Math.abs(target - state.base.value) < 0.5) return;
 
 			if (current.container !== previous.container) {

package/src/state/use-sheet-state.ts

@@ -3,25 +3,25 @@ import { useSharedValue } from "react-native-reanimated";
 import {
 	type AnimationSource,
 	CLOSED_INDEX,
-	type DetentSpec,
 	GESTURE_SOURCE,
 	SCROLLABLE_TYPE,
 	type ScrollableType,
 	type SheetIntent,
+	type SnapPointSpec,
 	UNMEASURED,
 } from "../core";
 import { ANIM_STATUS, type AnimStatus, type SheetSharedState, type SheetWorkletConfig } from "./state.types";
 
 /**
- * Allocates the raw shared values, once per sheet, and keeps `detentSpec` and
+ * Allocates the raw shared values, once per sheet, and keeps `snapPointSpec` and
  * `config` in step with the props.
  *
- * `detentSpec` is written when its **serialisation** changes, not its identity,
+ * `snapPointSpec` is written when its **serialisation** changes, not its identity,
  * so a `snapPoints={["40%", "85%"]}` literal in a render body costs nothing —
  * the array identity churn that made the library this replaces re-derive on
  * every render is simply not observed.
  */
-export function useSheetState(snapPoints: readonly DetentSpec[], config: SheetWorkletConfig): SheetSharedState {
+export function useSheetState(snapPoints: readonly SnapPointSpec[], config: SheetWorkletConfig): SheetSharedState {
 	const containerHeight = useSharedValue(UNMEASURED);
 	const containerWidth = useSharedValue(UNMEASURED);
 	const containerBottomOffset = useSharedValue(0);
@@ -42,14 +42,14 @@ export function useSheetState(snapPoints: readonly DetentSpec[], config: SheetWo
 	const keyboardHeight = useSharedValue(0);
 	const intent = useSharedValue<SheetIntent | null>(null);
 	const mountPending = useSharedValue(true);
-	const detentSpec = useSharedValue<readonly DetentSpec[]>(snapPoints);
+	const snapPointSpec = useSharedValue<readonly SnapPointSpec[]>(snapPoints);
 	const configValue = useSharedValue<SheetWorkletConfig>(config);
 
 	const specKey = snapPoints.join("|");
 	// biome-ignore lint/correctness/useExhaustiveDependencies: keyed on the serialisation on purpose; the array is only read when it changes
 	useEffect(() => {
-		detentSpec.value = snapPoints;
-	}, [specKey, detentSpec]);
+		snapPointSpec.value = snapPoints;
+	}, [specKey, snapPointSpec]);
 
 	const {
 		dynamicSizing,
@@ -126,7 +126,7 @@ export function useSheetState(snapPoints: readonly DetentSpec[], config: SheetWo
 			keyboardHeight,
 			intent,
 			mountPending,
-			detentSpec,
+			snapPointSpec,
 			config: configValue,
 		}),
 		[
@@ -150,7 +150,7 @@ export function useSheetState(snapPoints: readonly DetentSpec[], config: SheetWo
 			keyboardHeight,
 			intent,
 			mountPending,
-			detentSpec,
+			snapPointSpec,
 			configValue,
 		]
 	);

package/src/state/{use-detents.ts → use-snap-points.ts}

@@ -1,17 +1,17 @@
 import { type SharedValue, useDerivedValue } from "react-native-reanimated";
-import { dynamicDetent, normalizeDetents } from "../core";
+import { dynamicSnapPoint, normalizeSnapPoints } from "../core";
 import type { SheetSharedState } from "./state.types";
 
 /**
- * The ascending, unique detents, recomputed on the UI thread whenever the spec,
+ * The ascending, unique snap points, recomputed on the UI thread whenever the spec,
  * the container or a measurement changes.
  *
- * The dynamic detent joins the list only once the handle and the content have
- * both reported — before that a sheet sized to its content has no detent at
+ * The dynamic snap point joins the list only once the handle and the content have
+ * both reported — before that a sheet sized to its content has no snap point at
  * all, and `layoutReady` keeps an open intent waiting rather than animating to
- * a guess. An explicit detent equal to the dynamic one is one detent, not two.
+ * a guess. An explicit snap point equal to the dynamic one is one snap point, not two.
  */
-export function useDetents(
+export function useSnapPoints(
 	state: SheetSharedState,
 	maxHeight: SharedValue<number>,
 	band: SharedValue<number>
@@ -19,13 +19,13 @@ export function useDetents(
 	return useDerivedValue<readonly number[]>(() => {
 		const available = maxHeight.value;
 		const config = state.config.value;
-		const detents = normalizeDetents(state.detentSpec.value, available);
+		const snapPoints = normalizeSnapPoints(state.snapPointSpec.value, available);
 
-		if (!config.dynamicSizing || available <= 0) return detents;
-		if (state.handleHeight.value < 0 || state.contentHeight.value < 0) return detents;
-		if (config.hasFooter && state.footerContentHeight.value < 0) return detents;
+		if (!config.dynamicSizing || available <= 0) return snapPoints;
+		if (state.handleHeight.value < 0 || state.contentHeight.value < 0) return snapPoints;
+		if (config.hasFooter && state.footerContentHeight.value < 0) return snapPoints;
 
-		const dynamic = dynamicDetent({
+		const dynamic = dynamicSnapPoint({
 			handleHeight: state.handleHeight.value,
 			contentHeight: state.contentHeight.value,
 			footerContentHeight: state.footerContentHeight.value,
@@ -34,9 +34,9 @@ export function useDetents(
 			available,
 			maxDynamicContentSize: config.maxDynamicContentSize,
 		});
-		if (detents.indexOf(dynamic) !== -1) return detents;
+		if (snapPoints.indexOf(dynamic) !== -1) return snapPoints;
 
-		const merged = [...detents, dynamic];
+		const merged = [...snapPoints, dynamic];
 		merged.sort((a, b) => a - b);
 		return merged;
 	});

package/src/steps/AGENTS.md

@@ -60,23 +60,23 @@ function Actions() {
   height is a shared value. Only the current step and, during a change, the
   one leaving are rendered; each is absolutely positioned across the top of
   the stack, measured by its `onLayout` while current.
-- **The height glides because the detent moves once.** When the current step
+- **The height glides because the snap point moves once.** When the current step
   measures, `Steps` writes the number to the sheet's `contentHeight` straight
-  away and springs the stack's height to it. The dynamic detent re-derives on
-  the UI thread, the root's detent-change reaction (`state/use-sheet-intents.ts`)
+  away and springs the stack's height to it. The dynamic snap point re-derives on
+  the UI thread, the root's snap-point-change reaction (`state/use-sheet-intents.ts`)
   animates `base` to the same index in the new list with the sheet's own
   animation, and — because the stack's spring is resolved from the same
   config — the panel's top edge and the body's bottom edge move together. A
-  sheet resting on an explicit detent does not move at all. If the sheet was
-  busy when the detent moved (a step change mid-open), the stack animation's
-  completion nudges `base` onto its detent.
+  sheet resting on an explicit snap point does not move at all. If the sheet was
+  busy when the snap point moved (a step change mid-open), the stack animation's
+  completion nudges `base` onto its snap point.
 - **`Content` stops measuring.** The internal context's
   `contentHeightSource` reads `steps` while a `Steps` body is mounted, and
   `Content`'s `onLayout` returns early; its layout events would otherwise be
   the stack mid-animation, a frame stale. The unmount reset to `UNMEASURED`
   still runs, so the next open waits for the first step to measure again.
 - **A step's `snapPoints` replace the root's, and turn dynamic sizing off,
-  while it is current.** A step that names its detents is sized by them.
+  while it is current.** A step that names its snap points is sized by them.
   `dismissible: false` switches off pan-down-to-close and the overlay's press
   for that step — `Close` and the ref still work. Both go through
   `setStepOverride` on the root (`components/bottom-sheet.tsx`), because the

package/src/steps/bottom-sheet-steps.tsx

@@ -34,20 +34,20 @@ function animateWith(animation: ReanimatedAnimation, value: number, complete: (f
  * across the top of the stack and only the current step and, during a change,
  * the one leaving are rendered. The stack's height is a shared value animated
  * to whatever the current step measures, and that same measurement is written
- * to the sheet's `contentHeight` the moment it lands, so the dynamic detent
- * moves once and the root's detent-change reaction animates `base` there with
+ * to the sheet's `contentHeight` the moment it lands, so the dynamic snap point
+ * moves once and the root's snap-point-change reaction animates `base` there with
  * the same spring the body is using: the panel's top edge and the body's
- * bottom edge glide together, and a sheet resting on an explicit detent does
- * not move at all. Should the sheet have been busy when the detent moved — a
+ * bottom edge glide together, and a sheet resting on an explicit snap point does
+ * not move at all. Should the sheet have been busy when the snap point moved — a
  * step change mid-open — the height animation's completion nudges it onto its
- * detent.
+ * snap point.
  *
  * `Content`'s own measurement is switched off while this is the body, or its
  * layout events would race the animated height with stale numbers.
  *
  * The step the machine is on decides two things about the sheet: its
  * `snapPoints` replace the root's while it is current (and dynamic sizing is
- * off for it — a step that names its detents is sized by them), and
+ * off for it — a step that names its snap points is sized by them), and
  * `dismissible: false` disables pan-down-to-close and the overlay's press.
  * Both go through the root, since the overlay is not a descendant of the body.
  *
@@ -159,9 +159,9 @@ export function BottomSheetSteps<S extends string, C, E extends SheetEvent>({
 				if (finished !== true) return;
 				const busy = state.animStatus.value !== ANIM_STATUS.IDLE || state.gestureSource.value !== GESTURE_SOURCE.NONE;
 				const index = state.currentIndex.value;
-				const detents = geometry.detents.value;
-				if (busy || index < 0 || detents.length === 0) return;
-				const target = heightForIndex(Math.min(index, detents.length - 1), detents, geometry.closedHeight.value);
+				const snapPoints = geometry.snapPoints.value;
+				if (busy || index < 0 || snapPoints.length === 0) return;
+				const target = heightForIndex(Math.min(index, snapPoints.length - 1), snapPoints, geometry.closedHeight.value);
 				if (Math.abs(target - state.base.value) > 0.5) animateTo(target, "snapPoints", 0);
 			};
 			stepHeight.value = animateWith(resolved, height, settle);

package/src/core/detents/dynamic-detent.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { dynamicDetent } from "./dynamic-detent";
-
-const measured = { handleHeight: 24, contentHeight: 300, footerContentHeight: 56, band: 34, available: 800 };
-
-describe("dynamicDetent", () => {
-	test("without a footer the sheet is handle, content and the safe-area band", () => {
-		expect(dynamicDetent({ ...measured, hasFooter: false })).toBe(24 + 300 + 34);
-	});
-
-	test("with a footer the footer content is included, and the band is counted once", () => {
-		expect(dynamicDetent({ ...measured, hasFooter: true })).toBe(24 + 300 + 56 + 34);
-	});
-
-	test("a detached sheet has no band, so it contributes nothing", () => {
-		expect(dynamicDetent({ ...measured, band: 0, hasFooter: true })).toBe(24 + 300 + 56);
-	});
-
-	test("never exceeds the available height", () => {
-		expect(dynamicDetent({ ...measured, contentHeight: 2000, hasFooter: true })).toBe(800);
-	});
-
-	test("maxDynamicContentSize caps below the available height", () => {
-		expect(dynamicDetent({ ...measured, contentHeight: 2000, hasFooter: false, maxDynamicContentSize: 500 })).toBe(500);
-	});
-
-	test("maxDynamicContentSize above the available height changes nothing", () => {
-		expect(dynamicDetent({ ...measured, contentHeight: 2000, hasFooter: false, maxDynamicContentSize: 5000 })).toBe(
-			800
-		);
-	});
-
-	test("unmeasured parts count as zero rather than pulling the sum negative", () => {
-		expect(dynamicDetent({ ...measured, handleHeight: -1, footerContentHeight: -1, hasFooter: true })).toBe(300 + 34);
-	});
-
-	test("an unmeasured container yields zero, never a negative height", () => {
-		expect(dynamicDetent({ ...measured, available: -1, hasFooter: false })).toBe(0);
-	});
-});

package/src/core/detents/index-for-height.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { heightForIndex, indexForHeight } from "./index-for-height";
-
-const detents = [200, 400, 800];
-
-describe("indexForHeight", () => {
-	test("each detent maps to its own integer index", () => {
-		expect(indexForHeight(200, detents, 0)).toBe(0);
-		expect(indexForHeight(400, detents, 0)).toBe(1);
-		expect(indexForHeight(800, detents, 0)).toBe(2);
-	});
-
-	test("the closed height is -1", () => {
-		expect(indexForHeight(0, detents, 0)).toBe(-1);
-		expect(indexForHeight(-32, detents, -32)).toBe(-1);
-	});
-
-	test("between detents the index is fractional, so the backdrop can follow a drag", () => {
-		expect(indexForHeight(100, detents, 0)).toBeCloseTo(-0.5);
-		expect(indexForHeight(300, detents, 0)).toBeCloseTo(0.5);
-		expect(indexForHeight(600, detents, 0)).toBeCloseTo(1.5);
-	});
-
-	test("clamps beyond either end — an over-drag never reports a detent that does not exist", () => {
-		expect(indexForHeight(-100, detents, 0)).toBe(-1);
-		expect(indexForHeight(900, detents, 0)).toBe(2);
-	});
-
-	test("with no detents every height is closed", () => {
-		expect(indexForHeight(300, [], 0)).toBe(-1);
-	});
-
-	test("a detent coinciding with the closed height does not divide by zero", () => {
-		expect(Number.isFinite(indexForHeight(0, [0, 400], 0))).toBe(true);
-		expect(indexForHeight(400, [0, 400], 0)).toBe(1);
-	});
-});
-
-describe("heightForIndex", () => {
-	test("round-trips every detent", () => {
-		for (const [index, height] of detents.entries()) {
-			expect(heightForIndex(index, detents, 0)).toBe(height);
-			expect(indexForHeight(heightForIndex(index, detents, 0), detents, 0)).toBe(index);
-		}
-	});
-
-	test("-1 is the closed height, resting line included", () => {
-		expect(heightForIndex(-1, detents, 0)).toBe(0);
-		expect(heightForIndex(-1, detents, -32)).toBe(-32);
-	});
-
-	test("clamps an out-of-range index to the nearest end", () => {
-		expect(heightForIndex(5, detents, 0)).toBe(800);
-		expect(heightForIndex(-3, detents, 0)).toBe(0);
-	});
-
-	test("a fractional index interpolates, mirroring indexForHeight", () => {
-		expect(heightForIndex(0.5, detents, 0)).toBe(300);
-		expect(heightForIndex(-0.5, detents, 0)).toBe(100);
-	});
-
-	test("with no detents every index is closed", () => {
-		expect(heightForIndex(0, [], -16)).toBe(-16);
-	});
-});

package/src/core/detents/normalize-detents.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { DetentSpec } from "../sheet.types";
-import { normalizeDetents, parseDetent } from "./normalize-detents";
-
-describe("parseDetent", () => {
-	test("a finite non-negative number is pixels", () => {
-		expect(parseDetent(300)).toEqual({ success: true, data: { kind: "px", value: 300 } });
-		expect(parseDetent(0)).toEqual({ success: true, data: { kind: "px", value: 0 } });
-	});
-
-	test("a percentage string is a fraction of the available height", () => {
-		expect(parseDetent("50%")).toEqual({ success: true, data: { kind: "percent", value: 50 } });
-		expect(parseDetent("12.5%")).toEqual({ success: true, data: { kind: "percent", value: 12.5 } });
-	});
-
-	test("refuses NaN, infinities and negatives by name", () => {
-		for (const bad of [Number.NaN, Number.POSITIVE_INFINITY, -1] as const) {
-			expect(parseDetent(bad)).toEqual({ success: false, error: { code: "invalid-snap-point", value: bad } });
-		}
-	});
-
-	test("refuses a string that is not a percentage", () => {
-		for (const bad of ["50", "abc%", "%", "-10%", "50px"]) {
-			expect(parseDetent(bad as DetentSpec)).toEqual({
-				success: false,
-				error: { code: "invalid-snap-point", value: bad },
-			});
-		}
-	});
-
-	test("refuses anything that is not a number or a string", () => {
-		expect(parseDetent(undefined as unknown as DetentSpec)).toEqual({
-			success: false,
-			error: { code: "invalid-snap-point", value: undefined },
-		});
-	});
-});
-
-describe("normalizeDetents", () => {
-	test("pixels pass through", () => {
-		expect(normalizeDetents([200, 400], 800)).toEqual([200, 400]);
-	});
-
-	test("percentages resolve against the available height", () => {
-		expect(normalizeDetents(["25%", "50%", "100%"], 800)).toEqual([200, 400, 800]);
-	});
-
-	test("mixed specs sort ascending regardless of authoring order", () => {
-		expect(normalizeDetents(["100%", 100, "50%"], 800)).toEqual([100, 400, 800]);
-	});
-
-	test("duplicates collapse, including a pixel and a percentage that agree", () => {
-		expect(normalizeDetents([400, "50%", 400], 800)).toEqual([400]);
-	});
-
-	test("clamps to the available height and to zero", () => {
-		expect(normalizeDetents([1000, "150%"], 800)).toEqual([800]);
-	});
-
-	test("skips an invalid spec rather than poisoning the list", () => {
-		expect(normalizeDetents([Number.NaN, "x%" as DetentSpec, 300], 800)).toEqual([300]);
-	});
-
-	test("an unmeasured or zero available height yields nothing to snap to", () => {
-		expect(normalizeDetents(["50%"], -1)).toEqual([]);
-		expect(normalizeDetents([300], 0)).toEqual([]);
-	});
-
-	test("an empty spec is an empty list", () => {
-		expect(normalizeDetents([], 800)).toEqual([]);
-	});
-});

package/src/core/detents/sheet-state.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { SHEET_STATE } from "../sheet.types";
-import { sheetState } from "./sheet-state";
-
-const detents = [200, 400];
-const maxHeight = 800;
-
-describe("sheetState", () => {
-	test("at or below the closed height the sheet is closed", () => {
-		expect(sheetState(0, 0, detents, 0, maxHeight)).toBe(SHEET_STATE.CLOSED);
-		expect(sheetState(-10, -10, detents, 0, maxHeight)).toBe(SHEET_STATE.CLOSED);
-		expect(sheetState(-32, -32, detents, -32, maxHeight)).toBe(SHEET_STATE.CLOSED);
-	});
-
-	test("between closed and the highest detent it is opened", () => {
-		expect(sheetState(200, 200, detents, 0, maxHeight)).toBe(SHEET_STATE.OPENED);
-		expect(sheetState(300, 300, detents, 0, maxHeight)).toBe(SHEET_STATE.OPENED);
-	});
-
-	test("at the highest detent it is extended", () => {
-		expect(sheetState(400, 400, detents, 0, maxHeight)).toBe(SHEET_STATE.EXTENDED);
-	});
-
-	test("a hair below the highest detent still counts as extended, so a settled spring unlocks the list", () => {
-		expect(sheetState(399.7, 399.7, detents, 0, maxHeight)).toBe(SHEET_STATE.EXTENDED);
-	});
-
-	test("above the highest detent — over-drag or a keyboard lift — it is over-extended", () => {
-		expect(sheetState(450, 450, detents, 0, maxHeight)).toBe(SHEET_STATE.OVER_EXTENDED);
-		expect(sheetState(400, 600, detents, 0, maxHeight)).toBe(SHEET_STATE.OVER_EXTENDED);
-	});
-
-	test("filling the available height is fill, whatever the detents say", () => {
-		expect(sheetState(800, 800, detents, 0, maxHeight)).toBe(SHEET_STATE.FILL);
-		expect(sheetState(400, 800, detents, 0, maxHeight)).toBe(SHEET_STATE.FILL);
-		expect(sheetState(800, 800, [200, 800], 0, maxHeight)).toBe(SHEET_STATE.FILL);
-	});
-
-	test("with no detents anything open is extended, so a dynamic sheet still unlocks its list", () => {
-		expect(sheetState(300, 300, [], 0, maxHeight)).toBe(SHEET_STATE.EXTENDED);
-	});
-});

package/src/core/haptic/crossed-detent.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { crossedDetent, detentUnder } from "./crossed-detent";
-
-const detents = [200, 400, 800];
-
-describe("detentUnder", () => {
-	test("the index of the highest detent at or below the height, -1 below the first", () => {
-		expect(detentUnder(100, detents)).toBe(-1);
-		expect(detentUnder(200, detents)).toBe(0);
-		expect(detentUnder(399, detents)).toBe(0);
-		expect(detentUnder(400, detents)).toBe(1);
-		expect(detentUnder(900, detents)).toBe(2);
-	});
-
-	test("a hair below a detent counts as on it, so a settled spring is not a phantom crossing", () => {
-		expect(detentUnder(399.8, detents)).toBe(1);
-	});
-
-	test("with no detents nothing is ever under the sheet", () => {
-		expect(detentUnder(300, [])).toBe(-1);
-	});
-});
-
-describe("crossedDetent", () => {
-	test("true when the drag crosses a detent in either direction", () => {
-		expect(crossedDetent(0, 401, detents)).toBe(true);
-		expect(crossedDetent(1, 399, detents)).toBe(true);
-	});
-
-	test("false while the drag stays between the same detents", () => {
-		expect(crossedDetent(0, 250, detents)).toBe(false);
-		expect(crossedDetent(0, 399, detents)).toBe(false);
-	});
-
-	test("crossing the lowest detent downward counts, so a haptic fires on the way to closed too", () => {
-		expect(crossedDetent(0, 150, detents)).toBe(true);
-	});
-
-	test("a frame that skips a detent is one crossing, and detentUnder says where it landed", () => {
-		expect(crossedDetent(-1, 850, detents)).toBe(true);
-		expect(detentUnder(850, detents)).toBe(2);
-	});
-});

package/src/core/haptic/crossed-detent.ts

@@ -1,33 +0,0 @@
-/** Settle tolerance: a spring at rest is within this of its target. */
-const SETTLE_EPSILON = 0.5;
-
-/**
- * The index of the highest detent at or below `height`, `-1` below the
- * first. A hair under a detent counts as on it, so a spring settling a
- * fraction short is not a crossing.
- */
-export function detentUnder(height: number, detents: readonly number[]): number {
-	"worklet";
-	let under = -1;
-	for (let index = 0; index < detents.length; index += 1) {
-		if (height + SETTLE_EPSILON >= (detents[index] as number)) under = index;
-		else break;
-	}
-	return under;
-}
-
-/**
- * Whether a drag crossed a detent this frame: the detent now under the sheet
- * differs from `lastIndex`, the one the pan stored last frame. On `true` the
- * pan fires its haptic and stores `detentUnder(height, detents)`. A frame
- * that leaps two detents is one crossing, not a burst.
- */
-export function crossedDetent(lastIndex: number, height: number, detents: readonly number[]): boolean {
-	"worklet";
-	let under = -1;
-	for (let index = 0; index < detents.length; index += 1) {
-		if (height + SETTLE_EPSILON >= (detents[index] as number)) under = index;
-		else break;
-	}
-	return under !== lastIndex;
-}