@ticketboothapp/booking 1.2.59 → 1.2.61

package/src/components/booking/Calendar.tsx

@@ -49,14 +49,23 @@ interface CalendarProps {
   displayMode?: 'times' | 'status';
   /** Optional extra discount percent added to the day-level discount badge. */
   extraDiscountPercent?: number;
-  /** When true, cap day discount badges to the currently selected date's discount percent. */
-  capDiscountToSelectedDate?: boolean;
+  /**
+   * Change-booking: yyyy-MM-dd of the **existing** booking's tour date. When that date exists in
+   * [availabilitiesByDate], each day's badge uses `min(that day's catalog %, the booking date's catalog %)` so
+   * the cap stays tied to the current booking, not which day is selected in the UI.
+   */
+  capDiscountBadgesToBookingDate?: string | null;
   /**
    * When true (e.g. change-booking flow), scroll the visible grid once to the week containing
    * `selectedDate` after the parent sets it from the current booking. Otherwise the grid stays
    * anchored to the earliest available date.
    */
   syncVisibleWeekToSelectedDate?: boolean;
+  /**
+   * Optional date string (yyyy-MM-dd) that should remain selectable even when sold out.
+   * Used by change-booking so the original booked date can always be selected.
+   */
+  selectableSoldOutDate?: string | null;
 }
 
 // ============ Constants ============
@@ -152,18 +161,21 @@ interface DateCellProps {
   showCapacity?: boolean;
   timezone: string;
   displayMode: 'times' | 'status';
+  selectableSoldOutDate?: string | null;
   onClick: () => void;
   isMobile?: boolean;
 }
 
 const DateCell = memo(function DateCell({
   date,
+  dateStr,
   availability,
   isSelected,
   isToday,
   showCapacity,
   timezone,
   displayMode,
+  selectableSoldOutDate = null,
   onClick,
   isMobile = false,
 }: DateCellProps) {
@@ -171,8 +183,12 @@ const DateCell = memo(function DateCell({
   const { locale } = useLocale();
   const dateFnsLocale = dateFnsLocales[locale] || enUS;
   const dayNumber = formatInTimeZone(date, timezone, 'd');
-  // When showCapacity (admin), allow selecting sold-out slots for overbooking
-  const hasAvailability = availability !== null && (!availability.isSoldOut || showCapacity);
+  const allowPinnedSoldOutDate = Boolean(selectableSoldOutDate && selectableSoldOutDate === dateStr);
+  const hasAvailabilityData = availability !== null;
+  // When showCapacity (admin), allow selecting sold-out slots for overbooking.
+  // In change flow, also allow the original booked sold-out date to stay selectable.
+  const hasAvailability =
+    hasAvailabilityData && (!availability.isSoldOut || showCapacity || allowPinnedSoldOutDate);
   const isDisabled = !hasAvailability;
 
   // Format time for display. timeStr (e.g. "09:00") is already in company timezone (MDT).
@@ -389,8 +405,9 @@ export function Calendar({
   isLoading = false,
   displayMode = 'times',
   extraDiscountPercent = 0,
-  capDiscountToSelectedDate = false,
+  capDiscountBadgesToBookingDate = null,
   syncVisibleWeekToSelectedDate = false,
+  selectableSoldOutDate = null,
 }: CalendarProps) {
   const { t } = useTranslations();
   const { locale } = useLocale();
@@ -837,14 +854,15 @@ export function Calendar({
         };
       }
     });
-    
-    if (capDiscountToSelectedDate && selectedDate) {
-      const selectedDiscount = map[selectedDate]?.totalDiscountPercent;
-      if (selectedDiscount != null && selectedDiscount > 0) {
+
+    const anchor = capDiscountBadgesToBookingDate?.trim() || null;
+    if (anchor) {
+      const anchorDiscount = map[anchor]?.totalDiscountPercent;
+      if (anchorDiscount != null && anchorDiscount > 0) {
         const capped: Record<string, DateAvailability> = {};
         for (const [dateStr, availability] of Object.entries(map)) {
           const raw = availability.totalDiscountPercent;
-          const adjusted = raw != null ? Math.min(raw, selectedDiscount) : undefined;
+          const adjusted = raw != null ? Math.min(raw, anchorDiscount) : undefined;
           capped[dateStr] = {
             ...availability,
             totalDiscountPercent: adjusted,
@@ -855,7 +873,7 @@ export function Calendar({
     }
 
     return map;
-  }, [availabilitiesByDate, timezone, currency, extraDiscountPercent, capDiscountToSelectedDate, selectedDate]);
+  }, [availabilitiesByDate, timezone, currency, extraDiscountPercent, capDiscountBadgesToBookingDate]);
 
   // Get display range for header
   const displayRange = useMemo(() => {
@@ -884,9 +902,16 @@ export function Calendar({
   const handleDateClick = (date: Date) => {
     const dateStr = formatInTimeZone(date, timezone, 'yyyy-MM-dd');
     const availability = dateAvailabilityMap[dateStr] || null;
-    
-    // Allow selection when there are availabilities; when showCapacity (admin), allow sold-out for overbooking
-    if (availability && (!availability.isSoldOut || showCapacity)) {
+
+    const allowPinnedSoldOutDate = Boolean(
+      selectableSoldOutDate &&
+      selectableSoldOutDate === dateStr &&
+      availability?.isSoldOut,
+    );
+
+    // Allow selection when there are availabilities; when showCapacity (admin), allow sold-out for overbooking.
+    // In change flow, also allow re-selecting the original booked sold-out date.
+    if (availability && (!availability.isSoldOut || showCapacity || allowPinnedSoldOutDate)) {
       onDateSelect(dateStr);
     }
   };
@@ -1026,7 +1051,13 @@ export function Calendar({
                     const hasAvailabilityData = availability !== null;
                     const isSoldOut = availability?.isSoldOut === true;
                     // When showCapacity (admin), sold-out days are still selectable for overbooking
-                    const isAvailable = hasAvailabilityData && isInAllowedRange && (!isSoldOut || showCapacity);
+                    const allowPinnedSoldOutDate = Boolean(
+                      selectableSoldOutDate && selectableSoldOutDate === dateStr && isSoldOut,
+                    );
+                    const isAvailable =
+                      hasAvailabilityData &&
+                      isInAllowedRange &&
+                      (!isSoldOut || showCapacity || allowPinnedSoldOutDate);
                     const isToday = isSameDay(day, new Date());
                     
                     const dayClass = cn(
@@ -1036,7 +1067,7 @@ export function Calendar({
                       isSoldOut && showCapacity && styles.calendarDropdownDaySoldOutAdmin,
                       !isSoldOut && !isInAllowedRange && styles.calendarDropdownDayMuted,
                       !hasAvailabilityData && isInAllowedRange && styles.calendarDropdownDayMuted,
-                      isAvailable && isSelected && styles.calendarDropdownDaySelected,
+                      isSelected && isAvailable && styles.calendarDropdownDaySelected,
                       isAvailable && !isSelected && styles.calendarDropdownDayAvailable,
                       isToday && isAvailable && !isSelected && styles.calendarDropdownDayToday
                     );
@@ -1140,6 +1171,7 @@ export function Calendar({
                 showCapacity={showCapacity}
                 timezone={timezone}
                 displayMode={displayMode}
+                selectableSoldOutDate={selectableSoldOutDate}
                 onClick={() => handleDateClick(date)}
                 isMobile={isMobile}
               />

package/src/components/booking/ChangeBookingDialog.tsx

@@ -193,6 +193,8 @@ export default function ChangeBookingDialog({
     bookingReference: booking.bookingReference ?? null,
     dateTime: booking.dateTime ?? null,
     availabilityId: booking.availabilityId ?? null,
+    /** Parent id (`p_…`) when API did not persist option id; BookingFlow resolves option via availability row. */
+    productId: booking.productId ?? null,
     productOptionId: effectiveProductOptionIdForChangeFlow(booking),
     pickupLocationId: booking.pickupLocationId ?? null,
     returnAvailabilityId: booking.returnAvailabilityId ?? null,
@@ -208,6 +210,8 @@ export default function ChangeBookingDialog({
     },
     promoCode: lockedPromoCode,
     cancellationPolicyId: booking.cancellationPolicyId ?? null,
+    returnUnitFloorPerPerson:
+      (booking as { returnUnitFloorPerPerson?: number | null }).returnUnitFloorPerPerson ?? null,
   };
   const receiptCurrency = (booking.receipt.currency as Currency) || 'CAD';
   // Use booking + static config only — not `product.name` (minimal → API product swaps labels).

package/src/lib/booking/change-flow-pricing.ts

@@ -0,0 +1,171 @@
+/**
+ * ## Change-booking pricing — product rules (frontend)
+ *
+ * Use this file as the **spec checklist** when debating behavior with product; BookingFlow adds **gates** (parent product,
+ * channel) on top of these formulas.
+ *
+ * ### 1. When receipt “paid floors” apply
+ * Only **customer self-serve** change flow, when the booking’s **parent catalog product** matches the **loaded product**
+ * (`changeFlowApplyReceiptPaidFloors` in BookingFlow). **Provider dashboard** change flow uses **live catalog only** (no
+ * floors) so a cheaper date/return yields a lower total / refund via signed balance.
+ *
+ * ### 2. Tickets (per category)
+ * For each category where we can infer an average **unit paid** from the stored receipt:
+ * - Among seats **up to** the **originally booked** count for that category, **unit price** =
+ *   **`max(receipt average unit, live catalog unit)`** — not the minimum; the guest never pays **below** what they paid
+ *   for those seats **and** never **below** today’s list price for those seats.
+ * - Any **extra** seats beyond the original count for that category: **live catalog only** (no receipt floor).
+ * If we cannot infer a receipt unit for a category, that line stays **live catalog** only.
+ *
+ * ### 3. Product fees (config fees, per line)
+ * Split the party into **protected** headcount (≤ original total ticket count) vs **incremental** passengers.
+ * For each fee line: **`max(receipt-derived fee per person, live fee per person)`** on protected passengers; incremental
+ * passengers pay each line’s **live** per-person amount only.
+ *
+ * ### 4. Return option — **order total / checkout**
+ * When §1 floors apply and a per-person return floor exists (API `returnUnitFloorPerPerson` or receipt RETURN lines):
+ * **per person** = **`max(live catalog return for the selected slot, floor)`**; **row total** = party size × that amount.
+ * Provider dashboard: **live catalog return only** (no floor).
+ *
+ * ### 5. Return option — **picker UI only** (BookingFlow)
+ * **Self-serve:** return cards use the floored per-person price when a floor exists (aligned with §4).
+ * **Provider dashboard:** cards show **catalog** prices only (no floor).
+ *
+ * ### 6. Quote “new booking” total & balance
+ * **FE proposed total** = full cart math (subtotal + tax − promo), cent-rounded; optional **1¢ reconcile** to old receipt
+ * total when the difference is only rounding noise (`resolveChangeFlowNewBookingTotal`).
+ * **Customer** owes **`max(0, newTotal − oldReceipt)`**; **provider** inline pricing may show a **signed** delta.
+ */
+import { reconcileChangeBookingProposedTotal } from '../currency';
+
+/** Money in major units, rounded to cents (half-up). */
+export function roundMoney(amount: number): number {
+  return Math.round(amount * 100) / 100;
+}
+
+/**
+ * One ticket row: protected seats use `max(receipt unit, live unit)`; extra qty uses live only.
+ */
+export function changeFlowTicketLineTotalWithReceiptFloor(input: {
+  qty: number;
+  /** Seats originally booked in this category (caps “protected” seats). */
+  baselineQtyForCategory: number;
+  /** Average unit paid on receipt for this category; omit if unknown. */
+  receiptUnitFloor: number | undefined;
+  /** Current catalog line total (before floors). */
+  liveLineTotal: number;
+}): number {
+  const qty = Math.max(0, input.qty);
+  if (qty <= 0) return 0;
+  const liveUnit = Math.max(0, Number(input.liveLineTotal) || 0) / qty;
+  if (input.receiptUnitFloor == null || !Number.isFinite(input.receiptUnitFloor)) {
+    return Math.max(0, Number(input.liveLineTotal) || 0);
+  }
+  const baselineQty = Math.max(0, input.baselineQtyForCategory);
+  const protectedQty = Math.min(qty, baselineQty);
+  const incrementalQty = Math.max(0, qty - baselineQty);
+  const protectedUnit = Math.max(input.receiptUnitFloor, liveUnit);
+  return protectedQty * protectedUnit + incrementalQty * liveUnit;
+}
+
+/**
+ * One fee row: first `initialTicketCount` passengers use `max(receipt per-person, live per-person)`; rest live only.
+ */
+export function changeFlowFeeLineTotalWithReceiptFloor(input: {
+  totalQuantity: number;
+  initialTicketCount: number;
+  bookedFeePerPerson: number | undefined;
+  liveFeeLineTotal: number;
+}): number {
+  const totalQuantity = Math.max(0, input.totalQuantity);
+  if (totalQuantity <= 0) return Math.max(0, Number(input.liveFeeLineTotal) || 0);
+  const liveTotal = Math.max(0, Number(input.liveFeeLineTotal) || 0);
+  const livePer = liveTotal / totalQuantity;
+  if (input.bookedFeePerPerson == null || !Number.isFinite(input.bookedFeePerPerson)) {
+    return liveTotal;
+  }
+  const protectedP = Math.min(Math.max(0, input.initialTicketCount), totalQuantity);
+  const incrementalP = Math.max(0, totalQuantity - protectedP);
+  const protectedPerPerson = Math.max(input.bookedFeePerPerson, livePer);
+  return protectedP * protectedPerPerson + incrementalP * livePer;
+}
+
+/**
+ * Return add-on: **max(live, receipt floor)** per person (then multiply by party size in BookingFlow).
+ */
+export function changeFlowReturnPerPersonWithReceiptFloor(input: {
+  livePerPerson: number;
+  receiptFloorPerPerson: number | null;
+}): number {
+  const live = Number.isFinite(input.livePerPerson) ? input.livePerPerson : 0;
+  const floor = input.receiptFloorPerPerson;
+  if (floor == null || !Number.isFinite(floor)) return live;
+  return Math.max(live, floor);
+}
+
+/**
+ * Product: **New booking price** for a change is the same cart total as a fresh booking
+ * (subtotal + tax − discounts), in cents. We send that on quotes so it matches line items and the server breakdown.
+ *
+ * If the customer is only “off” from the old receipt by a penny of float/rounding, treat as no change to the rolled-up
+ * total (see `reconcileChangeBookingProposedTotal`).
+ */
+export function resolveChangeFlowNewBookingTotal(input: {
+  isChangeFlow: boolean;
+  /** `effectiveSubtotal + effectiveTax - promo` from the live cart. */
+  cartTotal: number;
+  originalReceiptTotal: number | null | undefined;
+}): number {
+  if (!input.isChangeFlow) {
+    return input.cartTotal;
+  }
+  const rounded = roundMoney(input.cartTotal);
+  if (input.originalReceiptTotal == null) {
+    return input.cartTotal;
+  }
+  return reconcileChangeBookingProposedTotal(rounded, input.originalReceiptTotal);
+}
+
+/**
+ * Product: **What the customer owes** for the difference is `max(0, newTotal − oldReceipt)`.
+ * **Provider dashboard** may show a signed delta (credits/refunds as negative).
+ */
+export function changeFlowBalanceVsOriginal(input: {
+  newTotal: number;
+  originalReceiptTotal: number;
+  /** `customer` = self-serve & admin change; `provider` = provider inline editor (can owe the guest). */
+  audience: 'customer' | 'provider';
+}): number {
+  const delta = input.newTotal - input.originalReceiptTotal;
+  return input.audience === 'provider' ? delta : Math.max(0, delta);
+}
+
+/**
+ * Product: **What we show** in the change-flow price row — either the provider’s manual preview totals, or the same
+ * cart numbers as everywhere else (no second shadow total).
+ */
+export function resolveChangeFlowDisplayedAmounts(input: {
+  providerPreview: {
+    totalAmount: number;
+    subtotalBeforeTax: number;
+    taxAmount: number;
+  } | null;
+  fromCart: { total: number; subtotal: number; tax: number };
+}): { total: number; subtotal: number; tax: number } {
+  if (input.providerPreview) {
+    return {
+      total: input.providerPreview.totalAmount,
+      subtotal: input.providerPreview.subtotalBeforeTax,
+      tax: input.providerPreview.taxAmount,
+    };
+  }
+  return { ...input.fromCart };
+}
+
+/**
+ * Product: **Main “total owed” number** should not show -0.00 or noise when the balance is effectively zero.
+ */
+export function normalizeNearZeroOwed(amount: number): number {
+  const r = roundMoney(amount);
+  return Math.abs(r) < 0.01 ? 0 : r;
+}