@ticketboothapp/booking 1.2.123 → 1.2.125

package/src/components/booking/useChangeBookingPriceSummary.ts

@@ -0,0 +1,199 @@
+import type {
+  AddOn,
+  Availability,
+  PricingConfig,
+  ReturnOption,
+} from '../../lib/booking-api';
+import {
+  resolveChangeFlowNewBookingTotal,
+  type ChangeFlowProtectedReceiptPricing,
+} from '../../lib/booking/change-flow-pricing';
+import type {
+  OrderSummaryFeeLine,
+  OrderSummaryTicketLine,
+  PriceBreakdown as PriceBreakdownData,
+} from '../../lib/booking/pricing';
+import type { ChangeBookingMergedQuoteState } from './change-booking-quote-state';
+import type { ChangeBookingFlowProps } from './booking-flow-types';
+import type { Currency } from './CurrencySwitcher';
+import type { PricingRate } from './change-booking-flow-helpers';
+import { useChangeBookingProtectedPricing } from './useChangeBookingProtectedPricing';
+import { useChangeBookingPromoDiscount } from './useChangeBookingPromoDiscount';
+import { useChangeBookingSummaryLines } from './useChangeBookingSummaryLines';
+
+type AddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+type GetPriceBreakdown = (
+  category: string,
+  priceCAD: number,
+  baseInDisplayCurrency: number | undefined,
+  appliedAdjustments?: Array<{ type: string; id: string; name: string; changeByCurrency?: Record<string, number> }>,
+) => PriceBreakdownData | null;
+
+interface UseChangeBookingPriceSummaryParams {
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  currency: Currency;
+  totalQuantity: number;
+  returnPriceAdjustment: number;
+  isCustomerSelfServeChange: boolean;
+  effectiveChangeFlowReturnUnitFloorPerPerson: number | null | undefined;
+  changeFlowInitialTicketCount: number;
+  changeFlowReturnPricingRuleA: boolean;
+  changeFlowApplyReceiptPaidFloors: boolean;
+  ticketLineItems: OrderSummaryTicketLine[];
+  changeFlowTicketBookedUnitPriceByCategory: Map<string, number>;
+  changeFlowInitialTicketQtyByCategory: Map<string, number>;
+  changeFlowProtectedReceiptPricing: ChangeFlowProtectedReceiptPricing;
+  subtotal: number;
+  feeLineItems: OrderSummaryFeeLine[];
+  changeFlowBookedFeeUnitByNormalizedLabel: Map<string, number>;
+  addOnSelections: AddOnSelection[];
+  addOns: AddOn[];
+  quantities: Record<string, number>;
+  pricing: PricingRate[];
+  getPriceBreakdown: GetPriceBreakdown;
+  cancellationPolicyFee: number;
+  hasSelectedCancellationPolicy: boolean;
+  effectiveCancellationPolicyLabel: string;
+  t: (key: string) => string;
+  appliedPromoCode: string | null;
+  productCompanyId?: string | null;
+  envCompanyId?: string | null;
+  productId: string;
+  lockedPromoCode: string | null;
+  originalReceipt: ChangeBookingFlowProps['originalReceipt'];
+  pricingConfig: PricingConfig | null;
+  isTaxIncludedInPrice: boolean;
+  suppressSelfServeCurrencyUi: boolean;
+  selfServePricingConfirmed: boolean;
+  latestChangeQuote: ChangeBookingMergedQuoteState | null;
+}
+
+export function useChangeBookingPriceSummary({
+  selectedAvailability,
+  selectedReturnOption,
+  currency,
+  totalQuantity,
+  returnPriceAdjustment,
+  isCustomerSelfServeChange,
+  effectiveChangeFlowReturnUnitFloorPerPerson,
+  changeFlowInitialTicketCount,
+  changeFlowReturnPricingRuleA,
+  changeFlowApplyReceiptPaidFloors,
+  ticketLineItems,
+  changeFlowTicketBookedUnitPriceByCategory,
+  changeFlowInitialTicketQtyByCategory,
+  changeFlowProtectedReceiptPricing,
+  subtotal,
+  feeLineItems,
+  changeFlowBookedFeeUnitByNormalizedLabel,
+  addOnSelections,
+  addOns,
+  quantities,
+  pricing,
+  getPriceBreakdown,
+  cancellationPolicyFee,
+  hasSelectedCancellationPolicy,
+  effectiveCancellationPolicyLabel,
+  t,
+  appliedPromoCode,
+  productCompanyId,
+  envCompanyId,
+  productId,
+  lockedPromoCode,
+  originalReceipt,
+  pricingConfig,
+  isTaxIncludedInPrice,
+  suppressSelfServeCurrencyUi,
+  selfServePricingConfirmed,
+  latestChangeQuote,
+}: UseChangeBookingPriceSummaryParams) {
+  const {
+    checkoutReturnLineAmount,
+    ticketLineItemsForChangeFlowDisplay,
+    effectiveSubtotal,
+    feeLineItemsWithAddOns,
+  } = useChangeBookingProtectedPricing({
+    selectedAvailability,
+    selectedReturnOption,
+    currency,
+    totalQuantity,
+    returnPriceAdjustment,
+    isCustomerSelfServeChange,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    changeFlowInitialTicketCount,
+    changeFlowReturnPricingRuleA,
+    changeFlowApplyReceiptPaidFloors,
+    ticketLineItems,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowProtectedReceiptPricing,
+    subtotal,
+    feeLineItems,
+    changeFlowBookedFeeUnitByNormalizedLabel,
+    addOnSelections,
+    addOns,
+  });
+
+  const {
+    effectivePromoDiscountAmount,
+    effectiveTax,
+    totalPrice,
+  } = useChangeBookingPromoDiscount({
+    appliedPromoCode,
+    selectedAvailability,
+    totalQuantity,
+    productCompanyId,
+    envCompanyId,
+    productId,
+    currency,
+    quantities,
+    ticketLineItemsForChangeFlowDisplay,
+    feeLineItems,
+    effectiveSubtotal,
+    lockedPromoCode,
+    originalReceipt,
+    isTaxIncludedInPrice,
+    pricingConfig,
+  });
+
+  const {
+    checkoutPriceSummaryLinesForCheckout,
+    priceSummaryLinesIncludeTaxRow,
+  } = useChangeBookingSummaryLines({
+    selectedAvailability,
+    selectedReturnOption,
+    ticketLineItemsForChangeFlowDisplay,
+    pricing,
+    getPriceBreakdown,
+    checkoutReturnLineAmount,
+    totalQuantity,
+    t,
+    cancellationPolicyFee,
+    hasSelectedCancellationPolicy,
+    effectiveCancellationPolicyLabel,
+    feeLineItemsWithAddOns,
+    feeLineItems,
+    suppressSelfServeCurrencyUi,
+    selfServePricingConfirmed,
+    latestServerPriceSummaryLines: latestChangeQuote?.serverPreview?.priceSummaryLines,
+    quantities,
+  });
+
+  const changeFlowNewBookingTotal = resolveChangeFlowNewBookingTotal({
+    cartTotal: totalPrice,
+    originalReceiptTotal: originalReceipt?.total,
+  });
+
+  return {
+    checkoutReturnLineAmount,
+    effectiveSubtotal,
+    feeLineItemsWithAddOns,
+    checkoutPriceSummaryLinesForCheckout,
+    priceSummaryLinesIncludeTaxRow,
+    effectivePromoDiscountAmount,
+    effectiveTax,
+    totalPrice,
+    changeFlowNewBookingTotal,
+  };
+}

package/src/components/booking/useChangeBookingPromoDiscount.ts

@@ -0,0 +1,218 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import {
+  getPromoDiscount,
+  type Availability,
+  type PricingConfig,
+} from '../../lib/booking-api';
+import type { OrderSummaryFeeLine, OrderSummaryTicketLine } from '../../lib/booking/pricing';
+import type { ChangeBookingFlowProps } from './booking-flow-types';
+import type { Currency } from './CurrencySwitcher';
+import { getAvailabilityOptionId } from './change-booking-flow-helpers';
+
+interface UseChangeBookingPromoDiscountParams {
+  appliedPromoCode: string | null;
+  selectedAvailability: Availability | null;
+  totalQuantity: number;
+  productCompanyId?: string | null;
+  envCompanyId?: string | null;
+  productId: string;
+  currency: Currency;
+  quantities: Record<string, number>;
+  ticketLineItemsForChangeFlowDisplay: OrderSummaryTicketLine[];
+  feeLineItems: OrderSummaryFeeLine[];
+  effectiveSubtotal: number;
+  lockedPromoCode: string | null;
+  originalReceipt: ChangeBookingFlowProps['originalReceipt'];
+  isTaxIncludedInPrice: boolean;
+  pricingConfig: PricingConfig | null;
+}
+
+export function useChangeBookingPromoDiscount({
+  appliedPromoCode,
+  selectedAvailability,
+  totalQuantity,
+  productCompanyId,
+  envCompanyId,
+  productId,
+  currency,
+  quantities,
+  ticketLineItemsForChangeFlowDisplay,
+  feeLineItems,
+  effectiveSubtotal,
+  lockedPromoCode,
+  originalReceipt,
+  isTaxIncludedInPrice,
+  pricingConfig,
+}: UseChangeBookingPromoDiscountParams) {
+  const quantitiesSignature = useMemo(
+    () =>
+      Object.entries(quantities)
+        .filter(([, n]) => (n ?? 0) > 0)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([c, n]) => `${c}:${n}`)
+        .join('|'),
+    [quantities],
+  );
+
+  const [promoDiscountAmount, setPromoDiscountAmount] = useState(0);
+  const [isGiftCard, setIsGiftCard] = useState(false);
+  const [isVoucher, setIsVoucher] = useState(false);
+  const promoDiscountFetchGenerationRef = useRef(0);
+  const promoDiscountParamsRef = useRef({
+    selectedAvailability: null as Availability | null,
+    ticketLineItems: [] as Array<{ category: string; qty: number; itemTotal: number }>,
+    effectiveSubtotal: 0,
+    displayedProductFeeTotal: 0,
+    appliedPromoCode: null as string | null,
+    changeBookingPromo: null as { priorAmount?: number } | null,
+  });
+
+  const selectedAvailabilityOptionId = useMemo(
+    () => (selectedAvailability ? getAvailabilityOptionId(selectedAvailability) : ''),
+    [selectedAvailability],
+  );
+
+  const promoDiscountFetchKey = useMemo(() => {
+    if (!appliedPromoCode || !selectedAvailability || totalQuantity === 0) return '';
+    const companyId = productCompanyId ?? envCompanyId;
+    if (!companyId) return '';
+    if (!selectedAvailabilityOptionId || !quantitiesSignature) return '';
+    return [
+      appliedPromoCode,
+      companyId,
+      productId,
+      selectedAvailabilityOptionId,
+      selectedAvailability.dateTime,
+      selectedAvailability.availabilityId ?? '',
+      currency,
+      quantitiesSignature,
+      ticketLineItemsForChangeFlowDisplay
+        .map((line) => `${line.category}:${line.qty}:${Math.round(line.itemTotal * 100)}`)
+        .sort()
+        .join('|'),
+      String(Math.round(feeLineItems.reduce((sum, fee) => sum + fee.totalAmount, 0) * 100)),
+      String(Math.round(effectiveSubtotal * 100)),
+      lockedPromoCode ? String(Math.round((originalReceipt?.promoAmount ?? 0) * 100)) : '',
+    ].join('::');
+  }, [
+    appliedPromoCode,
+    selectedAvailability,
+    selectedAvailabilityOptionId,
+    totalQuantity,
+    productCompanyId,
+    envCompanyId,
+    productId,
+    currency,
+    quantitiesSignature,
+    ticketLineItemsForChangeFlowDisplay,
+    feeLineItems,
+    effectiveSubtotal,
+    lockedPromoCode,
+    originalReceipt?.promoAmount,
+  ]);
+
+  promoDiscountParamsRef.current = {
+    selectedAvailability,
+    ticketLineItems: ticketLineItemsForChangeFlowDisplay.map((line) => ({
+      category: line.category,
+      qty: line.qty,
+      itemTotal: line.itemTotal,
+    })),
+    effectiveSubtotal,
+    displayedProductFeeTotal: feeLineItems.reduce((sum, fee) => sum + fee.totalAmount, 0),
+    appliedPromoCode,
+    changeBookingPromo: lockedPromoCode
+      ? { priorAmount: originalReceipt?.promoAmount }
+      : null,
+  };
+
+  useEffect(() => {
+    if (!promoDiscountFetchKey) {
+      setPromoDiscountAmount(0);
+      setIsGiftCard(false);
+      setIsVoucher(false);
+      return;
+    }
+
+    let cancelled = false;
+    const debounceMs = 120;
+    const timer = window.setTimeout(() => {
+      if (cancelled) return;
+      const {
+        selectedAvailability: sel,
+        ticketLineItems: lines,
+        effectiveSubtotal: sub,
+        displayedProductFeeTotal,
+        appliedPromoCode: code,
+        changeBookingPromo,
+      } = promoDiscountParamsRef.current;
+      if (!code || !sel) return;
+      const companyId = productCompanyId ?? envCompanyId;
+      const optionId = getAvailabilityOptionId(sel);
+      if (!companyId || !optionId) return;
+      const items = lines.map((line) => ({ category: line.category, qty: line.qty }));
+      if (items.length === 0) return;
+
+      const generation = ++promoDiscountFetchGenerationRef.current;
+      getPromoDiscount(
+        code,
+        companyId,
+        productId,
+        optionId,
+        currency,
+        items,
+        sel.dateTime,
+        sub,
+        changeBookingPromo
+          ? {
+              forBookingChange: true,
+              priorPromoDiscountAmount: changeBookingPromo.priorAmount,
+              displayedTicketLines: lines,
+              displayedProductFeeTotal,
+            }
+          : {
+              displayedTicketLines: lines,
+              displayedProductFeeTotal,
+            },
+      )
+        .then((res) => {
+          if (cancelled) return;
+          if (generation !== promoDiscountFetchGenerationRef.current) return;
+          setPromoDiscountAmount(res.discount ?? 0);
+          setIsGiftCard(res.isGiftCard ?? false);
+          setIsVoucher(res.isVoucher ?? false);
+        })
+        .catch(() => {
+          if (cancelled) return;
+          if (generation !== promoDiscountFetchGenerationRef.current) return;
+          setPromoDiscountAmount(0);
+          setIsGiftCard(false);
+          setIsVoucher(false);
+        });
+    }, debounceMs);
+
+    return () => {
+      cancelled = true;
+      window.clearTimeout(timer);
+    };
+  }, [promoDiscountFetchKey, productCompanyId, envCompanyId, productId, currency]);
+
+  const lockedPromoFallbackAmount =
+    lockedPromoCode
+      ? Math.max(0, originalReceipt?.promoAmount ?? 0)
+      : 0;
+  const effectivePromoDiscountAmount =
+    promoDiscountAmount > 0 ? promoDiscountAmount : lockedPromoFallbackAmount;
+  const taxOnSubtotal = isTaxIncludedInPrice ? 0 : effectiveSubtotal * (pricingConfig?.taxRate ?? 0);
+  const effectiveTax =
+    effectivePromoDiscountAmount > 0 && !isGiftCard && !isVoucher
+      ? (effectiveSubtotal - effectivePromoDiscountAmount) * (pricingConfig?.taxRate ?? 0)
+      : taxOnSubtotal;
+  const totalPrice = effectiveSubtotal + effectiveTax - effectivePromoDiscountAmount;
+
+  return {
+    effectivePromoDiscountAmount,
+    effectiveTax,
+    totalPrice,
+  };
+}

package/src/components/booking/useChangeBookingProtectedPricing.ts

@@ -0,0 +1,256 @@
+import { useMemo } from 'react';
+import type { AddOn, Availability, ReturnOption } from '../../lib/booking-api';
+import {
+  changeFlowFeeLineTotalWithReceiptFloor,
+  changeFlowReturnLineTotalWithReceiptFloor,
+  changeFlowTicketLineTotalWithReceiptFloor,
+  type ChangeFlowProtectedReceiptPricing,
+} from '../../lib/booking/change-flow-pricing';
+import type {
+  OrderSummaryFeeLine,
+  OrderSummaryTicketLine,
+} from '../../lib/booking/pricing';
+import type { Currency } from './CurrencySwitcher';
+import { normalizeLineLabelForCompare } from './change-booking-flow-helpers';
+
+type AddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+
+interface UseChangeBookingProtectedPricingParams {
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  currency: Currency;
+  totalQuantity: number;
+  returnPriceAdjustment: number;
+  isCustomerSelfServeChange: boolean;
+  effectiveChangeFlowReturnUnitFloorPerPerson: number | null | undefined;
+  changeFlowInitialTicketCount: number;
+  changeFlowReturnPricingRuleA: boolean;
+  changeFlowApplyReceiptPaidFloors: boolean;
+  ticketLineItems: OrderSummaryTicketLine[];
+  changeFlowTicketBookedUnitPriceByCategory: Map<string, number>;
+  changeFlowInitialTicketQtyByCategory: Map<string, number>;
+  changeFlowProtectedReceiptPricing: ChangeFlowProtectedReceiptPricing;
+  subtotal: number;
+  feeLineItems: OrderSummaryFeeLine[];
+  changeFlowBookedFeeUnitByNormalizedLabel: Map<string, number>;
+  addOnSelections: AddOnSelection[];
+  addOns: AddOn[];
+}
+
+export function useChangeBookingProtectedPricing({
+  selectedAvailability,
+  selectedReturnOption,
+  currency,
+  totalQuantity,
+  returnPriceAdjustment,
+  isCustomerSelfServeChange,
+  effectiveChangeFlowReturnUnitFloorPerPerson,
+  changeFlowInitialTicketCount,
+  changeFlowReturnPricingRuleA,
+  changeFlowApplyReceiptPaidFloors,
+  ticketLineItems,
+  changeFlowTicketBookedUnitPriceByCategory,
+  changeFlowInitialTicketQtyByCategory,
+  changeFlowProtectedReceiptPricing,
+  subtotal,
+  feeLineItems,
+  changeFlowBookedFeeUnitByNormalizedLabel,
+  addOnSelections,
+  addOns,
+}: UseChangeBookingProtectedPricingParams) {
+  const changeFlowProtectedTicketSubtotal = useMemo(() => {
+    const currentTicketSubtotal = ticketLineItems.reduce(
+      (sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0),
+      0,
+    );
+    if (!changeFlowApplyReceiptPaidFloors) return currentTicketSubtotal;
+    return ticketLineItems.reduce((sum, line) => {
+      const category = line.category?.trim().toUpperCase();
+      const qty = Math.max(0, Number(line.qty) || 0);
+      if (!category || qty <= 0) return sum;
+      return (
+        sum +
+        changeFlowTicketLineTotalWithReceiptFloor({
+          qty,
+          baselineQtyForCategory: changeFlowInitialTicketQtyByCategory.get(category) ?? 0,
+          receiptUnitFloor: changeFlowTicketBookedUnitPriceByCategory.get(category),
+          liveLineTotal: Number(line.itemTotal) || 0,
+          protectedReceiptPricing: changeFlowProtectedReceiptPricing,
+        })
+      );
+    }, 0);
+  }, [
+    changeFlowApplyReceiptPaidFloors,
+    ticketLineItems,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowProtectedReceiptPricing,
+  ]);
+
+  const addOnTotal = useMemo(() => {
+    let sum = 0;
+    for (const sel of addOnSelections) {
+      const addOn = addOns.find((a) => a.addOnId === sel.addOnId);
+      if (!addOn) continue;
+      const basePrice = addOn.price ?? 0;
+      const hasVariant =
+        (addOn.variantType === 'single_choice' || addOn.variantType === 'multi_quantity') &&
+        sel.variantId;
+      const variantAdjustment = hasVariant
+        ? (addOn.variants?.find((v) => v.id === sel.variantId)?.priceAdjustment ?? 0)
+        : 0;
+      sum += (basePrice + variantAdjustment) * (sel.quantity ?? 1);
+    }
+    return sum;
+  }, [addOnSelections, addOns]);
+
+  const currentTicketSubtotal = useMemo(
+    () => ticketLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0), 0),
+    [ticketLineItems],
+  );
+
+  const currentFeeSubtotal = useMemo(
+    () => feeLineItems.reduce((sum, line) => sum + Math.max(0, Number(line.totalAmount) || 0), 0),
+    [feeLineItems],
+  );
+
+  const changeFlowProtectedFeeSubtotal = useMemo(() => {
+    if (!changeFlowApplyReceiptPaidFloors || totalQuantity <= 0) return currentFeeSubtotal;
+    const initialParty = changeFlowInitialTicketCount;
+    return feeLineItems.reduce((sum, line) => {
+      const key = normalizeLineLabelForCompare(line.name || '');
+      const bookedFeePerPerson = key ? changeFlowBookedFeeUnitByNormalizedLabel.get(key) : undefined;
+      return (
+        sum +
+        changeFlowFeeLineTotalWithReceiptFloor({
+          totalQuantity,
+          initialTicketCount: initialParty,
+          bookedFeePerPerson,
+          liveFeeLineTotal: Number(line.totalAmount) || 0,
+          protectedReceiptPricing: changeFlowProtectedReceiptPricing,
+        })
+      );
+    }, 0);
+  }, [
+    changeFlowApplyReceiptPaidFloors,
+    totalQuantity,
+    currentFeeSubtotal,
+    feeLineItems,
+    changeFlowBookedFeeUnitByNormalizedLabel,
+    changeFlowInitialTicketCount,
+    changeFlowProtectedReceiptPricing,
+  ]);
+
+  const returnOptionCatalogPerPerson = useMemo(() => {
+    if (!selectedReturnOption?.returnAvailabilityId || !selectedAvailability?.returnOptions?.length) {
+      return null;
+    }
+    const raw = selectedAvailability.returnOptions.find(
+      (o) => o.returnAvailabilityId === selectedReturnOption.returnAvailabilityId,
+    );
+    const v = raw?.priceAdjustmentByCurrency?.[currency];
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+  }, [selectedReturnOption?.returnAvailabilityId, selectedAvailability?.returnOptions, currency]);
+
+  const changeFlowProtectedReturnAdjustment = useMemo(() => {
+    if (totalQuantity <= 0) return returnPriceAdjustment;
+    if (effectiveChangeFlowReturnUnitFloorPerPerson == null) return returnPriceAdjustment;
+    const livePerPerson =
+      returnOptionCatalogPerPerson ?? (selectedReturnOption?.priceAdjustmentByCurrency?.[currency] ?? 0);
+    return changeFlowReturnLineTotalWithReceiptFloor({
+      totalPersons: totalQuantity,
+      baselineParty: changeFlowInitialTicketCount,
+      livePerPerson,
+      receiptFloorPerPerson: effectiveChangeFlowReturnUnitFloorPerPerson,
+      returnRuleA: changeFlowReturnPricingRuleA,
+    });
+  }, [
+    totalQuantity,
+    returnPriceAdjustment,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    selectedReturnOption,
+    returnOptionCatalogPerPerson,
+    currency,
+    changeFlowInitialTicketCount,
+    changeFlowReturnPricingRuleA,
+  ]);
+
+  const checkoutReturnLineAmount = useMemo(() => {
+    if (isCustomerSelfServeChange) return changeFlowProtectedReturnAdjustment;
+    if (changeFlowApplyReceiptPaidFloors) return changeFlowProtectedReturnAdjustment;
+    return returnPriceAdjustment;
+  }, [
+    isCustomerSelfServeChange,
+    changeFlowApplyReceiptPaidFloors,
+    changeFlowProtectedReturnAdjustment,
+    returnPriceAdjustment,
+  ]);
+
+  const ticketLineItemsForChangeFlowDisplay = useMemo(() => {
+    if (!changeFlowApplyReceiptPaidFloors) return ticketLineItems;
+    return ticketLineItems.map((line) => {
+      const category = line.category?.trim().toUpperCase();
+      const qty = Math.max(0, Number(line.qty) || 0);
+      if (!category || qty <= 0) return line;
+      const newTotal = changeFlowTicketLineTotalWithReceiptFloor({
+        qty,
+        baselineQtyForCategory: changeFlowInitialTicketQtyByCategory.get(category) ?? 0,
+        receiptUnitFloor: changeFlowTicketBookedUnitPriceByCategory.get(category),
+        liveLineTotal: Number(line.itemTotal) || 0,
+        protectedReceiptPricing: changeFlowProtectedReceiptPricing,
+      });
+      return { ...line, itemTotal: newTotal };
+    });
+  }, [
+    changeFlowApplyReceiptPaidFloors,
+    ticketLineItems,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowProtectedReceiptPricing,
+  ]);
+
+  const effectiveSubtotalBeforeAddOns =
+    changeFlowApplyReceiptPaidFloors
+      ? subtotal -
+        currentTicketSubtotal -
+        currentFeeSubtotal -
+        returnPriceAdjustment +
+        changeFlowProtectedTicketSubtotal +
+        changeFlowProtectedFeeSubtotal +
+        changeFlowProtectedReturnAdjustment
+      : subtotal;
+  const effectiveSubtotal = effectiveSubtotalBeforeAddOns + addOnTotal;
+
+  const feeLineItemsWithAddOns = useMemo(() => {
+    const addOnLines = addOnSelections
+      .map((sel) => {
+        const addOn = addOns.find((a) => a.addOnId === sel.addOnId);
+        if (!addOn) return null;
+        const base = addOn.price ?? 0;
+        const hasVariant =
+          (addOn.variantType === 'single_choice' || addOn.variantType === 'multi_quantity') &&
+          sel.variantId;
+        const adj = hasVariant
+          ? (addOn.variants?.find((v) => v.id === sel.variantId)?.priceAdjustment ?? 0)
+          : 0;
+        const qty = sel.quantity ?? 1;
+        const amt = (base + adj) * qty;
+        const variantLabel = hasVariant
+          ? addOn.variants?.find((v) => v.id === sel.variantId)?.label
+          : null;
+        const name = variantLabel
+          ? `${addOn.name} (${variantLabel})${qty > 1 ? ` \u00d7 ${qty}` : ''}`
+          : addOn.name;
+        return { name, totalAmount: amt, description: addOn.description ?? undefined };
+      })
+      .filter((x): x is NonNullable<typeof x> => x != null);
+    return [...feeLineItems, ...addOnLines];
+  }, [feeLineItems, addOnSelections, addOns]);
+
+  return {
+    checkoutReturnLineAmount,
+    ticketLineItemsForChangeFlowDisplay,
+    effectiveSubtotal,
+    feeLineItemsWithAddOns,
+  };
+}