@riverbankcms/sdk 0.136.0 → 0.137.0

package/dist/client/capacity-BW00PO7s.mjs

@@ -0,0 +1,271 @@
+//#region ../blocks/src/system/runtime/nodes/events/domain/capacity.ts
+/**
+* Compute remaining spots for an event from `availableSpots` with a fallback
+* to `capacity - registeredCount`. Returns `{ available: null, isFull: false }`
+* for uncapped events so call sites can render no capacity indicator at all.
+*
+* The single source of truth for capacity math across event cards, agenda
+* rows, and timetable cells — keep wording variations in the call sites.
+*/
+function getEventAvailability(event) {
+	if (event.capacity == null) return {
+		available: null,
+		isFull: false
+	};
+	const available = event.availableSpots ?? event.capacity - event.registeredCount;
+	if (available <= 0) return {
+		available: 0,
+		isFull: true
+	};
+	return {
+		available,
+		isFull: false
+	};
+}
+/**
+* Pick the capacity row a booking decision should read: the selected
+* attendance mode's availability when the visitor has chosen one and the
+* event publishes it, otherwise the event-level aggregate.
+*
+* The mode row is used wholesale. A mode with `capacity: null` on a capped
+* event is uncapped *by design*: the registration write path applies the
+* same rule via `getEffectiveOccurrenceCapacityForAttendanceMode`, so falling
+* back to the event's `availableSpots` here would block bookings the server
+* accepts. (Waitlist claims are still occurrence-scoped; see issue 1377.)
+*/
+function selectEventCapacitySource(event, attendanceMode) {
+	if (!attendanceMode) return event;
+	return (event.attendanceModes ?? []).find((mode) => mode.mode === attendanceMode) ?? event;
+}
+/**
+* Whether the visitor's next step is the waitlist: the source is full *and*
+* a waitlist is open. The one place this is decided — cards, rows, the
+* wizard's steps and its action bar all route through here so they agree,
+* including for producers that omit `availableSpots` and rely on the
+* `capacity - registeredCount` fallback.
+*/
+function canJoinEventWaitlist(event, options) {
+	const source = selectEventCapacitySource(event, options?.attendanceMode);
+	return getEventAvailability(source).isFull && source.waitlistEnabled === true;
+}
+/**
+* Remaining places at or below which an event reads as scarce and the exact
+* count is worth showing. Above it, no number is shown at all: "147 places
+* left" is not something a visitor acts on, and it is the figure most likely
+* to be stale on a cached page.
+*
+*   max( min(3, ceil(capacity * 0.25)), ceil(capacity * 0.05) )
+*
+* The 25% arm stops small groups shouting early (3 of 4 is not urgency); the
+* 5% floor stops large events staying silent until three remain.
+* capacity 4 -> 1, 12 -> 3, 40 -> 3, 100 -> 5, 200 -> 10.
+*/
+function lowCapacityThreshold(capacity) {
+	return Math.max(Math.min(3, Math.ceil(capacity * .25)), Math.ceil(capacity * .05));
+}
+function getRemainingPlaces(source) {
+	const { available, isFull } = getEventAvailability(source);
+	if (available === null || source.capacity === null) return { kind: "unlimited" };
+	if (isFull) return {
+		kind: "full",
+		waitlist: canJoinEventWaitlist(source)
+	};
+	if (available <= lowCapacityThreshold(source.capacity)) return {
+		kind: "low",
+		remaining: available
+	};
+	return { kind: "open" };
+}
+/**
+* The one place a remaining-places count becomes text. Returns `null` when
+* nothing should be shown: uncapped events, and capped events above the
+* scarcity threshold. Surfaces that need their own full-state wording pass
+* it in rather than re-deriving the count.
+*/
+function formatRemainingPlaces(source, wording = {}) {
+	const remaining = getRemainingPlaces(source);
+	switch (remaining.kind) {
+		case "unlimited":
+		case "open": return null;
+		case "low": return formatPlacesLeft(remaining.remaining, wording.compact === true);
+		case "full": return remaining.waitlist ? wording.waitlist ?? "Waitlist" : wording.full ?? "Full";
+	}
+}
+function formatPlacesLeft(count, compact) {
+	if (compact) return `${count} left`;
+	return count === 1 ? "1 place left" : `${count} places left`;
+}
+function formatTicketTypeRemaining(remainingCapacity) {
+	if (remainingCapacity === null || remainingCapacity > 3) return null;
+	if (remainingCapacity <= 0) return "None left for this ticket type";
+	return `${formatPlacesLeft(remainingCapacity, false)} for this ticket type`;
+}
+/** Total capacity as copy ("12 places"), for detail surfaces that state the size of an event. */
+function formatTotalCapacity(capacity) {
+	if (capacity === null) return null;
+	return capacity === 1 ? "1 place" : `${capacity} places`;
+}
+function getEventAvailabilityStatus(event) {
+	const source = selectMostOpenCapacitySource(event);
+	const remaining = getRemainingPlaces(source);
+	const label = formatEventRemainingPlaces(event, { compact: true });
+	switch (remaining.kind) {
+		case "unlimited": return {
+			status: "available",
+			available: null,
+			isFull: false,
+			label
+		};
+		case "open": return {
+			status: "available",
+			available: getEventAvailability(source).available,
+			isFull: false,
+			label
+		};
+		case "low": return {
+			status: "filling",
+			available: remaining.remaining,
+			isFull: false,
+			label
+		};
+		case "full": return {
+			status: "waitlist",
+			available: 0,
+			isFull: true,
+			label
+		};
+	}
+}
+/**
+* Which capacity figure wins when they disagree.
+*
+* For a hybrid event that publishes both attendance-mode rows, **the mode
+* rows are authoritative and the event-level aggregate is only a summary**.
+* The registration write path admits or refuses per mode
+* (`getEffectiveOccurrenceCapacityForAttendanceMode` on the server), so the
+* aggregate can read full while a mode still has room, and can read open
+* while the mode the visitor wants is full. Believing the aggregate on a
+* card is how a "places available" event turns into a dead end at step two.
+*
+* Everything else — single-mode events, events that publish no rows, and the
+* aggregate-only helpers {@link getEventAvailability} /
+* {@link getRemainingPlaces} that existing callers rely on — keeps reading
+* the aggregate, unchanged.
+*/
+function findHybridModeRows(event) {
+	if (event.deliveryMode !== "hybrid") return null;
+	const rows = event.attendanceModes ?? [];
+	const inPerson = rows.find((row) => row.mode === "in_person");
+	const online = rows.find((row) => row.mode === "online");
+	return inPerson && online ? {
+		inPerson,
+		online
+	} : null;
+}
+/** Openness rank; higher means more room. A full mode with a waitlist beats one without. */
+function remainingPlacesRank(remaining) {
+	switch (remaining.kind) {
+		case "unlimited": return 4;
+		case "open": return 3;
+		case "low": return 2;
+		case "full": return remaining.waitlist ? 1 : 0;
+	}
+}
+function isMoreOpen(candidate, than) {
+	const rank = remainingPlacesRank(candidate);
+	const otherRank = remainingPlacesRank(than);
+	if (rank !== otherRank) return rank > otherRank;
+	return candidate.kind === "low" && than.kind === "low" ? candidate.remaining > than.remaining : false;
+}
+/** True when `candidate` has less room left than `than`. */
+function isScarcer(candidate, than) {
+	return isMoreOpen(than, candidate);
+}
+/**
+* The capacity row a whole-event decision should read: the most open
+* attendance mode of a hybrid event, otherwise the aggregate. A hybrid event
+* is sold out only when both of its modes are, and its waitlist is reachable
+* when either full mode has one open.
+*/
+function selectMostOpenCapacitySource(event) {
+	const rows = findHybridModeRows(event);
+	if (!rows) return event;
+	return isMoreOpen(getRemainingPlaces(rows.online), getRemainingPlaces(rows.inPerson)) ? rows.online : rows.inPerson;
+}
+/** True when no attendance mode has room. Hybrid-aware; use this for sold-out decisions. */
+function isEventFull(event) {
+	return getEventAvailability(selectMostOpenCapacitySource(event)).isFull;
+}
+/**
+* True when the event is full on every mode and at least one of those full
+* modes has a waitlist open. An event with a mode still bookable is not a
+* waitlist prospect: it should send the visitor to that mode instead.
+*/
+function canJoinEventWaitlistOnAnyMode(event) {
+	return canJoinEventWaitlist(selectMostOpenCapacitySource(event));
+}
+const ATTENDANCE_MODE_LABEL = {
+	in_person: "In person",
+	online: "Online"
+};
+/** Wording for a mode with room to spare, where the count is deliberately withheld. */
+const PLACES_AVAILABLE = "Places available";
+/**
+* The browse-surface label for an event's remaining places. Single-mode
+* events get exactly the aggregate label {@link formatRemainingPlaces}
+* produces, and so does a hybrid event whose two modes tell the same story.
+* When the modes differ, both sides are named: "available" on a card is a
+* promise the registration wizard would otherwise have to break.
+*
+* Hybrid examples, in person full with 3 online places left:
+*   default                -> "Online: 3 places left · In person: Full"
+*   { full: 'Sold out' }   -> "Online: 3 places left · In person: Sold out"
+*   { compact: true }      -> "Online: 3 left"
+*/
+function formatEventRemainingPlaces(event, wording = {}) {
+	const rows = findHybridModeRows(event);
+	if (!rows) return formatRemainingPlaces(event, wording);
+	const inPerson = formatRemainingPlaces(rows.inPerson, wording);
+	const online = formatRemainingPlaces(rows.online, wording);
+	if (inPerson === online) return inPerson;
+	if (wording.compact === true) return formatCompactHybridPlaces(rows, wording);
+	return formatBothHybridSides(rows, {
+		inPerson,
+		online
+	});
+}
+/**
+* Both sides, the one with room first: that is the half a visitor can act on,
+* and it should not arrive after a full stop's worth of bad news.
+*/
+function formatBothHybridSides(rows, labels) {
+	return (isMoreOpen(getRemainingPlaces(rows.online), getRemainingPlaces(rows.inPerson)) ? [["online", labels.online], ["in_person", labels.inPerson]] : [["in_person", labels.inPerson], ["online", labels.online]]).map(([mode, label]) => namedModePlaces(mode, label)).join(" · ");
+}
+function namedModePlaces(mode, label) {
+	return `${ATTENDANCE_MODE_LABEL[mode]}: ${label ?? PLACES_AVAILABLE}`;
+}
+/**
+* Pills and timetable cells have room for one short phrase, so they name the
+* single mode that carries news rather than listing both: the scarce side
+* when there is a count to show, and otherwise the side that has closed —
+* "In person: Full", never "Online only", which reads as a statement about
+* how the event is delivered rather than about its remaining places.
+*/
+function formatCompactHybridPlaces(rows, wording) {
+	const inPerson = getRemainingPlaces(rows.inPerson);
+	const online = getRemainingPlaces(rows.online);
+	if (inPerson.kind === "full" && online.kind === "full") return formatRemainingPlaces(inPerson.waitlist ? rows.inPerson : rows.online, wording);
+	if (inPerson.kind === "full" || online.kind === "full") {
+		const fullSide = inPerson.kind === "full" ? "in_person" : "online";
+		const openSide = inPerson.kind === "full" ? "online" : "in_person";
+		const openLabel = formatRemainingPlaces(rowFor(rows, openSide), wording);
+		return openLabel !== null ? namedModePlaces(openSide, openLabel) : namedModePlaces(fullSide, formatRemainingPlaces(rowFor(rows, fullSide), wording));
+	}
+	const scarcerSide = isScarcer(online, inPerson) ? "online" : "in_person";
+	return namedModePlaces(scarcerSide, formatRemainingPlaces(rowFor(rows, scarcerSide), wording));
+}
+function rowFor(rows, mode) {
+	return mode === "online" ? rows.online : rows.inPerson;
+}
+//#endregion
+export { formatTicketTypeRemaining as a, getEventAvailabilityStatus as c, selectEventCapacitySource as d, selectMostOpenCapacitySource as f, formatRemainingPlaces as i, getRemainingPlaces as l, canJoinEventWaitlistOnAnyMode as n, formatTotalCapacity as o, formatEventRemainingPlaces as r, getEventAvailability as s, canJoinEventWaitlist as t, isEventFull as u };

package/dist/client/{carousel-BVU5NQlb.mjs → carousel-BrbGJ2Jl.mjs}

@@ -1,4 +1,4 @@
-import { t as defineIslandPropsDecoder } from "./propsDecoder-pzBeCh14.mjs";
+import { t as defineIslandPropsDecoder } from "./propsDecoder-pYvx_Srl.mjs";
 import { t as mountReactIsland } from "./reactMount-SY8AVRof.mjs";
 import { n as normalizeCarouselProps, t as CarouselNodeClient } from "./carousel.client-59G_WMr4.mjs";
 import "react";

package/dist/client/{cart-BNItcZVa.mjs → cart-Bq5eU0xZ.mjs}

@@ -1,6 +1,6 @@
-import { t as defineIslandPropsDecoder } from "./propsDecoder-pzBeCh14.mjs";
-import { t as CartController } from "./shop-commerce-DicXYaYX.mjs";
-import { t as mountShopBlockIsland } from "./shopShared-BDf9ljkm.mjs";
+import { t as defineIslandPropsDecoder } from "./propsDecoder-pYvx_Srl.mjs";
+import { t as CartController } from "./shop-commerce-B76Jz23B.mjs";
+import { t as mountShopBlockIsland } from "./shopShared-vXU1omwJ.mjs";
 import "react";
 import { jsx } from "react/jsx-runtime";
 //#region ../blocks/src/system/runtime/nodes/cart.client.tsx

package/dist/client/{checkout-Bu6iCdkP.mjs → checkout-BAFVRdrK.mjs}

@@ -1,6 +1,6 @@
-import { t as defineIslandPropsDecoder } from "./propsDecoder-pzBeCh14.mjs";
-import { n as CheckoutController } from "./shop-commerce-DicXYaYX.mjs";
-import { t as mountShopBlockIsland } from "./shopShared-BDf9ljkm.mjs";
+import { t as defineIslandPropsDecoder } from "./propsDecoder-pYvx_Srl.mjs";
+import { n as CheckoutController } from "./shop-commerce-B76Jz23B.mjs";
+import { t as mountShopBlockIsland } from "./shopShared-vXU1omwJ.mjs";
 import "react";
 import { jsx } from "react/jsx-runtime";
 //#region ../blocks/src/system/runtime/nodes/checkout.client.tsx