@windmorph/react 0.0.0-stage → 0.1.0

package/dist/components/carousel/carousel-keylines.js

@@ -0,0 +1,486 @@
+const ANCHOR_SIZE = 10;
+const MEDIUM_ITEM_FLEX_PERCENTAGE = .1;
+const lerp = (a, b, t) => a + (b - a) * t;
+function isValidArrangement(a) {
+	if (a.largeCount > 0 && a.smallCount > 0 && a.mediumCount > 0) return a.largeSize > a.mediumSize && a.mediumSize > a.smallSize;
+	if (a.largeCount > 0 && a.smallCount > 0) return a.largeSize > a.smallSize;
+	return true;
+}
+const cost = (a, targetLargeSize) => isValidArrangement(a) ? Math.abs(targetLargeSize - a.largeSize) * a.priority : Number.MAX_VALUE;
+const arrangementCount = (a) => a.largeCount + a.mediumCount + a.smallCount;
+function fit(priority, availableSpace, itemSpacing, smallCount, smallSize, minSmallSize, maxSmallSize, mediumCount, mediumSize, largeCount, largeSize) {
+	const space = availableSpace - (largeCount + mediumCount + smallCount - 1) * itemSpacing;
+	let small = Math.min(Math.max(smallSize, minSmallSize), maxSmallSize);
+	const delta = space - (largeSize * largeCount + mediumSize * mediumCount + small * smallCount);
+	if (smallCount > 0 && delta > 0) small += Math.min(delta / smallCount, maxSmallSize - small);
+	else if (smallCount > 0 && delta < 0) small += Math.max(delta / smallCount, minSmallSize - small);
+	small = smallCount > 0 ? small : 0;
+	let large = (space - (smallCount + mediumCount / 2) * small) / (largeCount + mediumCount / 2);
+	let medium = (large + small) / 2;
+	if (mediumCount > 0 && large !== largeSize) {
+		const targetAdjustment = (largeSize - large) * largeCount;
+		const availableMediumFlex = medium * MEDIUM_ITEM_FLEX_PERCENTAGE * mediumCount;
+		const distribute = Math.min(Math.abs(targetAdjustment), availableMediumFlex);
+		if (targetAdjustment > 0) {
+			medium -= distribute / mediumCount;
+			large += distribute / largeCount;
+		} else {
+			medium += distribute / mediumCount;
+			large -= distribute / largeCount;
+		}
+	}
+	return {
+		priority,
+		smallSize: small,
+		smallCount,
+		mediumSize: medium,
+		mediumCount,
+		largeSize: large,
+		largeCount
+	};
+}
+function findLowestCostArrangement(availableSpace, itemSpacing, targetSmallSize, minSmallSize, maxSmallSize, smallCounts, targetMediumSize, mediumCounts, targetLargeSize, largeCounts) {
+	let lowest = null;
+	let priority = 1;
+	for (const largeCount of largeCounts) for (const mediumCount of mediumCounts) for (const smallCount of smallCounts) {
+		const arrangement = fit(priority, availableSpace, itemSpacing, smallCount, targetSmallSize, minSmallSize, maxSmallSize, mediumCount, targetMediumSize, largeCount, targetLargeSize);
+		if (lowest === null || cost(arrangement, targetLargeSize) < cost(lowest, targetLargeSize)) {
+			lowest = arrangement;
+			if (cost(lowest, targetLargeSize) === 0) return lowest;
+		}
+		priority++;
+	}
+	return lowest;
+}
+const firstIndex = (list, test) => list.findIndex(test);
+const lastIndex = (list, test) => {
+	for (let i = list.length - 1; i >= 0; i--) if (test(list[i])) return i;
+	return -1;
+};
+const firstFocalIndex = (list) => firstIndex(list, (k) => k.isFocal);
+const lastFocalIndex = (list) => lastIndex(list, (k) => k.isFocal);
+const firstNonAnchorIndex = (list) => firstIndex(list, (k) => !k.isAnchor);
+const lastNonAnchorIndex = (list) => lastIndex(list, (k) => !k.isAnchor);
+const pivotIndexOf = (list) => firstIndex(list, (k) => k.isPivot);
+function focalInfo(tmp) {
+	let first = -1;
+	let focalSize = 0;
+	tmp.forEach((k, i) => {
+		if (!k.isAnchor && k.size > focalSize) {
+			first = i;
+			focalSize = k.size;
+		}
+	});
+	let last = first;
+	if (first >= 0) while (last < tmp.length - 1 && tmp[last + 1].size === focalSize) last++;
+	return {
+		first,
+		last,
+		focalSize
+	};
+}
+const isCutoffLeft = (size, offset) => offset - size / 2 < 0 && offset + size / 2 > 0;
+const isCutoffRight = (size, offset, mainAxis) => offset - size / 2 < mainAxis && offset + size / 2 > mainAxis;
+function createKeylinesWithPivot(pivotIndex, pivotOffset, firstFocal, lastFocal, itemMainAxisSize, carouselMainAxisSize, itemSpacing, tmp) {
+	if (tmp.length === 0 || pivotIndex < 0 || pivotIndex >= tmp.length) return [];
+	const pivot = tmp[pivotIndex];
+	const keylines = [];
+	const pivotCutoff = isCutoffLeft(pivot.size, pivotOffset) ? pivotOffset - pivot.size / 2 : isCutoffRight(pivot.size, pivotOffset, carouselMainAxisSize) ? pivotOffset + pivot.size / 2 - carouselMainAxisSize : 0;
+	keylines.push({
+		size: pivot.size,
+		offset: pivotOffset,
+		unadjustedOffset: pivotOffset,
+		isFocal: pivotIndex >= firstFocal && pivotIndex <= lastFocal,
+		isAnchor: pivot.isAnchor,
+		isPivot: true,
+		cutoff: pivotCutoff
+	});
+	let offset = pivotOffset - itemMainAxisSize / 2 - itemSpacing;
+	let unadjusted = pivotOffset - itemMainAxisSize / 2 - itemSpacing;
+	for (let i = pivotIndex - 1; i >= 0; i--) {
+		const k = tmp[i];
+		const kOffset = offset - k.size / 2;
+		const kUnadjusted = unadjusted - itemMainAxisSize / 2;
+		keylines.unshift({
+			size: k.size,
+			offset: kOffset,
+			unadjustedOffset: kUnadjusted,
+			isFocal: i >= firstFocal && i <= lastFocal,
+			isAnchor: k.isAnchor,
+			isPivot: false,
+			cutoff: isCutoffLeft(k.size, kOffset) ? Math.abs(kOffset - k.size / 2) : 0
+		});
+		offset -= k.size + itemSpacing;
+		unadjusted -= itemMainAxisSize + itemSpacing;
+	}
+	offset = pivotOffset + itemMainAxisSize / 2 + itemSpacing;
+	unadjusted = pivotOffset + itemMainAxisSize / 2 + itemSpacing;
+	for (let i = pivotIndex + 1; i < tmp.length; i++) {
+		const k = tmp[i];
+		const kOffset = offset + k.size / 2;
+		const kUnadjusted = unadjusted + itemMainAxisSize / 2;
+		keylines.push({
+			size: k.size,
+			offset: kOffset,
+			unadjustedOffset: kUnadjusted,
+			isFocal: i >= firstFocal && i <= lastFocal,
+			isAnchor: k.isAnchor,
+			isPivot: false,
+			cutoff: isCutoffRight(k.size, kOffset, carouselMainAxisSize) ? kOffset + k.size / 2 - carouselMainAxisSize : 0
+		});
+		offset += k.size + itemSpacing;
+		unadjusted += itemMainAxisSize + itemSpacing;
+	}
+	return keylines;
+}
+function keylineListWithAlignment(carouselMainAxisSize, itemSpacing, alignment, tmp) {
+	const { first, last, focalSize } = focalInfo(tmp);
+	const focalItemCount = last - first;
+	let pivotOffset;
+	if (alignment === "center") {
+		const split = itemSpacing === 0 || focalItemCount % 2 === 0 ? 0 : itemSpacing / 2;
+		const spaceCounts = Math.trunc(focalItemCount / 2) * itemSpacing;
+		pivotOffset = carouselMainAxisSize / 2 - focalSize / 2 * focalItemCount - split - spaceCounts;
+	} else pivotOffset = focalSize / 2;
+	return createKeylinesWithPivot(first, pivotOffset, first, last, focalSize, carouselMainAxisSize, itemSpacing, tmp);
+}
+function keylineListWithPivot(carouselMainAxisSize, itemSpacing, pivotIndex, pivotOffset, tmp) {
+	const { first, last, focalSize } = focalInfo(tmp);
+	return createKeylinesWithPivot(pivotIndex, pivotOffset, first, last, focalSize, carouselMainAxisSize, itemSpacing, tmp);
+}
+function lerpKeyline(a, b, t) {
+	return {
+		size: lerp(a.size, b.size, t),
+		offset: lerp(a.offset, b.offset, t),
+		unadjustedOffset: lerp(a.unadjustedOffset, b.unadjustedOffset, t),
+		isFocal: t < .5 ? a.isFocal : b.isFocal,
+		isAnchor: t < .5 ? a.isAnchor : b.isAnchor,
+		isPivot: t < .5 ? a.isPivot : b.isPivot,
+		cutoff: lerp(a.cutoff, b.cutoff, t)
+	};
+}
+const lerpList = (a, b, t) => a.map((k, i) => lerpKeyline(k, b[i], t));
+function leftAligned(mainAxis, itemSpacing, leftAnchor, rightAnchor, a) {
+	const tmp = [{
+		size: leftAnchor,
+		isAnchor: true
+	}];
+	for (let i = 0; i < a.largeCount; i++) tmp.push({
+		size: a.largeSize,
+		isAnchor: false
+	});
+	for (let i = 0; i < a.mediumCount; i++) tmp.push({
+		size: a.mediumSize,
+		isAnchor: false
+	});
+	for (let i = 0; i < a.smallCount; i++) tmp.push({
+		size: a.smallSize,
+		isAnchor: false
+	});
+	tmp.push({
+		size: rightAnchor,
+		isAnchor: true
+	});
+	return keylineListWithAlignment(mainAxis, itemSpacing, "start", tmp);
+}
+function centerAligned(mainAxis, itemSpacing, leftAnchor, rightAnchor, a) {
+	const tmp = [{
+		size: leftAnchor,
+		isAnchor: true
+	}];
+	const halfSmall = Math.trunc(a.smallCount / 2);
+	const halfMedium = Math.trunc(a.mediumCount / 2);
+	for (let i = 0; i < halfSmall; i++) tmp.push({
+		size: a.smallSize,
+		isAnchor: false
+	});
+	for (let i = 0; i < halfMedium; i++) tmp.push({
+		size: a.mediumSize,
+		isAnchor: false
+	});
+	for (let i = 0; i < a.largeCount; i++) tmp.push({
+		size: a.largeSize,
+		isAnchor: false
+	});
+	for (let i = 0; i < halfMedium; i++) tmp.push({
+		size: a.mediumSize,
+		isAnchor: false
+	});
+	for (let i = 0; i < halfSmall; i++) tmp.push({
+		size: a.smallSize,
+		isAnchor: false
+	});
+	tmp.push({
+		size: rightAnchor,
+		isAnchor: true
+	});
+	return keylineListWithAlignment(mainAxis, itemSpacing, "center", tmp);
+}
+const largeCountsFor = (minCount, maxCount) => Array.from({ length: maxCount - minCount + 1 }, (_, i) => maxCount - i);
+/** Compose's `multiBrowseKeylineList`: large, medium and small items. */
+function multiBrowseKeylineList(carouselMainAxisSize, preferredItemSize, itemSpacing, itemCount, minSmallItemSize = 40, maxSmallItemSize = 56) {
+	if (carouselMainAxisSize === 0 || preferredItemSize === 0) return [];
+	let smallCounts = [1];
+	const mediumCounts = [1, 0];
+	const targetLarge = Math.min(preferredItemSize, carouselMainAxisSize);
+	const targetSmall = Math.min(Math.max(targetLarge / 3, minSmallItemSize), maxSmallItemSize);
+	const targetMedium = (targetLarge + targetSmall) / 2;
+	if (carouselMainAxisSize < minSmallItemSize * 2) smallCounts = [0];
+	const minAvailableLargeSpace = carouselMainAxisSize - targetMedium * Math.max(...mediumCounts) - maxSmallItemSize * Math.max(...smallCounts);
+	const minLargeCount = Math.max(1, Math.floor(minAvailableLargeSpace / targetLarge));
+	const maxLargeCount = Math.ceil(carouselMainAxisSize / targetLarge);
+	const largeCounts = largeCountsFor(minLargeCount, maxLargeCount);
+	let arrangement = findLowestCostArrangement(carouselMainAxisSize, itemSpacing, targetSmall, minSmallItemSize, maxSmallItemSize, smallCounts, targetMedium, mediumCounts, targetLarge, largeCounts);
+	if (arrangement && arrangementCount(arrangement) > itemCount) {
+		let surplus = arrangementCount(arrangement) - itemCount;
+		let smallCount = arrangement.smallCount;
+		let mediumCount = arrangement.mediumCount;
+		while (surplus > 0) {
+			if (smallCount > 0) smallCount -= 1;
+			else if (mediumCount > 1) mediumCount -= 1;
+			surplus -= 1;
+		}
+		arrangement = findLowestCostArrangement(carouselMainAxisSize, itemSpacing, targetSmall, minSmallItemSize, maxSmallItemSize, [smallCount], targetMedium, [mediumCount], targetLarge, largeCounts);
+	}
+	if (!arrangement) return [];
+	return leftAligned(carouselMainAxisSize, itemSpacing, ANCHOR_SIZE, ANCHOR_SIZE, arrangement);
+}
+/** Compose's `heroKeylineList`: one (or more) large items with small ones beside them. */
+function heroKeylineList(carouselMainAxisSize, preferredItemSize, itemSpacing, itemCount, isCentered, minSmallItemSize = 40, maxSmallItemSize = 56) {
+	if (carouselMainAxisSize === 0) return [];
+	const shouldCenter = isCentered && itemCount >= 3;
+	let smallCounts = itemCount <= 1 ? [0] : shouldCenter ? [2] : [1];
+	const targetLarge = Math.min(preferredItemSize ?? carouselMainAxisSize, carouselMainAxisSize);
+	const targetSmall = Math.min(Math.max(targetLarge / 3, minSmallItemSize), maxSmallItemSize);
+	if (carouselMainAxisSize < minSmallItemSize * Math.max(...smallCounts) + minSmallItemSize * 1.25) smallCounts = [0];
+	const minAvailableLargeSpace = carouselMainAxisSize - minSmallItemSize * Math.max(...smallCounts);
+	const minLargeCount = Math.max(1, Math.floor(minAvailableLargeSpace / targetLarge));
+	const maxLargeCount = Math.ceil(carouselMainAxisSize / targetLarge);
+	const arrangement = findLowestCostArrangement(carouselMainAxisSize, itemSpacing, targetSmall, minSmallItemSize, maxSmallItemSize, smallCounts, 0, [0], targetLarge, largeCountsFor(minLargeCount, maxLargeCount));
+	if (!arrangement) return [];
+	return shouldCenter && itemCount >= arrangementCount(arrangement) ? centerAligned(carouselMainAxisSize, itemSpacing, ANCHOR_SIZE, ANCHOR_SIZE, arrangement) : leftAligned(carouselMainAxisSize, itemSpacing, ANCHOR_SIZE, ANCHOR_SIZE, arrangement);
+}
+function moveKeyline(from, srcIndex, dstIndex, mainAxis, itemSpacing) {
+	const pivotDir = srcIndex > dstIndex ? 1 : -1;
+	const src = from[srcIndex];
+	const pivotDelta = (src.size - src.cutoff + itemSpacing) * pivotDir;
+	const pivotIndex = pivotIndexOf(from);
+	const newPivotIndex = pivotIndex + pivotDir;
+	const newPivotOffset = from[pivotIndex].offset + pivotDelta;
+	const moved = [...from];
+	moved.splice(srcIndex, 1);
+	moved.splice(dstIndex, 0, src);
+	return keylineListWithPivot(mainAxis, itemSpacing, newPivotIndex, newPivotOffset, moved.map((k) => ({
+		size: k.size,
+		isAnchor: k.isAnchor
+	})));
+}
+function firstIndexAfterFocalRangeWithSize(list, size) {
+	for (let i = lastFocalIndex(list); i < list.length; i++) if (list[i].size === size) return i;
+	return list.length - 1;
+}
+function lastIndexBeforeFocalRangeWithSize(list, size) {
+	for (let i = firstFocalIndex(list) - 1; i >= 0; i--) if (list[i].size === size) return i;
+	return 0;
+}
+function isFirstFocalAtStart(list) {
+	const focal = list[firstFocalIndex(list)];
+	return focal.offset - focal.size / 2 >= 0 && firstFocalIndex(list) === firstNonAnchorIndex(list);
+}
+function isLastFocalAtEnd(list, mainAxis) {
+	const focal = list[lastFocalIndex(list)];
+	return focal.offset + focal.size / 2 <= mainAxis && lastFocalIndex(list) === lastNonAnchorIndex(list);
+}
+/**
+* Compose's `createShiftedKeylineListForContentPadding`: `from` shifted by `padding` (negative
+* for the end), the items giving up the padding between them. The unadjusted offsets stay
+* those of `from`, since items keep their natural slots.
+*
+* Unlike Compose, which takes an equal share from every item, only the large and medium
+* items give it up: small items (at most `smallMax`) keep their size, so they never drop
+* below the spec's 40dp minimum at the start or end. The total is the same, so the anchors,
+* snap positions and scroll range don't change.
+*/
+function shiftedForPadding(from, mainAxis, itemSpacing, padding, pivotIndex, smallMax) {
+	const nonAnchors = from.filter((k) => !k.isAnchor);
+	const large = nonAnchors.filter((k) => k.size > smallMax);
+	const shrinks = (k) => !k.isAnchor && (large.length === 0 || k.size > smallMax);
+	const reduction = padding / (large.length || nonAnchors.length);
+	const pivotReduction = shrinks(from[pivotIndex]) ? reduction : 0;
+	return keylineListWithPivot(mainAxis, itemSpacing, pivotIndex, from[pivotIndex].offset - pivotReduction / 2 + padding, from.map((k) => ({
+		size: shrinks(k) ? k.size - Math.abs(reduction) : k.size,
+		isAnchor: k.isAnchor
+	}))).map((k, i) => ({
+		...k,
+		unadjustedOffset: from[i].unadjustedOffset
+	}));
+}
+function startSteps(defaults, mainAxis, itemSpacing, padding, smallMax) {
+	if (defaults.length === 0) return [];
+	const steps = [defaults];
+	if (isFirstFocalAtStart(defaults)) {
+		if (padding !== 0) steps.push(shiftedForPadding(defaults, mainAxis, itemSpacing, padding, firstFocalIndex(defaults), smallMax));
+		return steps;
+	}
+	const startIndex = firstNonAnchorIndex(defaults);
+	const count = firstFocalIndex(defaults) - startIndex;
+	if (count <= 0 && defaults[firstFocalIndex(defaults)].cutoff > 0) {
+		steps.push(moveKeyline(defaults, 0, 0, mainAxis, itemSpacing));
+		return steps;
+	}
+	for (let i = 0; i < count; i++) {
+		const prev = steps[steps.length - 1];
+		const original = startIndex + i;
+		let dstIndex = defaults.length - 1;
+		if (original > 0) dstIndex = firstIndexAfterFocalRangeWithSize(prev, defaults[original - 1].size) - 1;
+		steps.push(moveKeyline(prev, firstNonAnchorIndex(defaults), dstIndex, mainAxis, itemSpacing));
+	}
+	if (padding !== 0) {
+		const last = steps[steps.length - 1];
+		steps[steps.length - 1] = shiftedForPadding(last, mainAxis, itemSpacing, padding, firstFocalIndex(last), smallMax);
+	}
+	return steps;
+}
+function endSteps(defaults, mainAxis, itemSpacing, padding, smallMax) {
+	if (defaults.length === 0) return [];
+	const steps = [defaults];
+	if (isLastFocalAtEnd(defaults, mainAxis)) {
+		if (padding !== 0) steps.push(shiftedForPadding(defaults, mainAxis, itemSpacing, -padding, lastFocalIndex(defaults), smallMax));
+		return steps;
+	}
+	const startIndex = lastFocalIndex(defaults);
+	const endIndex = lastNonAnchorIndex(defaults);
+	const count = endIndex - startIndex;
+	if (count <= 0 && defaults[lastFocalIndex(defaults)].cutoff > 0) {
+		steps.push(moveKeyline(defaults, 0, 0, mainAxis, itemSpacing));
+		return steps;
+	}
+	for (let i = 0; i < count; i++) {
+		const prev = steps[steps.length - 1];
+		const original = endIndex - i;
+		let dstIndex = 0;
+		if (original < defaults.length - 1) dstIndex = lastIndexBeforeFocalRangeWithSize(prev, defaults[original + 1].size) + 1;
+		steps.push(moveKeyline(prev, lastNonAnchorIndex(defaults), dstIndex, mainAxis, itemSpacing));
+	}
+	if (padding !== 0) {
+		const last = steps[steps.length - 1];
+		steps[steps.length - 1] = shiftedForPadding(last, mainAxis, itemSpacing, -padding, lastFocalIndex(last), smallMax);
+	}
+	return steps;
+}
+function interpolationPoints(total, steps, shiftingLeft) {
+	const points = [0];
+	if (total === 0 || steps.length === 0) return points;
+	for (let i = 1; i < steps.length; i++) {
+		const prev = steps[i - 1];
+		const curr = steps[i];
+		const shifted = shiftingLeft ? curr[0].unadjustedOffset - prev[0].unadjustedOffset : prev[prev.length - 1].unadjustedOffset - curr[curr.length - 1].unadjustedOffset;
+		points.push(i === steps.length - 1 ? 1 : points[i - 1] + shifted / total);
+	}
+	return points;
+}
+const clampLerp = (outMin, outMax, inMin, inMax, v) => v <= inMin ? outMin : v >= inMax ? outMax : lerp(outMin, outMax, (v - inMin) / (inMax - inMin));
+/**
+* Compose's `Strategy`. The content padding before the first item and after the last one is
+* handled by the keylines (the last start and end steps are shifted by it), not by the
+* scroller, so items bleed over it while scrolling, as Compose's do. Small items, up to
+* `maxSmallItemSize`, keep their size in those steps (see `shiftedForPadding`).
+*/
+function createStrategy(defaults, availableSpace, itemSpacing, beforeContentPadding = 0, afterContentPadding = 0, maxSmallItemSize = 56) {
+	const start = startSteps(defaults, availableSpace, itemSpacing, beforeContentPadding, maxSmallItemSize);
+	const end = endSteps(defaults, availableSpace, itemSpacing, afterContentPadding, maxSmallItemSize);
+	const startShiftDistance = start.length === 0 ? 0 : Math.max(start[start.length - 1][0].unadjustedOffset - start[0][0].unadjustedOffset, beforeContentPadding);
+	const endShiftDistance = end.length === 0 ? 0 : Math.max(end[0][end[0].length - 1].unadjustedOffset - end[end.length - 1][end[end.length - 1].length - 1].unadjustedOffset, afterContentPadding);
+	const itemMainAxisSize = defaults[firstFocalIndex(defaults)]?.size ?? 0;
+	return {
+		defaults,
+		startSteps: start,
+		endSteps: end,
+		availableSpace,
+		itemSpacing,
+		itemMainAxisSize,
+		startShiftDistance,
+		endShiftDistance,
+		startShiftPoints: interpolationPoints(startShiftDistance, start, true),
+		endShiftPoints: interpolationPoints(endShiftDistance, end, false),
+		isValid: defaults.length > 0 && availableSpace !== 0 && itemMainAxisSize !== 0
+	};
+}
+/** Compose's `getKeylineListForScrollOffset`. */
+function keylinesForScrollOffset(strategy, scrollOffset, maxScrollOffset) {
+	const offset = Math.max(0, scrollOffset);
+	const startShift = strategy.startShiftDistance;
+	const endShift = Math.max(0, maxScrollOffset - strategy.endShiftDistance);
+	if (offset >= startShift && offset <= endShift) return strategy.defaults;
+	let interpolation = clampLerp(1, 0, 0, startShift, offset);
+	let points = strategy.startShiftPoints;
+	let steps = strategy.startSteps;
+	if (offset > endShift) {
+		interpolation = clampLerp(0, 1, endShift, maxScrollOffset, offset);
+		points = strategy.endShiftPoints;
+		steps = strategy.endSteps;
+		if (endShift < .01 && strategy.startSteps.length === 2 && strategy.endSteps.length === 2) steps = [strategy.startSteps[1], strategy.endSteps[1]];
+	}
+	let from = 0;
+	let to = 0;
+	let stepped = 0;
+	let lower = points[0];
+	for (let i = 1; i < steps.length; i++) {
+		const upper = points[i];
+		if (interpolation <= upper) {
+			from = i - 1;
+			to = i;
+			stepped = clampLerp(0, 1, lower, upper, interpolation);
+			break;
+		}
+		lower = upper;
+	}
+	return lerpList(steps[from], steps[to], stepped);
+}
+/** Compose's `calculateMaxScrollOffset`. */
+function maxScrollOffset(strategy, itemCount) {
+	const total = strategy.itemMainAxisSize * itemCount + strategy.itemSpacing * (itemCount - 1);
+	return Math.max(0, total - strategy.availableSpace);
+}
+/** Compose's `getSnapPositionOffset`: where item `index` sits when snapped. */
+function snapPositionOffset(strategy, index, itemCount) {
+	if (!strategy.isValid) return 0;
+	const half = strategy.itemMainAxisSize / 2;
+	let offset = Math.round(strategy.defaults[firstFocalIndex(strategy.defaults)].unadjustedOffset - half);
+	const startLast = strategy.startSteps.length - 1;
+	if (index <= startLast) {
+		const step = strategy.startSteps[Math.min(Math.max(startLast - index, 0), startLast)];
+		offset = Math.round(step[firstFocalIndex(step)].unadjustedOffset - half);
+	}
+	const lastItem = itemCount - 1;
+	const endLast = strategy.endSteps.length - 1;
+	const focalCount = lastFocalIndex(strategy.defaults) - firstFocalIndex(strategy.defaults) + 1;
+	if (index >= lastItem - endLast && itemCount > focalCount) {
+		const step = strategy.endSteps[Math.min(Math.max(endLast - (lastItem - index), 0), endLast)];
+		offset = Math.round(step[lastFocalIndex(step)].unadjustedOffset - half);
+	}
+	return offset;
+}
+/** Compose's `carouselItem` placement for item `index` at `scrollOffset`. */
+function placeItem(strategy, keylines, index, scrollOffset) {
+	const center = index * (strategy.itemMainAxisSize + strategy.itemSpacing) + strategy.itemMainAxisSize / 2 - scrollOffset;
+	let before = keylines[0];
+	for (let i = keylines.length - 1; i >= 0; i--) if (keylines[i].unadjustedOffset < center) {
+		before = keylines[i];
+		break;
+	}
+	const after = keylines.find((k) => k.unadjustedOffset >= center) ?? keylines[keylines.length - 1];
+	const outOfBounds = before === after;
+	const progress = outOfBounds ? 1 : (center - before.unadjustedOffset) / (after.unadjustedOffset - before.unadjustedOffset);
+	const keyline = lerpKeyline(before, after, progress);
+	let translation = keyline.offset - center;
+	if (outOfBounds) translation += (center - keyline.unadjustedOffset) / keyline.size;
+	return {
+		size: keyline.size,
+		translation
+	};
+}
+//#endregion
+export { createStrategy, firstFocalIndex, heroKeylineList, keylinesForScrollOffset, lastFocalIndex, maxScrollOffset, multiBrowseKeylineList, placeItem, snapPositionOffset };
+
+//# sourceMappingURL=carousel-keylines.js.map

package/dist/components/carousel/carousel-keylines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"carousel-keylines.js","names":[],"sources":["../../../src/components/carousel/carousel-keylines.ts"],"sourcesContent":["/*\n * A port of Compose Material 3's carousel keylines (androidx `compose/material3/carousel`:\n * Arrangement.kt, Keylines.kt, KeylineList.kt, Strategy.kt, KeylineSnapPosition.kt and the\n * placement in Carousel.kt's `carouselItem`). Pure functions on px values, unit-tested.\n */\n\nexport const MIN_SMALL_ITEM_SIZE = 40;\nexport const MAX_SMALL_ITEM_SIZE = 56;\nconst ANCHOR_SIZE = 10;\nconst MEDIUM_ITEM_FLEX_PERCENTAGE = 0.1;\n\nconst lerp = (a: number, b: number, t: number) => a + (b - a) * t;\n\n// ---------------------------------------------------------------------------\n// Arrangement.kt\n\ninterface Arrangement {\n  priority: number;\n  smallSize: number;\n  smallCount: number;\n  mediumSize: number;\n  mediumCount: number;\n  largeSize: number;\n  largeCount: number;\n}\n\nfunction isValidArrangement(a: Arrangement) {\n  if (a.largeCount > 0 && a.smallCount > 0 && a.mediumCount > 0)\n    return a.largeSize > a.mediumSize && a.mediumSize > a.smallSize;\n  if (a.largeCount > 0 && a.smallCount > 0) return a.largeSize > a.smallSize;\n  return true;\n}\n\nconst cost = (a: Arrangement, targetLargeSize: number) =>\n  isValidArrangement(a) ? Math.abs(targetLargeSize - a.largeSize) * a.priority : Number.MAX_VALUE;\n\nconst arrangementCount = (a: Arrangement) => a.largeCount + a.mediumCount + a.smallCount;\n\nfunction fit(\n  priority: number,\n  availableSpace: number,\n  itemSpacing: number,\n  smallCount: number,\n  smallSize: number,\n  minSmallSize: number,\n  maxSmallSize: number,\n  mediumCount: number,\n  mediumSize: number,\n  largeCount: number,\n  largeSize: number,\n): Arrangement {\n  const total = largeCount + mediumCount + smallCount;\n  const space = availableSpace - (total - 1) * itemSpacing;\n  let small = Math.min(Math.max(smallSize, minSmallSize), maxSmallSize);\n  const taken = largeSize * largeCount + mediumSize * mediumCount + small * smallCount;\n  const delta = space - taken;\n  if (smallCount > 0 && delta > 0) small += Math.min(delta / smallCount, maxSmallSize - small);\n  else if (smallCount > 0 && delta < 0) small += Math.max(delta / smallCount, minSmallSize - small);\n  small = smallCount > 0 ? small : 0;\n  let large = (space - (smallCount + mediumCount / 2) * small) / (largeCount + mediumCount / 2);\n  let medium = (large + small) / 2;\n  if (mediumCount > 0 && large !== largeSize) {\n    const targetAdjustment = (largeSize - large) * largeCount;\n    const availableMediumFlex = medium * MEDIUM_ITEM_FLEX_PERCENTAGE * mediumCount;\n    const distribute = Math.min(Math.abs(targetAdjustment), availableMediumFlex);\n    if (targetAdjustment > 0) {\n      medium -= distribute / mediumCount;\n      large += distribute / largeCount;\n    } else {\n      medium += distribute / mediumCount;\n      large -= distribute / largeCount;\n    }\n  }\n  return {\n    priority,\n    smallSize: small,\n    smallCount,\n    mediumSize: medium,\n    mediumCount,\n    largeSize: large,\n    largeCount,\n  };\n}\n\nfunction findLowestCostArrangement(\n  availableSpace: number,\n  itemSpacing: number,\n  targetSmallSize: number,\n  minSmallSize: number,\n  maxSmallSize: number,\n  smallCounts: number[],\n  targetMediumSize: number,\n  mediumCounts: number[],\n  targetLargeSize: number,\n  largeCounts: number[],\n): Arrangement | null {\n  let lowest: Arrangement | null = null;\n  let priority = 1;\n  for (const largeCount of largeCounts)\n    for (const mediumCount of mediumCounts)\n      for (const smallCount of smallCounts) {\n        const arrangement = fit(\n          priority,\n          availableSpace,\n          itemSpacing,\n          smallCount,\n          targetSmallSize,\n          minSmallSize,\n          maxSmallSize,\n          mediumCount,\n          targetMediumSize,\n          largeCount,\n          targetLargeSize,\n        );\n        if (lowest === null || cost(arrangement, targetLargeSize) < cost(lowest, targetLargeSize)) {\n          lowest = arrangement;\n          if (cost(lowest, targetLargeSize) === 0) return lowest;\n        }\n        priority++;\n      }\n  return lowest;\n}\n\n// ---------------------------------------------------------------------------\n// KeylineList.kt\n\nexport interface Keyline {\n  size: number;\n  offset: number;\n  unadjustedOffset: number;\n  isFocal: boolean;\n  isAnchor: boolean;\n  isPivot: boolean;\n  cutoff: number;\n}\n\nexport type KeylineList = Keyline[];\n\ninterface TmpKeyline {\n  size: number;\n  isAnchor: boolean;\n}\n\nconst firstIndex = (list: KeylineList, test: (k: Keyline) => boolean) => list.findIndex(test);\nconst lastIndex = (list: KeylineList, test: (k: Keyline) => boolean) => {\n  for (let i = list.length - 1; i >= 0; i--) if (test(list[i]!)) return i;\n  return -1;\n};\n\nexport const firstFocalIndex = (list: KeylineList) => firstIndex(list, (k) => k.isFocal);\nexport const lastFocalIndex = (list: KeylineList) => lastIndex(list, (k) => k.isFocal);\nconst firstNonAnchorIndex = (list: KeylineList) => firstIndex(list, (k) => !k.isAnchor);\nconst lastNonAnchorIndex = (list: KeylineList) => lastIndex(list, (k) => !k.isAnchor);\nconst pivotIndexOf = (list: KeylineList) => firstIndex(list, (k) => k.isPivot);\n\nfunction focalInfo(tmp: TmpKeyline[]) {\n  let first = -1;\n  let focalSize = 0;\n  tmp.forEach((k, i) => {\n    if (!k.isAnchor && k.size > focalSize) {\n      first = i;\n      focalSize = k.size;\n    }\n  });\n  let last = first;\n  if (first >= 0) while (last < tmp.length - 1 && tmp[last + 1]!.size === focalSize) last++;\n  return { first, last, focalSize };\n}\n\nconst isCutoffLeft = (size: number, offset: number) =>\n  offset - size / 2 < 0 && offset + size / 2 > 0;\nconst isCutoffRight = (size: number, offset: number, mainAxis: number) =>\n  offset - size / 2 < mainAxis && offset + size / 2 > mainAxis;\n\nfunction createKeylinesWithPivot(\n  pivotIndex: number,\n  pivotOffset: number,\n  firstFocal: number,\n  lastFocal: number,\n  itemMainAxisSize: number,\n  carouselMainAxisSize: number,\n  itemSpacing: number,\n  tmp: TmpKeyline[],\n): KeylineList {\n  if (tmp.length === 0 || pivotIndex < 0 || pivotIndex >= tmp.length) return [];\n  const pivot = tmp[pivotIndex]!;\n  const keylines: Keyline[] = [];\n  const pivotCutoff = isCutoffLeft(pivot.size, pivotOffset)\n    ? pivotOffset - pivot.size / 2\n    : isCutoffRight(pivot.size, pivotOffset, carouselMainAxisSize)\n      ? pivotOffset + pivot.size / 2 - carouselMainAxisSize\n      : 0;\n  keylines.push({\n    size: pivot.size,\n    offset: pivotOffset,\n    unadjustedOffset: pivotOffset,\n    isFocal: pivotIndex >= firstFocal && pivotIndex <= lastFocal,\n    isAnchor: pivot.isAnchor,\n    isPivot: true,\n    cutoff: pivotCutoff,\n  });\n  let offset = pivotOffset - itemMainAxisSize / 2 - itemSpacing;\n  let unadjusted = pivotOffset - itemMainAxisSize / 2 - itemSpacing;\n  for (let i = pivotIndex - 1; i >= 0; i--) {\n    const k = tmp[i]!;\n    const kOffset = offset - k.size / 2;\n    const kUnadjusted = unadjusted - itemMainAxisSize / 2;\n    keylines.unshift({\n      size: k.size,\n      offset: kOffset,\n      unadjustedOffset: kUnadjusted,\n      isFocal: i >= firstFocal && i <= lastFocal,\n      isAnchor: k.isAnchor,\n      isPivot: false,\n      cutoff: isCutoffLeft(k.size, kOffset) ? Math.abs(kOffset - k.size / 2) : 0,\n    });\n    offset -= k.size + itemSpacing;\n    unadjusted -= itemMainAxisSize + itemSpacing;\n  }\n  offset = pivotOffset + itemMainAxisSize / 2 + itemSpacing;\n  unadjusted = pivotOffset + itemMainAxisSize / 2 + itemSpacing;\n  for (let i = pivotIndex + 1; i < tmp.length; i++) {\n    const k = tmp[i]!;\n    const kOffset = offset + k.size / 2;\n    const kUnadjusted = unadjusted + itemMainAxisSize / 2;\n    keylines.push({\n      size: k.size,\n      offset: kOffset,\n      unadjustedOffset: kUnadjusted,\n      isFocal: i >= firstFocal && i <= lastFocal,\n      isAnchor: k.isAnchor,\n      isPivot: false,\n      cutoff: isCutoffRight(k.size, kOffset, carouselMainAxisSize)\n        ? kOffset + k.size / 2 - carouselMainAxisSize\n        : 0,\n    });\n    offset += k.size + itemSpacing;\n    unadjusted += itemMainAxisSize + itemSpacing;\n  }\n  return keylines;\n}\n\nfunction keylineListWithAlignment(\n  carouselMainAxisSize: number,\n  itemSpacing: number,\n  alignment: 'start' | 'center',\n  tmp: TmpKeyline[],\n): KeylineList {\n  const { first, last, focalSize } = focalInfo(tmp);\n  const focalItemCount = last - first;\n  let pivotOffset: number;\n  if (alignment === 'center') {\n    const split = itemSpacing === 0 || focalItemCount % 2 === 0 ? 0 : itemSpacing / 2;\n    const spaceCounts = Math.trunc(focalItemCount / 2) * itemSpacing;\n    pivotOffset = carouselMainAxisSize / 2 - (focalSize / 2) * focalItemCount - split - spaceCounts;\n  } else {\n    pivotOffset = focalSize / 2;\n  }\n  return createKeylinesWithPivot(\n    first,\n    pivotOffset,\n    first,\n    last,\n    focalSize,\n    carouselMainAxisSize,\n    itemSpacing,\n    tmp,\n  );\n}\n\nfunction keylineListWithPivot(\n  carouselMainAxisSize: number,\n  itemSpacing: number,\n  pivotIndex: number,\n  pivotOffset: number,\n  tmp: TmpKeyline[],\n): KeylineList {\n  const { first, last, focalSize } = focalInfo(tmp);\n  return createKeylinesWithPivot(\n    pivotIndex,\n    pivotOffset,\n    first,\n    last,\n    focalSize,\n    carouselMainAxisSize,\n    itemSpacing,\n    tmp,\n  );\n}\n\nfunction lerpKeyline(a: Keyline, b: Keyline, t: number): Keyline {\n  return {\n    size: lerp(a.size, b.size, t),\n    offset: lerp(a.offset, b.offset, t),\n    unadjustedOffset: lerp(a.unadjustedOffset, b.unadjustedOffset, t),\n    isFocal: t < 0.5 ? a.isFocal : b.isFocal,\n    isAnchor: t < 0.5 ? a.isAnchor : b.isAnchor,\n    isPivot: t < 0.5 ? a.isPivot : b.isPivot,\n    cutoff: lerp(a.cutoff, b.cutoff, t),\n  };\n}\n\nconst lerpList = (a: KeylineList, b: KeylineList, t: number) =>\n  a.map((k, i) => lerpKeyline(k, b[i]!, t));\n\n// ---------------------------------------------------------------------------\n// Keylines.kt\n\nfunction leftAligned(\n  mainAxis: number,\n  itemSpacing: number,\n  leftAnchor: number,\n  rightAnchor: number,\n  a: Arrangement,\n): KeylineList {\n  const tmp: TmpKeyline[] = [{ size: leftAnchor, isAnchor: true }];\n  for (let i = 0; i < a.largeCount; i++) tmp.push({ size: a.largeSize, isAnchor: false });\n  for (let i = 0; i < a.mediumCount; i++) tmp.push({ size: a.mediumSize, isAnchor: false });\n  for (let i = 0; i < a.smallCount; i++) tmp.push({ size: a.smallSize, isAnchor: false });\n  tmp.push({ size: rightAnchor, isAnchor: true });\n  return keylineListWithAlignment(mainAxis, itemSpacing, 'start', tmp);\n}\n\nfunction centerAligned(\n  mainAxis: number,\n  itemSpacing: number,\n  leftAnchor: number,\n  rightAnchor: number,\n  a: Arrangement,\n): KeylineList {\n  const tmp: TmpKeyline[] = [{ size: leftAnchor, isAnchor: true }];\n  const halfSmall = Math.trunc(a.smallCount / 2);\n  const halfMedium = Math.trunc(a.mediumCount / 2);\n  for (let i = 0; i < halfSmall; i++) tmp.push({ size: a.smallSize, isAnchor: false });\n  for (let i = 0; i < halfMedium; i++) tmp.push({ size: a.mediumSize, isAnchor: false });\n  for (let i = 0; i < a.largeCount; i++) tmp.push({ size: a.largeSize, isAnchor: false });\n  for (let i = 0; i < halfMedium; i++) tmp.push({ size: a.mediumSize, isAnchor: false });\n  for (let i = 0; i < halfSmall; i++) tmp.push({ size: a.smallSize, isAnchor: false });\n  tmp.push({ size: rightAnchor, isAnchor: true });\n  return keylineListWithAlignment(mainAxis, itemSpacing, 'center', tmp);\n}\n\nconst largeCountsFor = (minCount: number, maxCount: number) =>\n  Array.from({ length: maxCount - minCount + 1 }, (_, i) => maxCount - i);\n\n/** Compose's `multiBrowseKeylineList`: large, medium and small items. */\nexport function multiBrowseKeylineList(\n  carouselMainAxisSize: number,\n  preferredItemSize: number,\n  itemSpacing: number,\n  itemCount: number,\n  minSmallItemSize = MIN_SMALL_ITEM_SIZE,\n  maxSmallItemSize = MAX_SMALL_ITEM_SIZE,\n): KeylineList {\n  if (carouselMainAxisSize === 0 || preferredItemSize === 0) return [];\n  let smallCounts = [1];\n  const mediumCounts = [1, 0];\n  const targetLarge = Math.min(preferredItemSize, carouselMainAxisSize);\n  const targetSmall = Math.min(Math.max(targetLarge / 3, minSmallItemSize), maxSmallItemSize);\n  const targetMedium = (targetLarge + targetSmall) / 2;\n  if (carouselMainAxisSize < minSmallItemSize * 2) smallCounts = [0];\n  const minAvailableLargeSpace =\n    carouselMainAxisSize -\n    targetMedium * Math.max(...mediumCounts) -\n    maxSmallItemSize * Math.max(...smallCounts);\n  const minLargeCount = Math.max(1, Math.floor(minAvailableLargeSpace / targetLarge));\n  const maxLargeCount = Math.ceil(carouselMainAxisSize / targetLarge);\n  const largeCounts = largeCountsFor(minLargeCount, maxLargeCount);\n  let arrangement = findLowestCostArrangement(\n    carouselMainAxisSize,\n    itemSpacing,\n    targetSmall,\n    minSmallItemSize,\n    maxSmallItemSize,\n    smallCounts,\n    targetMedium,\n    mediumCounts,\n    targetLarge,\n    largeCounts,\n  );\n  if (arrangement && arrangementCount(arrangement) > itemCount) {\n    let surplus = arrangementCount(arrangement) - itemCount;\n    let smallCount = arrangement.smallCount;\n    let mediumCount = arrangement.mediumCount;\n    while (surplus > 0) {\n      if (smallCount > 0) smallCount -= 1;\n      else if (mediumCount > 1) mediumCount -= 1;\n      surplus -= 1;\n    }\n    arrangement = findLowestCostArrangement(\n      carouselMainAxisSize,\n      itemSpacing,\n      targetSmall,\n      minSmallItemSize,\n      maxSmallItemSize,\n      [smallCount],\n      targetMedium,\n      [mediumCount],\n      targetLarge,\n      largeCounts,\n    );\n  }\n  if (!arrangement) return [];\n  return leftAligned(carouselMainAxisSize, itemSpacing, ANCHOR_SIZE, ANCHOR_SIZE, arrangement);\n}\n\n/** Compose's `heroKeylineList`: one (or more) large items with small ones beside them. */\nexport function heroKeylineList(\n  carouselMainAxisSize: number,\n  preferredItemSize: number | undefined,\n  itemSpacing: number,\n  itemCount: number,\n  isCentered: boolean,\n  minSmallItemSize = MIN_SMALL_ITEM_SIZE,\n  maxSmallItemSize = MAX_SMALL_ITEM_SIZE,\n): KeylineList {\n  if (carouselMainAxisSize === 0) return [];\n  const shouldCenter = isCentered && itemCount >= 3;\n  let smallCounts = itemCount <= 1 ? [0] : shouldCenter ? [2] : [1];\n  const targetLarge = Math.min(preferredItemSize ?? carouselMainAxisSize, carouselMainAxisSize);\n  const targetSmall = Math.min(Math.max(targetLarge / 3, minSmallItemSize), maxSmallItemSize);\n  const fullscreenThreshold = minSmallItemSize * Math.max(...smallCounts) + minSmallItemSize * 1.25;\n  if (carouselMainAxisSize < fullscreenThreshold) smallCounts = [0];\n  const minAvailableLargeSpace = carouselMainAxisSize - minSmallItemSize * Math.max(...smallCounts);\n  const minLargeCount = Math.max(1, Math.floor(minAvailableLargeSpace / targetLarge));\n  const maxLargeCount = Math.ceil(carouselMainAxisSize / targetLarge);\n  const arrangement = findLowestCostArrangement(\n    carouselMainAxisSize,\n    itemSpacing,\n    targetSmall,\n    minSmallItemSize,\n    maxSmallItemSize,\n    smallCounts,\n    0,\n    [0],\n    targetLarge,\n    largeCountsFor(minLargeCount, maxLargeCount),\n  );\n  if (!arrangement) return [];\n  return shouldCenter && itemCount >= arrangementCount(arrangement)\n    ? centerAligned(carouselMainAxisSize, itemSpacing, ANCHOR_SIZE, ANCHOR_SIZE, arrangement)\n    : leftAligned(carouselMainAxisSize, itemSpacing, ANCHOR_SIZE, ANCHOR_SIZE, arrangement);\n}\n\n// ---------------------------------------------------------------------------\n// Strategy.kt\n\nfunction moveKeyline(\n  from: KeylineList,\n  srcIndex: number,\n  dstIndex: number,\n  mainAxis: number,\n  itemSpacing: number,\n): KeylineList {\n  const pivotDir = srcIndex > dstIndex ? 1 : -1;\n  const src = from[srcIndex]!;\n  const pivotDelta = (src.size - src.cutoff + itemSpacing) * pivotDir;\n  const pivotIndex = pivotIndexOf(from);\n  const newPivotIndex = pivotIndex + pivotDir;\n  const newPivotOffset = from[pivotIndex]!.offset + pivotDelta;\n  const moved = [...from];\n  moved.splice(srcIndex, 1);\n  moved.splice(dstIndex, 0, src);\n  return keylineListWithPivot(\n    mainAxis,\n    itemSpacing,\n    newPivotIndex,\n    newPivotOffset,\n    moved.map((k) => ({ size: k.size, isAnchor: k.isAnchor })),\n  );\n}\n\nfunction firstIndexAfterFocalRangeWithSize(list: KeylineList, size: number) {\n  for (let i = lastFocalIndex(list); i < list.length; i++) if (list[i]!.size === size) return i;\n  return list.length - 1;\n}\n\nfunction lastIndexBeforeFocalRangeWithSize(list: KeylineList, size: number) {\n  for (let i = firstFocalIndex(list) - 1; i >= 0; i--) if (list[i]!.size === size) return i;\n  return 0;\n}\n\nfunction isFirstFocalAtStart(list: KeylineList) {\n  const focal = list[firstFocalIndex(list)]!;\n  return focal.offset - focal.size / 2 >= 0 && firstFocalIndex(list) === firstNonAnchorIndex(list);\n}\n\nfunction isLastFocalAtEnd(list: KeylineList, mainAxis: number) {\n  const focal = list[lastFocalIndex(list)]!;\n  return (\n    focal.offset + focal.size / 2 <= mainAxis && lastFocalIndex(list) === lastNonAnchorIndex(list)\n  );\n}\n\n/**\n * Compose's `createShiftedKeylineListForContentPadding`: `from` shifted by `padding` (negative\n * for the end), the items giving up the padding between them. The unadjusted offsets stay\n * those of `from`, since items keep their natural slots.\n *\n * Unlike Compose, which takes an equal share from every item, only the large and medium\n * items give it up: small items (at most `smallMax`) keep their size, so they never drop\n * below the spec's 40dp minimum at the start or end. The total is the same, so the anchors,\n * snap positions and scroll range don't change.\n */\nfunction shiftedForPadding(\n  from: KeylineList,\n  mainAxis: number,\n  itemSpacing: number,\n  padding: number,\n  pivotIndex: number,\n  smallMax: number,\n): KeylineList {\n  const nonAnchors = from.filter((k) => !k.isAnchor);\n  const large = nonAnchors.filter((k) => k.size > smallMax);\n  // Every item small (a degenerate fit): share it as Compose does.\n  const shrinks = (k: Keyline) => !k.isAnchor && (large.length === 0 || k.size > smallMax);\n  const reduction = padding / (large.length || nonAnchors.length);\n  const pivotReduction = shrinks(from[pivotIndex]!) ? reduction : 0;\n  const shifted = keylineListWithPivot(\n    mainAxis,\n    itemSpacing,\n    pivotIndex,\n    from[pivotIndex]!.offset - pivotReduction / 2 + padding,\n    from.map((k) => ({\n      size: shrinks(k) ? k.size - Math.abs(reduction) : k.size,\n      isAnchor: k.isAnchor,\n    })),\n  );\n  return shifted.map((k, i) => ({ ...k, unadjustedOffset: from[i]!.unadjustedOffset }));\n}\n\nfunction startSteps(\n  defaults: KeylineList,\n  mainAxis: number,\n  itemSpacing: number,\n  padding: number,\n  smallMax: number,\n): KeylineList[] {\n  if (defaults.length === 0) return [];\n  const steps = [defaults];\n  if (isFirstFocalAtStart(defaults)) {\n    if (padding !== 0)\n      steps.push(\n        shiftedForPadding(\n          defaults,\n          mainAxis,\n          itemSpacing,\n          padding,\n          firstFocalIndex(defaults),\n          smallMax,\n        ),\n      );\n    return steps;\n  }\n  const startIndex = firstNonAnchorIndex(defaults);\n  const endIndex = firstFocalIndex(defaults);\n  const count = endIndex - startIndex;\n  if (count <= 0 && defaults[firstFocalIndex(defaults)]!.cutoff > 0) {\n    steps.push(moveKeyline(defaults, 0, 0, mainAxis, itemSpacing));\n    return steps;\n  }\n  for (let i = 0; i < count; i++) {\n    const prev = steps[steps.length - 1]!;\n    const original = startIndex + i;\n    let dstIndex = defaults.length - 1;\n    if (original > 0) {\n      dstIndex = firstIndexAfterFocalRangeWithSize(prev, defaults[original - 1]!.size) - 1;\n    }\n    steps.push(moveKeyline(prev, firstNonAnchorIndex(defaults), dstIndex, mainAxis, itemSpacing));\n  }\n  if (padding !== 0) {\n    const last = steps[steps.length - 1]!;\n    steps[steps.length - 1] = shiftedForPadding(\n      last,\n      mainAxis,\n      itemSpacing,\n      padding,\n      firstFocalIndex(last),\n      smallMax,\n    );\n  }\n  return steps;\n}\n\nfunction endSteps(\n  defaults: KeylineList,\n  mainAxis: number,\n  itemSpacing: number,\n  padding: number,\n  smallMax: number,\n): KeylineList[] {\n  if (defaults.length === 0) return [];\n  const steps = [defaults];\n  if (isLastFocalAtEnd(defaults, mainAxis)) {\n    if (padding !== 0)\n      steps.push(\n        shiftedForPadding(\n          defaults,\n          mainAxis,\n          itemSpacing,\n          -padding,\n          lastFocalIndex(defaults),\n          smallMax,\n        ),\n      );\n    return steps;\n  }\n  const startIndex = lastFocalIndex(defaults);\n  const endIndex = lastNonAnchorIndex(defaults);\n  const count = endIndex - startIndex;\n  if (count <= 0 && defaults[lastFocalIndex(defaults)]!.cutoff > 0) {\n    steps.push(moveKeyline(defaults, 0, 0, mainAxis, itemSpacing));\n    return steps;\n  }\n  for (let i = 0; i < count; i++) {\n    const prev = steps[steps.length - 1]!;\n    const original = endIndex - i;\n    let dstIndex = 0;\n    if (original < defaults.length - 1) {\n      dstIndex = lastIndexBeforeFocalRangeWithSize(prev, defaults[original + 1]!.size) + 1;\n    }\n    steps.push(moveKeyline(prev, lastNonAnchorIndex(defaults), dstIndex, mainAxis, itemSpacing));\n  }\n  if (padding !== 0) {\n    const last = steps[steps.length - 1]!;\n    steps[steps.length - 1] = shiftedForPadding(\n      last,\n      mainAxis,\n      itemSpacing,\n      -padding,\n      lastFocalIndex(last),\n      smallMax,\n    );\n  }\n  return steps;\n}\n\nfunction interpolationPoints(total: number, steps: KeylineList[], shiftingLeft: boolean) {\n  const points = [0];\n  if (total === 0 || steps.length === 0) return points;\n  for (let i = 1; i < steps.length; i++) {\n    const prev = steps[i - 1]!;\n    const curr = steps[i]!;\n    const shifted = shiftingLeft\n      ? curr[0]!.unadjustedOffset - prev[0]!.unadjustedOffset\n      : prev[prev.length - 1]!.unadjustedOffset - curr[curr.length - 1]!.unadjustedOffset;\n    points.push(i === steps.length - 1 ? 1 : points[i - 1]! + shifted / total);\n  }\n  return points;\n}\n\nconst clampLerp = (outMin: number, outMax: number, inMin: number, inMax: number, v: number) =>\n  v <= inMin ? outMin : v >= inMax ? outMax : lerp(outMin, outMax, (v - inMin) / (inMax - inMin));\n\nexport interface Strategy {\n  defaults: KeylineList;\n  startSteps: KeylineList[];\n  endSteps: KeylineList[];\n  availableSpace: number;\n  itemSpacing: number;\n  itemMainAxisSize: number;\n  startShiftDistance: number;\n  endShiftDistance: number;\n  startShiftPoints: number[];\n  endShiftPoints: number[];\n  isValid: boolean;\n}\n\n/**\n * Compose's `Strategy`. The content padding before the first item and after the last one is\n * handled by the keylines (the last start and end steps are shifted by it), not by the\n * scroller, so items bleed over it while scrolling, as Compose's do. Small items, up to\n * `maxSmallItemSize`, keep their size in those steps (see `shiftedForPadding`).\n */\nexport function createStrategy(\n  defaults: KeylineList,\n  availableSpace: number,\n  itemSpacing: number,\n  beforeContentPadding = 0,\n  afterContentPadding = 0,\n  maxSmallItemSize = MAX_SMALL_ITEM_SIZE,\n): Strategy {\n  const start = startSteps(\n    defaults,\n    availableSpace,\n    itemSpacing,\n    beforeContentPadding,\n    maxSmallItemSize,\n  );\n  const end = endSteps(\n    defaults,\n    availableSpace,\n    itemSpacing,\n    afterContentPadding,\n    maxSmallItemSize,\n  );\n  const startShiftDistance =\n    start.length === 0\n      ? 0\n      : Math.max(\n          start[start.length - 1]![0]!.unadjustedOffset - start[0]![0]!.unadjustedOffset,\n          beforeContentPadding,\n        );\n  const endShiftDistance =\n    end.length === 0\n      ? 0\n      : Math.max(\n          end[0]![end[0]!.length - 1]!.unadjustedOffset -\n            end[end.length - 1]![end[end.length - 1]!.length - 1]!.unadjustedOffset,\n          afterContentPadding,\n        );\n  const focal = defaults[firstFocalIndex(defaults)];\n  const itemMainAxisSize = focal?.size ?? 0;\n  return {\n    defaults,\n    startSteps: start,\n    endSteps: end,\n    availableSpace,\n    itemSpacing,\n    itemMainAxisSize,\n    startShiftDistance,\n    endShiftDistance,\n    startShiftPoints: interpolationPoints(startShiftDistance, start, true),\n    endShiftPoints: interpolationPoints(endShiftDistance, end, false),\n    isValid: defaults.length > 0 && availableSpace !== 0 && itemMainAxisSize !== 0,\n  };\n}\n\n/** Compose's `getKeylineListForScrollOffset`. */\nexport function keylinesForScrollOffset(\n  strategy: Strategy,\n  scrollOffset: number,\n  maxScrollOffset: number,\n): KeylineList {\n  const offset = Math.max(0, scrollOffset);\n  const startShift = strategy.startShiftDistance;\n  const endShift = Math.max(0, maxScrollOffset - strategy.endShiftDistance);\n  if (offset >= startShift && offset <= endShift) return strategy.defaults;\n  let interpolation = clampLerp(1, 0, 0, startShift, offset);\n  let points = strategy.startShiftPoints;\n  let steps = strategy.startSteps;\n  if (offset > endShift) {\n    interpolation = clampLerp(0, 1, endShift, maxScrollOffset, offset);\n    points = strategy.endShiftPoints;\n    steps = strategy.endSteps;\n    if (endShift < 0.01 && strategy.startSteps.length === 2 && strategy.endSteps.length === 2) {\n      steps = [strategy.startSteps[1]!, strategy.endSteps[1]!];\n    }\n  }\n  let from = 0;\n  let to = 0;\n  let stepped = 0;\n  let lower = points[0]!;\n  for (let i = 1; i < steps.length; i++) {\n    const upper = points[i]!;\n    if (interpolation <= upper) {\n      from = i - 1;\n      to = i;\n      stepped = clampLerp(0, 1, lower, upper, interpolation);\n      break;\n    }\n    lower = upper;\n  }\n  return lerpList(steps[from]!, steps[to]!, stepped);\n}\n\n/** Compose's `calculateMaxScrollOffset`. */\nexport function maxScrollOffset(strategy: Strategy, itemCount: number) {\n  const total = strategy.itemMainAxisSize * itemCount + strategy.itemSpacing * (itemCount - 1);\n  return Math.max(0, total - strategy.availableSpace);\n}\n\n/** Compose's `getSnapPositionOffset`: where item `index` sits when snapped. */\nexport function snapPositionOffset(strategy: Strategy, index: number, itemCount: number) {\n  if (!strategy.isValid) return 0;\n  const half = strategy.itemMainAxisSize / 2;\n  let offset = Math.round(\n    strategy.defaults[firstFocalIndex(strategy.defaults)]!.unadjustedOffset - half,\n  );\n  const startLast = strategy.startSteps.length - 1;\n  if (index <= startLast) {\n    const step = strategy.startSteps[Math.min(Math.max(startLast - index, 0), startLast)]!;\n    offset = Math.round(step[firstFocalIndex(step)]!.unadjustedOffset - half);\n  }\n  const lastItem = itemCount - 1;\n  const endLast = strategy.endSteps.length - 1;\n  const focalCount = lastFocalIndex(strategy.defaults) - firstFocalIndex(strategy.defaults) + 1;\n  if (index >= lastItem - endLast && itemCount > focalCount) {\n    const step = strategy.endSteps[Math.min(Math.max(endLast - (lastItem - index), 0), endLast)]!;\n    offset = Math.round(step[lastFocalIndex(step)]!.unadjustedOffset - half);\n  }\n  return offset;\n}\n\nexport interface ItemPlacement {\n  /** Visible (mask) size along the main axis. */\n  size: number;\n  /** Translation along the main axis from the item's natural position. */\n  translation: number;\n}\n\n/** Compose's `carouselItem` placement for item `index` at `scrollOffset`. */\nexport function placeItem(\n  strategy: Strategy,\n  keylines: KeylineList,\n  index: number,\n  scrollOffset: number,\n): ItemPlacement {\n  const sizeWithSpacing = strategy.itemMainAxisSize + strategy.itemSpacing;\n  const center = index * sizeWithSpacing + strategy.itemMainAxisSize / 2 - scrollOffset;\n  let before = keylines[0]!;\n  for (let i = keylines.length - 1; i >= 0; i--) {\n    if (keylines[i]!.unadjustedOffset < center) {\n      before = keylines[i]!;\n      break;\n    }\n  }\n  const after =\n    keylines.find((k) => k.unadjustedOffset >= center) ?? keylines[keylines.length - 1]!;\n  const outOfBounds = before === after;\n  const progress = outOfBounds\n    ? 1\n    : (center - before.unadjustedOffset) / (after.unadjustedOffset - before.unadjustedOffset);\n  const keyline = lerpKeyline(before, after, progress);\n  let translation = keyline.offset - center;\n  if (outOfBounds) translation += (center - keyline.unadjustedOffset) / keyline.size;\n  return { size: keyline.size, translation };\n}\n"],"mappings":"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"}

package/dist/components/carousel/carousel-press-area.js

@@ -0,0 +1,35 @@
+/**
+* How far an item's press area reaches past each end of its visible part, so that an item
+* narrower than M3's 48px touch target (a small item, 40–56px) still takes 48px of presses.
+* It grows into the spacing on each side: half of it where the neighbour grows too, all of
+* it where the neighbour doesn't, so press areas never overlap; and never past the
+* viewport's edges, where it grows the other way instead. Items 48px or wider don't grow.
+*/
+function pressAreaReach(spans, index, spacing, viewport) {
+	const span = spans[index];
+	if (!span) return {
+		start: 0,
+		end: 0
+	};
+	const need = Math.max(0, 48 - span.size);
+	if (need === 0) return {
+		start: 0,
+		end: 0
+	};
+	const grows = (neighbour) => neighbour !== void 0 && neighbour.size < 48;
+	const room = (neighbour) => grows(neighbour) ? spacing / 2 : spacing;
+	const startRoom = Math.max(0, Math.min(room(spans[index - 1]), span.start));
+	const endRoom = Math.max(0, Math.min(room(spans[index + 1]), viewport - (span.start + span.size)));
+	let start = Math.min(startRoom, need / 2);
+	let end = Math.min(endRoom, need / 2);
+	if (start < need / 2) end = Math.min(endRoom, need - start);
+	if (end < need / 2) start = Math.min(startRoom, need - end);
+	return {
+		start,
+		end
+	};
+}
+//#endregion
+export { pressAreaReach };
+
+//# sourceMappingURL=carousel-press-area.js.map

package/dist/components/carousel/carousel-press-area.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"carousel-press-area.js","names":[],"sources":["../../../src/components/carousel/carousel-press-area.ts"],"sourcesContent":["/** M3's minimum touch target, px. */\nexport const MIN_TOUCH_TARGET = 48;\n\n/** An item's visible part along the carousel, in px from the viewport's start edge. */\nexport interface VisibleSpan {\n  start: number;\n  size: number;\n}\n\n/**\n * How far an item's press area reaches past each end of its visible part, so that an item\n * narrower than M3's 48px touch target (a small item, 40–56px) still takes 48px of presses.\n * It grows into the spacing on each side: half of it where the neighbour grows too, all of\n * it where the neighbour doesn't, so press areas never overlap; and never past the\n * viewport's edges, where it grows the other way instead. Items 48px or wider don't grow.\n */\nexport function pressAreaReach(\n  spans: readonly VisibleSpan[],\n  index: number,\n  spacing: number,\n  viewport: number,\n): { start: number; end: number } {\n  const span = spans[index];\n  if (!span) return { start: 0, end: 0 };\n  const need = Math.max(0, MIN_TOUCH_TARGET - span.size);\n  if (need === 0) return { start: 0, end: 0 };\n  const grows = (neighbour: VisibleSpan | undefined) =>\n    neighbour !== undefined && neighbour.size < MIN_TOUCH_TARGET;\n  const room = (neighbour: VisibleSpan | undefined) => (grows(neighbour) ? spacing / 2 : spacing);\n  const startRoom = Math.max(0, Math.min(room(spans[index - 1]), span.start));\n  const endRoom = Math.max(\n    0,\n    Math.min(room(spans[index + 1]), viewport - (span.start + span.size)),\n  );\n  let start = Math.min(startRoom, need / 2);\n  let end = Math.min(endRoom, need / 2);\n  if (start < need / 2) end = Math.min(endRoom, need - start);\n  if (end < need / 2) start = Math.min(startRoom, need - end);\n  return { start, end };\n}\n"],"mappings":";;;;;;;AAgBA,SAAgB,eACd,OACA,OACA,SACA,UACgC;CAChC,MAAM,OAAO,MAAM;CACnB,IAAI,CAAC,MAAM,OAAO;EAAE,OAAO;EAAG,KAAK;CAAE;CACrC,MAAM,OAAO,KAAK,IAAI,GAAA,KAAsB,KAAK,IAAI;CACrD,IAAI,SAAS,GAAG,OAAO;EAAE,OAAO;EAAG,KAAK;CAAE;CAC1C,MAAM,SAAS,cACb,cAAc,KAAA,KAAa,UAAU,OAAA;CACvC,MAAM,QAAQ,cAAwC,MAAM,SAAS,IAAI,UAAU,IAAI;CACvF,MAAM,YAAY,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,MAAM,QAAQ,EAAE,GAAG,KAAK,KAAK,CAAC;CAC1E,MAAM,UAAU,KAAK,IACnB,GACA,KAAK,IAAI,KAAK,MAAM,QAAQ,EAAE,GAAG,YAAY,KAAK,QAAQ,KAAK,KAAK,CACtE;CACA,IAAI,QAAQ,KAAK,IAAI,WAAW,OAAO,CAAC;CACxC,IAAI,MAAM,KAAK,IAAI,SAAS,OAAO,CAAC;CACpC,IAAI,QAAQ,OAAO,GAAG,MAAM,KAAK,IAAI,SAAS,OAAO,KAAK;CAC1D,IAAI,MAAM,OAAO,GAAG,QAAQ,KAAK,IAAI,WAAW,OAAO,GAAG;CAC1D,OAAO;EAAE;EAAO;CAAI;AACtB"}