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

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

@@ -0,0 +1,41 @@
+/** Everything the dynamic detent is a sum of, in height space. */
+export type DynamicDetentInput = {
+	/** Measured handle height; `UNMEASURED` counts as zero. */
+	handleHeight: number;
+	/** Measured content height; `UNMEASURED` counts as zero. */
+	contentHeight: number;
+	/** Measured footer content height; ignored when `hasFooter` is false. */
+	footerContentHeight: number;
+	/** The safe-area band under the sheet — zero for a detached sheet. */
+	band: number;
+	hasFooter: boolean;
+	/** The height the sheet may occupy. */
+	available: number;
+	/** An optional cap on the whole detent, below `available`. */
+	maxDynamicContentSize?: number;
+};
+
+/**
+ * The detent a sheet sized to its content settles at.
+ *
+ * Handle, content and — unlike the library this replaces — the footer's
+ * content are all in, and the safe-area band exactly once: it lives inside the
+ * footer when there is one and under the content when there is not. Capped by
+ * `maxDynamicContentSize` and always by `available`.
+ */
+export function dynamicDetent(input: DynamicDetentInput): number {
+	"worklet";
+	const handle = input.handleHeight > 0 ? input.handleHeight : 0;
+	const content = input.contentHeight > 0 ? input.contentHeight : 0;
+	const footer = input.hasFooter && input.footerContentHeight > 0 ? input.footerContentHeight : 0;
+	const band = input.band > 0 ? input.band : 0;
+	const available = input.available > 0 ? input.available : 0;
+
+	let cap = available;
+	if (input.maxDynamicContentSize !== undefined && input.maxDynamicContentSize < cap) {
+		cap = input.maxDynamicContentSize > 0 ? input.maxDynamicContentSize : 0;
+	}
+
+	const sum = handle + content + footer + band;
+	return sum < cap ? sum : cap;
+}

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

@@ -0,0 +1,65 @@
+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/index-for-height.ts

@@ -0,0 +1,44 @@
+import { CLOSED_INDEX } from "../sheet.types";
+
+/**
+ * The index a height corresponds to: `-1` closed, `0` the lowest detent,
+ * fractional in between, clamped at both ends.
+ *
+ * Piecewise-linear over `[closedHeight, ...detents]` → `[-1, 0, 1, …]`. It is
+ * fed `base`, never `height`, so a keyboard lift moves the sheet without
+ * moving the index or the backdrop that follows it.
+ */
+export function indexForHeight(height: number, detents: readonly number[], closedHeight: number): number {
+	"worklet";
+	const count = detents.length;
+	if (count === 0 || height <= closedHeight) return CLOSED_INDEX;
+
+	let lower = closedHeight;
+	for (let index = 0; index < count; index += 1) {
+		const upper = detents[index] as number;
+		if (height <= upper) {
+			const span = upper - lower;
+			if (span <= 0) return index;
+			return index - 1 + (height - lower) / span;
+		}
+		lower = upper;
+	}
+	return count - 1;
+}
+
+/**
+ * The inverse: the height at an index, `-1` being the closed height. Integers
+ * land on detents, fractions interpolate, and an out-of-range index clamps.
+ */
+export function heightForIndex(index: number, detents: readonly number[], closedHeight: number): number {
+	"worklet";
+	const count = detents.length;
+	if (count === 0 || index <= CLOSED_INDEX) return closedHeight;
+	if (index >= count - 1) return detents[count - 1] as number;
+
+	const upperIndex = Math.ceil(index);
+	const lower = upperIndex === 0 ? closedHeight : (detents[upperIndex - 1] as number);
+	const upper = detents[upperIndex] as number;
+	const fraction = index - (upperIndex - 1);
+	return lower + (upper - lower) * fraction;
+}

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

@@ -0,0 +1,72 @@
+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/normalize-detents.ts

@@ -0,0 +1,63 @@
+import { err, ok, type Result } from "../result";
+import type { DetentSpec } from "../sheet.types";
+
+/** A detent with its unit made explicit. */
+export type ParsedDetent = { kind: "px"; value: number } | { kind: "percent"; value: number };
+
+/** Why a detent could not be read. `value` is what the consumer wrote. */
+export type DetentError = { code: "invalid-snap-point"; value: unknown };
+
+/**
+ * Reads one detent as the consumer wrote it — `300` or `"50%"` — refusing
+ * `NaN`, infinities, negatives and any string that is not a percentage.
+ *
+ * This is the JS-thread validator, for `snapToPosition` and for surfacing a
+ * bad `snapPoints` prop by name. The worklet below re-implements the same
+ * parse inline, because a module-scope worklet may not call it.
+ */
+export function parseDetent(spec: DetentSpec): Result<ParsedDetent, DetentError> {
+	if (typeof spec === "number") {
+		if (!Number.isFinite(spec) || spec < 0) return err({ code: "invalid-snap-point", value: spec });
+		return ok({ kind: "px", value: spec });
+	}
+	if (typeof spec === "string") {
+		const match = /^(\d+(?:\.\d+)?)%$/.exec(spec);
+		if (match === null) return err({ code: "invalid-snap-point", value: spec });
+		return ok({ kind: "percent", value: Number(match[1]) });
+	}
+	return err({ code: "invalid-snap-point", value: spec });
+}
+
+/**
+ * Resolves a `snapPoints` spec into ascending, unique heights, each clamped
+ * to `[0, available]`.
+ *
+ * `available` is the height the sheet may occupy — the container height less
+ * the resting bottom for a detached sheet. While it is unmeasured (or zero)
+ * there is nothing to snap to, and the result is empty rather than a list of
+ * zeros. An invalid entry is skipped, never written into the list: one `NaN`
+ * in `detents` freezes a sheet.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: the flat-worklet rule forbids extracting helpers; see the doc comment above.
+export function normalizeDetents(spec: readonly DetentSpec[], available: number): number[] {
+	"worklet";
+	if (!(available > 0)) return [];
+
+	const heights: number[] = [];
+	for (let index = 0; index < spec.length; index += 1) {
+		const entry = spec[index];
+		let height = Number.NaN;
+		if (typeof entry === "number") {
+			height = entry;
+		} else if (typeof entry === "string" && entry.length > 1 && entry.charCodeAt(entry.length - 1) === 37) {
+			height = (Number(entry.slice(0, -1)) / 100) * available;
+		}
+		if (!Number.isFinite(height)) continue;
+
+		const clamped = height < 0 ? 0 : height > available ? available : height;
+		if (heights.indexOf(clamped) === -1) heights.push(clamped);
+	}
+
+	heights.sort((a, b) => a - b);
+	return heights;
+}

package/src/core/detents/over-drag.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { resistOverDrag } from "./over-drag";
+
+describe("resistOverDrag", () => {
+	test("inside the range the height passes through untouched", () => {
+		expect(resistOverDrag(300, 0, 800, 2.5)).toBe(300);
+		expect(resistOverDrag(0, 0, 800, 2.5)).toBe(0);
+		expect(resistOverDrag(800, 0, 800, 2.5)).toBe(800);
+	});
+
+	test("is continuous at the boundary", () => {
+		expect(resistOverDrag(800.001, 0, 800, 2.5)).toBeCloseTo(800, 2);
+		expect(resistOverDrag(-0.001, 0, 800, 2.5)).toBeCloseTo(0, 2);
+	});
+
+	test("beyond the top it is monotone and sub-linear", () => {
+		let previous = 800;
+		let previousGain = Number.POSITIVE_INFINITY;
+		for (let over = 10; over <= 400; over += 10) {
+			const value = resistOverDrag(800 + over, 0, 800, 2.5);
+			expect(value).toBeGreaterThan(previous);
+			expect(value - 800).toBeLessThan(over);
+			const gain = value - previous;
+			expect(gain).toBeLessThanOrEqual(previousGain);
+			previous = value;
+			previousGain = gain;
+		}
+	});
+
+	test("beyond the bottom it resists symmetrically", () => {
+		expect(resistOverDrag(-100, 0, 800, 2.5)).toBeCloseTo(-(resistOverDrag(900, 0, 800, 2.5) - 800));
+	});
+
+	test("a factor of zero is a hard clamp", () => {
+		expect(resistOverDrag(900, 0, 800, 0)).toBe(800);
+		expect(resistOverDrag(-100, 0, 800, 0)).toBe(0);
+	});
+
+	test("a larger factor gives more travel for the same over-drag", () => {
+		expect(resistOverDrag(900, 0, 800, 4)).toBeGreaterThan(resistOverDrag(900, 0, 800, 2));
+	});
+
+	test("an inverted range collapses to its minimum rather than oscillating", () => {
+		expect(resistOverDrag(500, 800, 200, 2.5)).toBe(800);
+	});
+});

package/src/core/detents/over-drag.ts

@@ -0,0 +1,23 @@
+/**
+ * A dragged height pulled back toward `[min, max]` with rubber-band
+ * resistance once it leaves the range.
+ *
+ * Beyond either end the travel is `(√(1 + 2·over / factor) − 1) · factor`:
+ * slope 1 at the boundary so the sheet never jumps or races the finger,
+ * then square-root growth — monotone and sub-linear, so the finger is always
+ * ahead. A `factor` of `0` is a hard clamp, and a larger factor allows more
+ * travel. An inverted range collapses to `min`.
+ */
+export function resistOverDrag(height: number, min: number, max: number, factor: number): number {
+	"worklet";
+	if (max < min) return min;
+	if (height >= min && height <= max) return height;
+	if (!(factor > 0)) return height < min ? min : max;
+
+	if (height > max) {
+		const over = height - max;
+		return max + (Math.sqrt(1 + (2 * over) / factor) - 1) * factor;
+	}
+	const under = min - height;
+	return min - (Math.sqrt(1 + (2 * under) / factor) - 1) * factor;
+}

package/src/core/detents/select-snap-height.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { selectSnapHeight } from "./select-snap-height";
+
+const detents = [200, 400, 800];
+const at = (height: number, velocity = 0, closedHeight: number | null = 0) =>
+	selectSnapHeight({ height, velocity, detents, closedHeight, projection: 0.2 });
+
+describe("selectSnapHeight", () => {
+	test("at rest, the nearest detent wins", () => {
+		expect(at(250)).toBe(200);
+		expect(at(350)).toBe(400);
+		expect(at(700)).toBe(800);
+	});
+
+	test("velocity projects the release point — a flick upward reaches the next detent", () => {
+		expect(at(250, 1000)).toBe(400);
+	});
+
+	test("a flick downward from just above a detent falls through it", () => {
+		expect(at(420, -1500)).toBe(200);
+	});
+
+	test("closes only when a closed height is offered", () => {
+		expect(at(50)).toBe(0);
+		expect(at(50, 0, null)).toBe(200);
+	});
+
+	test("a detached closed height is a real candidate, resting line included", () => {
+		expect(at(-20, 0, -32)).toBe(-32);
+	});
+
+	test("a hard downward flick closes when it can", () => {
+		expect(at(700, -4000)).toBe(0);
+		expect(at(700, -4000, null)).toBe(200);
+	});
+
+	test("a projection past the highest detent still lands on it", () => {
+		expect(at(700, 5000)).toBe(800);
+	});
+
+	test("exactly between two detents, the lower one wins", () => {
+		expect(at(300)).toBe(200);
+	});
+
+	test("with nothing to snap to, the height is left where it is", () => {
+		expect(selectSnapHeight({ height: 123, velocity: 0, detents: [], closedHeight: null, projection: 0.2 })).toBe(123);
+	});
+
+	test("a NaN velocity is treated as rest rather than poisoning the target", () => {
+		expect(at(350, Number.NaN)).toBe(400);
+	});
+});

package/src/core/detents/select-snap-height.ts

@@ -0,0 +1,44 @@
+export type SelectSnapHeightInput = {
+	/** Where the finger let go, in height space. */
+	height: number;
+	/** Release velocity in height space — upward positive, so pass `-velocityY`. */
+	velocity: number;
+	/** Ascending detents. */
+	detents: readonly number[];
+	/** The closed height when closing is allowed from this gesture, else `null`. */
+	closedHeight: number | null;
+	/** Seconds of velocity to project — the `0.2` the previous engine used. */
+	projection: number;
+};
+
+/**
+ * The detent a released drag settles at: the candidate nearest to where the
+ * finger was heading, `height + projection · velocity`.
+ *
+ * Closing is a candidate only when `closedHeight` is given; the pan passes
+ * `null` unless `enablePanDownToClose`. On a tie the lower candidate wins.
+ */
+export function selectSnapHeight(input: SelectSnapHeightInput): number {
+	"worklet";
+	const velocity = Number.isFinite(input.velocity) ? input.velocity : 0;
+	const projected = input.height + input.projection * velocity;
+
+	let best = input.height;
+	let bestDistance = Number.POSITIVE_INFINITY;
+
+	if (input.closedHeight !== null) {
+		best = input.closedHeight;
+		bestDistance = Math.abs(projected - input.closedHeight);
+	}
+
+	for (let index = 0; index < input.detents.length; index += 1) {
+		const candidate = input.detents[index] as number;
+		const distance = Math.abs(projected - candidate);
+		if (distance < bestDistance) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+
+	return best;
+}

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

@@ -0,0 +1,42 @@
+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/detents/sheet-state.ts

@@ -0,0 +1,32 @@
+import { SHEET_STATE, type SheetState } from "../sheet.types";
+
+/** Settle tolerance: a spring at rest is within this of its target. */
+const SETTLE_EPSILON = 0.5;
+
+/**
+ * Where the sheet is relative to its detents.
+ *
+ * `base` decides closed and extended — the keyboard-free height is what the
+ * gesture and the scroll lock reason about. `height` decides fill and
+ * over-extended, because a keyboard lift or an over-drag pushes the visible
+ * sheet past the highest detent without moving `base`. With no detents (a
+ * dynamic sheet whose content is the only detent, before it measures) any
+ * open height is extended, so the list under it is never locked.
+ */
+export function sheetState(
+	base: number,
+	height: number,
+	detents: readonly number[],
+	closedHeight: number,
+	maxHeight: number
+): SheetState {
+	"worklet";
+	if (base <= closedHeight + SETTLE_EPSILON) return SHEET_STATE.CLOSED;
+	if (height >= maxHeight - SETTLE_EPSILON) return SHEET_STATE.FILL;
+
+	const count = detents.length;
+	const highest = count > 0 ? (detents[count - 1] as number) : base;
+	if (height > highest + SETTLE_EPSILON) return SHEET_STATE.OVER_EXTENDED;
+	if (base >= highest - SETTLE_EPSILON) return SHEET_STATE.EXTENDED;
+	return SHEET_STATE.OPENED;
+}

package/src/core/footer/body-inset.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import { bodyClip, bodyInset, scrollContentHeight } from "./body-inset";
+
+describe("bodyInset", () => {
+	test("with a sticky footer the body reserves the footer, band included", () => {
+		expect(bodyInset(true, 90, 34)).toBe(90);
+	});
+
+	test("without one it reserves the band alone", () => {
+		expect(bodyInset(false, 0, 34)).toBe(34);
+	});
+
+	test("the band is gone under the keyboard, and so is the reservation", () => {
+		expect(bodyInset(false, 0, 0)).toBe(0);
+	});
+
+	test("never negative — an unmeasured footer reserves nothing", () => {
+		expect(bodyInset(true, -1, 34)).toBe(0);
+		expect(bodyInset(false, 0, -1)).toBe(0);
+	});
+});
+
+describe("bodyClip", () => {
+	const at = (sheetHeight: number) =>
+		bodyClip({ contentArea: 486, inset: 90, hasFooter: true, sheetHeight, handleHeight: 24, keyboardHeight: 0 });
+
+	test("at rest on its detent the body is clipped exactly at the footer's top edge", () => {
+		// contentArea 486 = 600 − 24 − 90; the body is laid out 90 deeper, to the
+		// sheet's bottom line, and the clip hides that 90 behind the footer.
+		expect(at(600)).toBe(486);
+	});
+
+	test("dragged below its detent the clip follows the live height, so nothing shows under the footer", () => {
+		expect(at(500)).toBe(386);
+		expect(at(200)).toBe(86);
+	});
+
+	test("above its detent — an over-drag — the clip stays at the laid-out body", () => {
+		expect(at(700)).toBe(486 + 90);
+	});
+
+	test("nearly closed, the footer sits at the top of the panel and the body is fully hidden", () => {
+		expect(at(100)).toBe(0);
+		expect(at(0)).toBe(0);
+	});
+
+	test("under the keyboard the footer's top edge is the keyboard's less the footer, and the clip follows", () => {
+		expect(
+			bodyClip({
+				contentArea: 150,
+				inset: 90,
+				hasFooter: true,
+				sheetHeight: 600,
+				handleHeight: 24,
+				keyboardHeight: 336,
+			})
+		).toBe(150);
+		expect(
+			bodyClip({
+				contentArea: 150,
+				inset: 90,
+				hasFooter: true,
+				sheetHeight: 550,
+				handleHeight: 24,
+				keyboardHeight: 336,
+			})
+		).toBe(100);
+	});
+
+	test("without a footer the body is never clipped short of its layout: it slides with the sheet", () => {
+		expect(
+			bodyClip({ contentArea: 542, inset: 34, hasFooter: false, sheetHeight: 300, handleHeight: 24, keyboardHeight: 0 })
+		).toBe(576);
+	});
+
+	test("unmeasured parts count as zero", () => {
+		expect(
+			bodyClip({ contentArea: -1, inset: -1, hasFooter: true, sheetHeight: 600, handleHeight: -1, keyboardHeight: 0 })
+		).toBe(0);
+	});
+});
+
+describe("scrollContentHeight", () => {
+	test("the rows are the content size less the trailing spacer", () => {
+		expect(scrollContentHeight(1234, 90)).toBe(1144);
+	});
+
+	test("an unmeasured spacer subtracts nothing", () => {
+		expect(scrollContentHeight(1234, -1)).toBe(1234);
+	});
+
+	test("never negative", () => {
+		expect(scrollContentHeight(30, 90)).toBe(0);
+	});
+});