@medalsocial/booking 0.1.0 → 0.2.0

package/dist/core/machine.mjs

@@ -3,6 +3,7 @@ import { fill, labelText, resolveLabels } from "./labels.mjs";
 import { createClock } from "./clock.mjs";
 import { resourceMatches } from "./deep-link.mjs";
 import { createMoney } from "./money.mjs";
+import { visitKey, visitOf, visitPriceOre, visitServicesOf } from "./visit.mjs";
 //#region src/core/machine.ts
 /**
 * The wizard's brain: which step is reachable, what the sticky summary bar
@@ -49,6 +50,7 @@ function initialState() {
 		step: "who",
 		people: [],
 		choices: [],
+		extras: [],
 		items: [],
 		resourceId: null,
 		stylistAnswered: false,
@@ -69,23 +71,55 @@ function initialState() {
 	};
 }
 /**
-* The strictest service involved sets the party limit — and the service about to
-* be added counts, not just the ones already chosen. Mirroring the engine rather
-* than inventing a ceiling: `bookings.ts` takes `Math.min` over every service in
-* the request and imposes no cap of its own, so the salon's real ceiling is
-* whatever it seeded (`maxPerBooking: 3` for `barn`, 1 for everything else). A
-* hardcoded number here would be a second, invisible rule that silently
-* disagreed with the salon's the day they changed it.
+* The first service more people would take than its `maxPerBooking` allows, or
+* `null` when every service is within its cap — the engine's party rule, given
+* the lists as they WOULD be after the tap being judged.
 *
-* Counting the incoming service is what lets a strict one refuse at the tap
-* instead of at submit — the engine's own worked example is that a service with
-* `maxPerBooking: 1` cannot ride along in a party of four. It also disposes of
-* `Math.min()`-of-nothing: the spread always holds at least the incoming
-* service, so an empty basket yields that service's own limit rather than
-* `Infinity`, and `addService` cannot append forever.
+* Per service, not per party. The engine used to cap the whole booking at the
+* strictest service's number, which kept a grown-up's one-at-a-time cut out of
+* any family visit; it now counts, for each service, the people taking it. So
+* a «Skjegg» with `maxPerBooking: 1` rides along with two children's cuts, and
+* two people on that «Skjegg» are still refused. Mirroring the engine rather
+* than inventing a ceiling: a number of our own would be a second, invisible
+* rule that disagreed with the salon's the day they changed it.
+*
+* A service counts at most once per person — a person's list never holds it
+* twice, and if one did it would still be one chair.
+*/
+function overServiceCap(lists) {
+	const takers = /* @__PURE__ */ new Map();
+	for (const list of lists) {
+		const once = new Map(list.map((service) => [service.id, service]));
+		for (const service of once.values()) {
+			const entry = takers.get(service.id) ?? {
+				service,
+				people: 0
+			};
+			entry.people += 1;
+			takers.set(service.id, entry);
+		}
+	}
+	for (const { service, people } of takers.values()) if (people > service.maxPerBooking) return service;
+	return null;
+}
+/**
+* A person's extra services, tolerating a state that predates them. This
+* package's own state always carries `extras` (`initialState`), but meda types
+* the field optional and a custom shell may hold a state saved before 0.3 —
+* reading `state.extras[i]` off that would throw at the first tap.
 */
-function partyLimit(items, incoming) {
-	return Math.min(incoming.maxPerBooking, ...items.map((item) => item.service.maxPerBooking));
+function extrasAt(state, index) {
+	return state.extras?.[index] ?? [];
+}
+/** Person `index`'s services in order: their first, then their extras. */
+function servicesOf(state, index) {
+	const first = state.choices[index] ?? null;
+	return first === null ? [] : [first, ...extrasAt(state, index)];
+}
+/** Whether a named stylist can do every service in a list. Absent ids are
+* «the caller does not know», which keeps the preference — see `stylistAfterAdd`. */
+function canServeAll(resourceServiceIds, services) {
+	return resourceServiceIds === void 0 || services.every((service) => resourceServiceIds.includes(service.id));
 }
 /** The one stylist a seating chart names throughout, or `null` when it names
 * more than one. An empty chart has nobody, which is also `null`. */
@@ -109,7 +143,7 @@ function sharedResourceId(resourceIds) {
 * case is a caller other than the wizard rather than a race.
 */
 function stylistAfterAdd(action) {
-	return action.resourceServiceIds === void 0 || action.resourceServiceIds.includes(action.service.id) ? {} : {
+	return canServeAll(action.resourceServiceIds, [action.service]) ? {} : {
 		resourceId: null,
 		stylistAnswered: false
 	};
@@ -161,10 +195,11 @@ const clearedSlot = {
 function guestChild(n) {
 	return { key: `guest:${n}` };
 }
-/** A person as a line item: the service, and what is known about who sits in the chair. */
-function itemFor(person, service) {
+/** A person as a line item: the services, and what is known about who sits in the chair. */
+function itemFor(person, service, extras) {
 	return {
 		service,
+		...extras.length === 0 ? {} : { extraServices: [...extras] },
 		...person.name === void 0 ? {} : { bookedForName: person.name },
 		...person.birthYear === void 0 ? {} : { bookedForBirthYear: person.birthYear },
 		...person.personId === void 0 ? {} : { bookedForPersonId: person.personId },
@@ -172,22 +207,40 @@ function itemFor(person, service) {
 		...person.adult ? { adult: true } : {}
 	};
 }
+/** Every person's whole visit, so an extra added or removed reads as a changed
+* basket — a Vask after the Klipp makes the visit fifteen minutes longer, and
+* the slot chosen for the shorter one is no longer a slot anyone offered. */
 function basketOf(items) {
-	return items.map((item) => item.service.id).join("|");
+	return items.map((item) => visitKey(item)).join("|");
 }
 /**
-* `people` and `choices` in, the basket out — the one place `items` is built
-* from them. A basket whose services changed drops the slot, for the reason
-* `clearedSlot` gives; one that only changed WHO (a name typed on «Bekreft»,
-* say) keeps it.
+* `people`, `choices` and `extras` in, the basket out — the one place `items`
+* is built from them. A basket whose services changed drops the slot, for the
+* reason `clearedSlot` gives; one that only changed WHO (a name typed on
+* «Bekreft», say) keeps it.
+*
+* THE ALIGNMENT RULE: `extras[i]` belongs to `people[i]`, exactly as
+* `choices[i]` does. Every action that rebuilds or reorders `people` either
+* carries each surviving person's extras with them — matched by `key`, the way
+* `choosePeople` and `seatFamily` carry `choices` — or resets them to `[]`
+* where the person's first service is replaced by a one-tap pick: `pickService`
+* replacing the basket clears every extra, `pickServiceFor` clears that
+* person's, because a one-tap card means «this, and only this». A person added
+* by a link or a sibling chip starts on `[]`. Required rather than defaulted, so
+* no caller can drop a person's extras by forgetting to mention them.
+*
+* A person with no first service has no extras either, whatever was passed:
+* an extra never stands alone.
 */
-function withParty(state, people, choices) {
-	const items = people.length > 0 && choices.every((choice) => choice !== null) ? people.map((person, index) => itemFor(person, choices[index])) : [];
+function withParty(state, people, choices, extras) {
+	const aligned = people.map((_, index) => choices[index] ? [...extras[index]] : []);
+	const items = people.length > 0 && choices.every((choice) => choice !== null) ? people.map((person, index) => itemFor(person, choices[index], aligned[index])) : [];
 	const changed = basketOf(items) !== basketOf(state.items);
 	return {
 		...state,
 		people,
 		choices,
+		extras: aligned,
 		items,
 		...changed ? clearedSlot : {}
 	};
@@ -241,6 +294,7 @@ function seatFamily(state) {
 	if (!state.people.some(isGuestSeat)) return state;
 	const people = [];
 	const choices = [];
+	const extras = [];
 	state.people.forEach((person, index) => {
 		const seat = person.key === "adult" ? {
 			key: SELF_KEY,
@@ -249,9 +303,10 @@ function seatFamily(state) {
 		if (isGuestSeat(seat) || people.some((other) => other.key === seat.key)) return;
 		people.push(seat);
 		choices.push(state.choices[index] ?? null);
+		extras.push(extrasAt(state, index));
 	});
 	return {
-		...withParty(state, people, choices),
+		...withParty(state, people, choices, extras),
 		step: people.length === 0 ? "who" : state.step,
 		error: null
 	};
@@ -260,21 +315,22 @@ function seatFamily(state) {
 function pickServiceFor(state, action) {
 	if (!state.people[action.index] && !(action.index === 0 && state.people.length === 0)) return state;
 	if (state.people.length <= 1) return {
-		...withParty(state, [state.people[0] ?? guestChild(1)], [action.service]),
+		...withParty(state, [state.people[0] ?? guestChild(1)], [action.service], [[]]),
 		...clearedSlot,
 		resourceId: null,
 		stylistAnswered: false,
 		step: "when",
 		error: null
 	};
-	if (action.service.maxPerBooking < state.people.length) return {
+	if (overServiceCap(state.people.map((_, index) => index === action.index ? [action.service] : servicesOf(state, index))) !== null) return {
 		...state,
 		error: "maxParty"
 	};
 	const choices = state.choices.map((choice, index) => index === action.index ? action.service : choice);
-	const canServe = action.resourceServiceIds === void 0 || action.resourceServiceIds.includes(action.service.id);
+	const extras = state.people.map((_, index) => index === action.index ? [] : extrasAt(state, index));
+	const canServe = canServeAll(action.resourceServiceIds, [action.service]);
 	return {
-		...withParty(state, state.people, choices),
+		...withParty(state, state.people, choices, extras),
 		...canServe ? {} : {
 			resourceId: null,
 			stylistAnswered: false
@@ -347,10 +403,10 @@ function canGoToStep(state, step) {
 */
 function itemStartTimes(items, startTs, partyMode) {
 	let offset = 0;
-	return items.map(({ service }, index) => {
+	return items.map((item, index) => {
 		if (partyMode === "sequential" && index > 0) {
-			const previous = items[index - 1].service;
-			offset += (previous.durationMinutes + previous.bufferAfterMinutes + service.bufferBeforeMinutes) * 6e4;
+			const previous = visitOf(items[index - 1]);
+			offset += (previous.durationMinutes + previous.bufferAfterMinutes + visitOf(item).bufferBeforeMinutes) * 6e4;
 		}
 		return startTs + offset;
 	});
@@ -370,17 +426,20 @@ function itemStartTimes(items, startTs, partyMode) {
 * length rather than a negative one.
 */
 function visitMinutes(items, partyMode) {
-	if (partyMode === "parallel") return Math.max(0, ...items.map(({ service }) => service.durationMinutes));
-	return items.reduce((total, { service }, index) => total + service.durationMinutes + (index === 0 ? 0 : items[index - 1].service.bufferAfterMinutes + service.bufferBeforeMinutes), 0);
+	const visits = items.map((item) => visitOf(item));
+	if (partyMode === "parallel") return Math.max(0, ...visits.map((visit) => visit.durationMinutes));
+	return visits.reduce((total, visit, index) => total + visit.durationMinutes + (index === 0 ? 0 : visits[index - 1].bufferAfterMinutes + visit.bufferBeforeMinutes), 0);
 }
 /**
 * How much EARLIER a family has to start than a single first child would.
 *
-* The schedule endpoint answers for one service, so `lastStartTs` is «the last
-* start a Gutteklipp fits» — the last minute at which that service's prep,
-* duration and cleanup all land inside the day's window. A family needs its
-* whole chain to fit, so its own last start is earlier by exactly the part of
-* the chain that hangs off the end of the first child's busy span.
+* The schedule endpoint is asked for the FIRST person's whole visit — their
+* service plus its extras — so `lastStartTs` is «the last start that visit
+* fits»: the last minute at which its prep, every service's minutes and its
+* cleanup all land inside the day's window. A family needs its whole chain to
+* fit, so its own last start is earlier by exactly the part of the chain that
+* hangs off the end of the first person's whole busy span — everybody after
+* them.
 *
 * NOT `visitMinutes - firstDuration`, which was the first attempt and is wrong
 * in a way that only shows on a mixed basket: `visitMinutes` deliberately
@@ -396,11 +455,14 @@ function visitMinutes(items, partyMode) {
 * has to fit is the LONGEST busy span rather than the sum.
 */
 function visitTailMinutes(items, partyMode) {
-	const first = items[0]?.service;
+	const first = items[0];
 	if (first === void 0 || items.length < 2) return 0;
-	const busy = (service) => service.bufferBeforeMinutes + service.durationMinutes + service.bufferAfterMinutes;
-	if (partyMode === "parallel") return Math.max(0, Math.max(...items.map(({ service }) => busy(service))) - busy(first));
-	return items.slice(1).reduce((total, { service }) => total + service.bufferBeforeMinutes + service.durationMinutes + service.bufferAfterMinutes, 0);
+	const busy = (item) => {
+		const visit = visitOf(item);
+		return visit.bufferBeforeMinutes + visit.durationMinutes + visit.bufferAfterMinutes;
+	};
+	if (partyMode === "parallel") return Math.max(0, Math.max(...items.map(busy)) - busy(first));
+	return items.slice(1).reduce((total, item) => total + busy(item), 0);
 }
 /** When the family leaves. The same arithmetic as `visitMinutes`, which is why
 * it is that function and not a second copy of it: an .ics that ended before
@@ -454,6 +516,7 @@ function stylistLabel(state, resolveStylistName) {
 /** The machine for one site: its party ceiling, kids' categories, clock, currency and words. */
 function createWizard(config) {
 	const maxPeople = config.party.maxPeople;
+	const maxServices = config.party.maxServicesPerPerson;
 	const clock = createClock(config);
 	const money = createMoney(config);
 	const labels = resolveLabels(config.locale, config.labels);
@@ -469,6 +532,10 @@ function createWizard(config) {
 			if (index !== -1) return state.choices[index] ?? null;
 			return heldFor(state.pendingService, person) ?? action.services?.[position] ?? null;
 		});
+		const extras = action.people.map((person) => {
+			const index = before(person);
+			return index === -1 ? [] : extrasAt(state, index);
+		});
 		return {
 			...withParty(state, action.people.map((person) => {
 				const index = before(person);
@@ -476,7 +543,7 @@ function createWizard(config) {
 					...state.people[index],
 					...person
 				};
-			}), choices),
+			}), choices, extras),
 			step: action.advance ? "service" : state.step,
 			error: null
 		};
@@ -498,11 +565,46 @@ function createWizard(config) {
 			people: [...state.people, person]
 		});
 	}
+	/** `toggleServiceFor` — see the action. */
+	function toggleServiceFor(state, action) {
+		const seated = state.people[action.index] !== void 0;
+		if (!seated && !(action.index === 0 && state.people.length === 0)) return state;
+		const people = seated ? state.people : [guestChild(1)];
+		const lists = people.map((_, index) => seated ? servicesOf(state, index) : []);
+		const current = lists[action.index];
+		const has = current.some((service) => service.id === action.service.id);
+		let next;
+		if (has) next = current.filter((service) => service.id !== action.service.id);
+		else {
+			if (current.length >= maxServices) return {
+				...state,
+				error: "maxServices"
+			};
+			next = [...current, action.service];
+			if (overServiceCap(lists.map((list, index) => index === action.index ? next : list)) !== null) return {
+				...state,
+				error: "maxParty"
+			};
+		}
+		const choices = people.map((_, index) => index === action.index ? next[0] ?? null : state.choices[index] ?? null);
+		const extras = people.map((_, index) => index === action.index ? next.slice(1) : extrasAt(state, index));
+		const canServe = canServeAll(action.resourceServiceIds, next);
+		return {
+			...withParty(state, people, choices, extras),
+			...clearedSlot,
+			...canServe ? {} : {
+				resourceId: null,
+				stylistAnswered: false
+			},
+			error: null
+		};
+	}
 	function reduce(state, action) {
 		switch (action.type) {
 			case "startOver": return initialState();
 			case "choosePeople": return choosePeople(state, action);
 			case "pickServiceFor": return pickServiceFor(state, action);
+			case "toggleServiceFor": return toggleServiceFor(state, action);
 			case "seatFamily": return seatFamily(state);
 			case "addPerson": return addPerson(state, action.person);
 			case "holdService": return {
@@ -510,7 +612,7 @@ function createWizard(config) {
 				pendingService: action.service
 			};
 			case "pickService": return {
-				...withParty(state, peopleFor(state, 1), [action.service]),
+				...withParty(state, peopleFor(state, 1), [action.service], [[]]),
 				...clearedSlot,
 				resourceId: null,
 				stylistAnswered: false,
@@ -518,12 +620,12 @@ function createWizard(config) {
 				error: null
 			};
 			case "addService":
-				if (state.items.length >= partyLimit(state.items, action.service)) return {
+				if (state.items.length >= maxPeople || overServiceCap([...state.items.map(visitServicesOf), [action.service]]) !== null) return {
 					...state,
 					error: "maxParty"
 				};
 				return {
-					...withParty(state, peopleFor(state, state.items.length + 1), [...state.items.map((item) => item.service), action.service]),
+					...withParty(state, peopleFor(state, state.items.length + 1), [...state.items.map((item) => item.service), action.service], [...state.items.map((item) => item.extraServices ?? []), []]),
 					...clearedSlot,
 					...stylistAfterAdd(action),
 					error: null
@@ -642,7 +744,6 @@ function createWizard(config) {
 				type: "addService",
 				service
 			});
-			/* v8 ignore next -- defensive: `wanted` never exceeds the service's own limit */
 			if (after.items.length === next.items.length) break;
 			next = after;
 		}
@@ -714,7 +815,7 @@ function createWizard(config) {
 		if (prefill.resourceId && next.step === "when" && !next.stylistAnswered && next.resourceId === null && next.startTs === null) {
 			const wantedResource = prefill.resourceId;
 			const resource = catalogue.resources.find((entry) => resourceMatches(entry, wantedResource));
-			const basket = next.items.map((item) => item.service.id);
+			const basket = next.items.flatMap((item) => visitServicesOf(item).map(({ id }) => id));
 			if (resource !== void 0 && basket.every((id) => resource.serviceIds.includes(id))) next = reduce(next, {
 				type: "pickResource",
 				resourceId: resource.id
@@ -753,6 +854,14 @@ function createWizard(config) {
 		return Math.round(service.priceOre * multiplier);
 	}
 	/**
+	* What ONE person's whole visit costs — every service they chose, each priced
+	* by `itemPriceOre`. The line the confirmation card prints per person, and
+	* the unit `totalPriceOre` sums, so a line and the total cannot disagree.
+	*/
+	function visitItemPriceOre(item, startTs) {
+		return visitPriceOre(visitServicesOf(item), (service) => itemPriceOre(service, startTs));
+	}
+	/**
 	* What the visit costs, in øre, at the time it was booked for.
 	*
 	* Here rather than in either component that shows it, because both of them show
@@ -761,7 +870,7 @@ function createWizard(config) {
 	* sort of rule that gets applied in one of two places.
 	*/
 	function totalPriceOre(items, startTs) {
-		return items.reduce((sum, { service }) => sum + itemPriceOre(service, startTs), 0);
+		return items.reduce((sum, item) => sum + visitItemPriceOre(item, startTs), 0);
 	}
 	/**
 	* What is being booked.
@@ -776,7 +885,7 @@ function createWizard(config) {
 	function serviceLabel(state) {
 		const { items } = state;
 		if (items.length === 0) return null;
-		if (!showsPartyMode(state)) return items[0].service.name;
+		if (!showsPartyMode(state)) return visitServicesOf(items[0]).map((service) => service.name).join(" + ");
 		return `${fill(labels["summary.services"], { count: items.length })}${SEPARATOR}${fill(labels["summary.totalMinutes"], { minutes: visitMinutes(items, state.partyMode) })}`;
 	}
 	/** «Theo, Emma», «2 barn», «Voksen» — who the visit is for, before what. */
@@ -860,6 +969,7 @@ function createWizard(config) {
 		canAdvance,
 		canGoToStep,
 		itemPriceOre,
+		visitItemPriceOre,
 		totalPriceOre,
 		itemStartTimes,
 		visitMinutes,