@ticketboothapp/booking 1.2.123 → 1.2.124

package/src/components/booking/useStandardBookingPriceSummary.ts

@@ -0,0 +1,438 @@
+import { useCallback, useMemo } from 'react';
+import type {
+  AddOn,
+  Availability,
+  ItineraryDisplayStep,
+  PrecomputedPricesByCategory,
+  PricingConfig,
+  Product,
+  ReturnOption,
+} from '../../lib/booking-api';
+import {
+  computeOrderSummary,
+  computePriceBreakdown,
+  type PriceBreakdown as PriceBreakdownData,
+} from '../../lib/booking/pricing';
+import type {
+  BookingFlowPriceSummaryAugmentation,
+  NewBookingFlowProps,
+} from './booking-flow-types';
+import type { Currency } from './CurrencySwitcher';
+import type { PriceSummaryLine } from './PriceSummary';
+import {
+  buildPricingFromAvailability,
+  getAvailabilityOptionId,
+} from './standard-booking-availability';
+import { useStandardBookingPromoDiscount } from './useStandardBookingPromoDiscount';
+
+type AddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+type AppliedAdjustment = {
+  type: string;
+  id: string;
+  name: string;
+  changeByCurrency?: Record<string, number>;
+};
+type ForcedCancellationPolicy = {
+  id: string;
+  label: string;
+  refundTiers?: Array<{ hoursBefore: number; refundPercent: number }>;
+  changeWindowHoursBefore?: number | null;
+} | null;
+
+interface UseStandardBookingPriceSummaryParams {
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  activeOptions: Product['options'];
+  precomputedPricesByOption: Record<string, PrecomputedPricesByCategory> | null | undefined;
+  currency: Currency;
+  pricingConfig: PricingConfig | null;
+  isSimplifiedPricingView: boolean;
+  quantities: Record<string, number>;
+  cancellationPolicyId: string | null;
+  forcedCancellationPolicy: ForcedCancellationPolicy;
+  addOnSelections: AddOnSelection[];
+  addOns: AddOn[];
+  t: (key: string) => string;
+  appliedPromoCode: string | null;
+  productCompanyId?: string | null;
+  envCompanyId?: string | null;
+  productId: string;
+  selectedDate: string;
+  computeItineraryDisplay: () => ItineraryDisplayStep[] | null;
+  augmentPriceSummary?: NewBookingFlowProps['augmentPriceSummary'];
+}
+
+export function useStandardBookingPriceSummary({
+  selectedAvailability,
+  selectedReturnOption,
+  activeOptions,
+  precomputedPricesByOption,
+  currency,
+  pricingConfig,
+  isSimplifiedPricingView,
+  quantities,
+  cancellationPolicyId,
+  forcedCancellationPolicy,
+  addOnSelections,
+  addOns,
+  t,
+  appliedPromoCode,
+  productCompanyId,
+  envCompanyId,
+  productId,
+  selectedDate,
+  computeItineraryDisplay,
+  augmentPriceSummary,
+}: UseStandardBookingPriceSummaryParams) {
+  const hasFees = useMemo(
+    () =>
+      Boolean(
+        pricingConfig?.fees &&
+          Object.keys(pricingConfig.fees).length > 0 &&
+          Object.values(pricingConfig.fees).some((value) => (value?.feePerPerson ?? 0) > 0),
+      ),
+    [pricingConfig?.fees],
+  );
+
+  const returnOptionsWithFloor = useMemo(
+    () => selectedAvailability?.returnOptions ?? [],
+    [selectedAvailability?.returnOptions],
+  );
+
+  const selectedReturnOptionWithFloor = selectedReturnOption;
+  const returnOptionForOrderSummary = selectedReturnOptionWithFloor;
+
+  const effectiveSelectedPickupVacancies = useMemo(() => {
+    if (!selectedAvailability) return 0;
+    return Math.max(0, selectedAvailability.vacancies ?? 0);
+  }, [selectedAvailability]);
+
+  const effectiveSelectedReturnVacancies = useMemo(() => {
+    if (!selectedReturnOption) return null;
+    return Math.max(0, selectedReturnOption.vacancies ?? 0);
+  }, [selectedReturnOption]);
+
+  const pricing = useMemo(
+    () =>
+      buildPricingFromAvailability(
+        selectedAvailability,
+        activeOptions,
+        precomputedPricesByOption,
+        currency,
+        pricingConfig,
+        hasFees,
+        isSimplifiedPricingView,
+      ),
+    [
+      selectedAvailability,
+      activeOptions,
+      precomputedPricesByOption,
+      currency,
+      pricingConfig,
+      hasFees,
+      isSimplifiedPricingView,
+    ],
+  );
+
+  const getPriceBreakdown = useCallback(
+    (
+      category: string,
+      priceCAD: number,
+      baseInDisplayCurrency: number | undefined,
+      appliedAdjustments: AppliedAdjustment[] = [],
+    ): PriceBreakdownData | null => {
+      if (!pricingConfig) return null;
+      const selectedOption = activeOptions.find(
+        (option) =>
+          option.optionId ===
+          (selectedAvailability ? getAvailabilityOptionId(selectedAvailability) : ''),
+      );
+      const basePriceCAD = selectedOption?.pricing?.[category.toUpperCase()] ?? 0;
+      return computePriceBreakdown(
+        pricingConfig,
+        currency,
+        priceCAD,
+        basePriceCAD,
+        hasFees,
+        appliedAdjustments,
+        undefined,
+        baseInDisplayCurrency,
+        isSimplifiedPricingView,
+      );
+    },
+    [pricingConfig, activeOptions, selectedAvailability, currency, hasFees, isSimplifiedPricingView],
+  );
+
+  const orderSummary = useMemo(
+    () =>
+      computeOrderSummary(
+        quantities,
+        pricing,
+        returnOptionForOrderSummary,
+        pricingConfig ?? null,
+        currency,
+        hasFees,
+        cancellationPolicyId,
+      ),
+    [
+      quantities,
+      pricing,
+      returnOptionForOrderSummary,
+      pricingConfig,
+      currency,
+      hasFees,
+      cancellationPolicyId,
+    ],
+  );
+
+  const {
+    totalQuantity,
+    subtotal,
+    tax,
+    total: totalFromSummary,
+    feeLineItems,
+    returnPriceAdjustment,
+    cancellationPolicyFee,
+    isTaxIncludedInPrice,
+    ticketLineItems,
+  } = orderSummary;
+
+  const effectivePartySizeCap = useMemo(() => {
+    if (!selectedAvailability) return 0;
+    const outbound = Math.max(0, selectedAvailability.vacancies ?? 0);
+    if (selectedReturnOption == null) return outbound;
+    const returnCap = Math.max(0, selectedReturnOption.vacancies ?? 0);
+    return Math.min(outbound, returnCap);
+  }, [selectedAvailability, selectedReturnOption]);
+
+  const selectedCancellationPolicy = useMemo(
+    () => pricingConfig?.cancellationPolicies?.find((policy) => policy.id === cancellationPolicyId),
+    [pricingConfig?.cancellationPolicies, cancellationPolicyId],
+  );
+
+  const effectiveCancellationPolicyLabel =
+    selectedCancellationPolicy?.label ??
+    forcedCancellationPolicy?.label ??
+    (t('booking.flexibleCancellation') || 'Flexible cancellation');
+
+  const addOnTotal = useMemo(() => {
+    let sum = 0;
+    for (const selection of addOnSelections) {
+      const addOn = addOns.find((candidate) => candidate.addOnId === selection.addOnId);
+      if (!addOn) continue;
+      const basePrice = addOn.price ?? 0;
+      const hasVariant =
+        (addOn.variantType === 'single_choice' || addOn.variantType === 'multi_quantity') &&
+        selection.variantId;
+      const variantAdjustment = hasVariant
+        ? (addOn.variants?.find((variant) => variant.id === selection.variantId)?.priceAdjustment ?? 0)
+        : 0;
+      sum += (basePrice + variantAdjustment) * (selection.quantity ?? 1);
+    }
+    return sum;
+  }, [addOnSelections, addOns]);
+
+  const checkoutReturnLineAmount = returnPriceAdjustment;
+  const effectiveSubtotalBeforeAddOns = subtotal;
+  const effectiveSubtotal = effectiveSubtotalBeforeAddOns + addOnTotal;
+
+  const feeLineItemsWithAddOns = useMemo(() => {
+    const addOnLines = addOnSelections
+      .map((selection) => {
+        const addOn = addOns.find((candidate) => candidate.addOnId === selection.addOnId);
+        if (!addOn) return null;
+        const base = addOn.price ?? 0;
+        const hasVariant =
+          (addOn.variantType === 'single_choice' || addOn.variantType === 'multi_quantity') &&
+          selection.variantId;
+        const adjustment = hasVariant
+          ? (addOn.variants?.find((variant) => variant.id === selection.variantId)?.priceAdjustment ?? 0)
+          : 0;
+        const quantity = selection.quantity ?? 1;
+        const amount = (base + adjustment) * quantity;
+        const variantLabel = hasVariant
+          ? addOn.variants?.find((variant) => variant.id === selection.variantId)?.label
+          : null;
+        const name = variantLabel
+          ? `${addOn.name} (${variantLabel})${quantity > 1 ? ` \u00d7 ${quantity}` : ''}`
+          : addOn.name;
+        return { name, totalAmount: amount, description: addOn.description ?? undefined };
+      })
+      .filter((line): line is NonNullable<typeof line> => line != null);
+    return [...feeLineItems, ...addOnLines];
+  }, [feeLineItems, addOnSelections, addOns]);
+
+  const checkoutPriceSummaryLines = useMemo((): PriceSummaryLine[] => {
+    if (!selectedAvailability) return [];
+    const returnLineAmount = checkoutReturnLineAmount;
+    const showReturnLine =
+      Boolean(selectedReturnOption) && Math.abs(returnLineAmount) > 0.0005;
+    return [
+      ...ticketLineItems.map((line): PriceSummaryLine => {
+        const rate = pricing.find((candidate) => candidate.category === line.category);
+        const breakdown = getPriceBreakdown(
+          line.category,
+          rate?.priceCAD ?? 0,
+          rate?.baseInDisplayCurrency,
+          rate?.appliedAdjustments ?? [],
+        );
+        return {
+          kind: 'ticket',
+          category: line.category,
+          qty: line.qty,
+          itemTotal: line.itemTotal,
+          breakdown,
+        };
+      }),
+      ...(showReturnLine
+        ? [
+            {
+              kind: 'line' as const,
+              label: `${t('booking.returnOption')} (${totalQuantity} ${
+                totalQuantity === 1 ? 'person' : 'people'
+              })`,
+              amount: returnLineAmount,
+              type: 'return',
+            },
+          ]
+        : []),
+      ...(cancellationPolicyFee > 0 && (selectedCancellationPolicy || forcedCancellationPolicy)
+        ? [
+            {
+              kind: 'line' as const,
+              label: effectiveCancellationPolicyLabel,
+              amount: cancellationPolicyFee,
+              type: 'cancellation',
+            },
+          ]
+        : []),
+      ...feeLineItemsWithAddOns.map((fee) => {
+        const normalizedName = fee.name.toLowerCase();
+        const isMoraineLakeRoadAccessFee =
+          normalizedName.includes('moraine') &&
+          (normalizedName.includes('access') ||
+            normalizedName.includes('road') ||
+            normalizedName.includes('license'));
+        return {
+          kind: 'line' as const,
+          label: feeLineItems.some((candidate) => candidate.name === fee.name)
+            ? `${fee.name} (${totalQuantity} ${totalQuantity === 1 ? 'person' : 'people'})`
+            : fee.name,
+          amount: fee.totalAmount,
+          type: 'fee',
+          tooltip: isMoraineLakeRoadAccessFee
+            ? "Since 2025, Parks Canada charges a per-trip fee for License of Occupation. Based on our capacity, this per-person fee contributes towards Parks Canada's Moraine Lake Road operations."
+            : undefined,
+        };
+      }),
+    ];
+  }, [
+    selectedAvailability,
+    selectedReturnOption,
+    checkoutReturnLineAmount,
+    ticketLineItems,
+    pricing,
+    getPriceBreakdown,
+    t,
+    totalQuantity,
+    cancellationPolicyFee,
+    selectedCancellationPolicy,
+    forcedCancellationPolicy,
+    effectiveCancellationPolicyLabel,
+    feeLineItemsWithAddOns,
+    feeLineItems,
+  ]);
+
+  const {
+    promoDiscountAmount,
+    isGiftCard,
+    isVoucher,
+    effectivePromoDiscountAmount,
+    effectiveTax,
+    totalPrice,
+  } = useStandardBookingPromoDiscount({
+    appliedPromoCode,
+    selectedAvailability,
+    totalQuantity,
+    productCompanyId,
+    envCompanyId,
+    productId,
+    currency,
+    quantities,
+    ticketLineItems,
+    feeLineItems,
+    effectiveSubtotal,
+    isTaxIncludedInPrice,
+    pricingConfig,
+  });
+
+  const priceSummaryAugmentation = useMemo<BookingFlowPriceSummaryAugmentation | null>(
+    () =>
+      augmentPriceSummary
+        ? augmentPriceSummary({
+            selectedDate: selectedDate || null,
+            selectedAvailability,
+            itineraryItems: computeItineraryDisplay(),
+            priceSummaryLines: checkoutPriceSummaryLines,
+            subtotal: effectiveSubtotal,
+            tax: effectivePromoDiscountAmount > 0 ? effectiveTax : tax,
+            total: totalPrice,
+            currency,
+          })
+        : null,
+    [
+      augmentPriceSummary,
+      selectedDate,
+      selectedAvailability,
+      computeItineraryDisplay,
+      checkoutPriceSummaryLines,
+      effectiveSubtotal,
+      effectivePromoDiscountAmount,
+      effectiveTax,
+      tax,
+      totalPrice,
+      currency,
+    ],
+  );
+
+  const displayCheckoutPriceSummaryLines =
+    priceSummaryAugmentation?.lines ?? checkoutPriceSummaryLines;
+  const displaySubtotal =
+    effectiveSubtotal + (priceSummaryAugmentation?.subtotalAdjustment ?? 0);
+  const displayTotalPrice =
+    totalPrice + (priceSummaryAugmentation?.totalAdjustment ?? 0);
+
+  return {
+    returnOptionsWithFloor,
+    selectedReturnOptionWithFloor,
+    effectiveSelectedPickupVacancies,
+    effectiveSelectedReturnVacancies,
+    pricing,
+    getPriceBreakdown,
+    totalQuantity,
+    subtotal,
+    tax,
+    totalFromSummary,
+    feeLineItems,
+    cancellationPolicyFee,
+    isTaxIncludedInPrice,
+    ticketLineItems,
+    effectivePartySizeCap,
+    effectiveCancellationPolicyLabel,
+    addOnTotal,
+    checkoutReturnLineAmount,
+    effectiveSubtotal,
+    feeLineItemsWithAddOns,
+    checkoutPriceSummaryLines,
+    promoDiscountAmount,
+    isGiftCard,
+    isVoucher,
+    effectivePromoDiscountAmount,
+    effectiveTax,
+    totalPrice,
+    priceSummaryAugmentation,
+    displayCheckoutPriceSummaryLines,
+    displaySubtotal,
+    displayTotalPrice,
+  };
+}

package/src/components/booking/useStandardBookingPromoController.ts

@@ -0,0 +1,258 @@
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type Dispatch,
+  type SetStateAction,
+} from 'react';
+import {
+  validatePromoCode,
+  type Availability,
+  type RefundTierOption,
+} from '../../lib/booking-api';
+import { getAvailabilityOptionId } from './standard-booking-availability';
+
+type TranslationFn = (key: string) => string;
+
+export type StandardBookingForcedCancellationPolicy = {
+  id: string;
+  label: string;
+  refundTiers?: RefundTierOption[];
+  changeWindowHoursBefore?: number | null;
+} | null;
+
+export interface UseStandardBookingPromoControllerParams {
+  autoAppliedPromoCode?: string | null;
+  initialPromoCode?: string | null;
+  promoCodeInput: string;
+  setPromoCodeInput: Dispatch<SetStateAction<string>>;
+  appliedPromoCode: string | null;
+  setAppliedPromoCode: Dispatch<SetStateAction<string | null>>;
+  selectedAvailability: Availability | null;
+  totalQuantity: number;
+  productCompanyId?: string | null;
+  productId: string;
+  clearFetchedAvailabilityRanges: () => void;
+  setCancellationPolicyId: Dispatch<SetStateAction<string | null>>;
+  t: TranslationFn;
+}
+
+export function useStandardBookingPromoController({
+  autoAppliedPromoCode,
+  initialPromoCode,
+  promoCodeInput,
+  setPromoCodeInput,
+  appliedPromoCode,
+  setAppliedPromoCode,
+  selectedAvailability,
+  totalQuantity,
+  productCompanyId,
+  productId,
+  clearFetchedAvailabilityRanges,
+  setCancellationPolicyId,
+  t,
+}: UseStandardBookingPromoControllerParams) {
+  const [promoCodeError, setPromoCodeError] = useState('');
+  const [promoCodeValidating, setPromoCodeValidating] = useState(false);
+  const [forcedCancellationPolicy, setForcedCancellationPolicy] =
+    useState<StandardBookingForcedCancellationPolicy>(null);
+  const cancellationPolicyRef = useRef<HTMLDivElement>(null);
+  const hasAppliedInitialPromoRef = useRef(false);
+  const promoAppliedSelectionKeyRef = useRef<string | null>(null);
+  const promoValidateInFlightRef = useRef(false);
+
+  useEffect(() => {
+    if (hasAppliedInitialPromoRef.current) return;
+    const normalizedPromo = initialPromoCode?.trim().toUpperCase();
+    if (!normalizedPromo) return;
+    hasAppliedInitialPromoRef.current = true;
+    setPromoCodeInput((current) => current || normalizedPromo);
+    setAppliedPromoCode((current) => current ?? normalizedPromo);
+  }, [initialPromoCode, setAppliedPromoCode, setPromoCodeInput]);
+
+  useEffect(() => {
+    if (!autoAppliedPromoCode) return;
+    const normalizedPromo = autoAppliedPromoCode.trim().toUpperCase();
+    if (!normalizedPromo) return;
+    setPromoCodeInput((current) => current || normalizedPromo);
+  }, [autoAppliedPromoCode, setPromoCodeInput]);
+
+  const hasOngoingDiscount = useMemo(
+    () =>
+      selectedAvailability?.rates?.some((rate) =>
+        (rate.appliedAdjustments ?? rate.applied_adjustments ?? []).some(
+          (adjustment) => (adjustment.type ?? '').toLowerCase() === 'deal',
+        ),
+      ) ?? false,
+    [selectedAvailability],
+  );
+
+  const selectedAvailabilityKey = useMemo(
+    () =>
+      `${selectedAvailability?.dateTime ?? ''}::${
+        selectedAvailability ? getAvailabilityOptionId(selectedAvailability) : ''
+      }`,
+    [selectedAvailability],
+  );
+
+  const getPromoErrorMessage = useCallback(
+    (error?: string) =>
+      error === 'Promo codes cannot be stacked with deals'
+        ? (t('booking.promoCodesCannotStackWithDiscounts') || error)
+        : (error || t('booking.invalidPromoCode') || 'Invalid or expired promo code'),
+    [t],
+  );
+
+  const handlePromoInputChange = useCallback(
+    (value: string) => {
+      setPromoCodeInput(value);
+      setPromoCodeError('');
+    },
+    [setPromoCodeInput],
+  );
+
+  const handleRemovePromo = useCallback(() => {
+    promoAppliedSelectionKeyRef.current = null;
+    setAppliedPromoCode(null);
+    setPromoCodeInput('');
+    setPromoCodeError('');
+    setForcedCancellationPolicy(null);
+    setCancellationPolicyId(null);
+    clearFetchedAvailabilityRanges();
+  }, [
+    clearFetchedAvailabilityRanges,
+    setAppliedPromoCode,
+    setCancellationPolicyId,
+    setPromoCodeInput,
+  ]);
+
+  const handleApplyPromo = useCallback(async () => {
+    const code = promoCodeInput.trim().toUpperCase();
+    if (!code) return;
+    if (!selectedAvailability || totalQuantity <= 0) return;
+    if (appliedPromoCode === code) return;
+    if (!productCompanyId) return;
+    if (promoValidateInFlightRef.current) return;
+
+    promoValidateInFlightRef.current = true;
+    setPromoCodeError('');
+    setPromoCodeValidating(true);
+    try {
+      const result = await validatePromoCode(
+        code,
+        productCompanyId,
+        productId,
+        hasOngoingDiscount,
+        selectedAvailability.dateTime,
+      );
+      if (result.valid) {
+        promoAppliedSelectionKeyRef.current = selectedAvailabilityKey;
+        setAppliedPromoCode(code);
+        clearFetchedAvailabilityRanges();
+        if (result.forcedCancellationPolicyId && result.forcedCancellationPolicyLabel) {
+          setForcedCancellationPolicy({
+            id: result.forcedCancellationPolicyId,
+            label: result.forcedCancellationPolicyLabel,
+            refundTiers: result.forcedCancellationPolicyRefundTiers,
+            changeWindowHoursBefore: result.forcedChangeWindowHoursBefore ?? undefined,
+          });
+          setCancellationPolicyId(result.forcedCancellationPolicyId);
+          setTimeout(() => {
+            cancellationPolicyRef.current?.scrollIntoView({ behavior: 'smooth', block: 'center' });
+          }, 100);
+        } else {
+          setForcedCancellationPolicy(null);
+        }
+      } else {
+        setPromoCodeError(getPromoErrorMessage(result.error));
+      }
+    } catch (err) {
+      setPromoCodeError(err instanceof Error ? err.message : 'Failed to validate promo code');
+    } finally {
+      promoValidateInFlightRef.current = false;
+      setPromoCodeValidating(false);
+    }
+  }, [
+    promoCodeInput,
+    selectedAvailability,
+    totalQuantity,
+    appliedPromoCode,
+    productCompanyId,
+    productId,
+    hasOngoingDiscount,
+    selectedAvailabilityKey,
+    setAppliedPromoCode,
+    clearFetchedAvailabilityRanges,
+    setCancellationPolicyId,
+    getPromoErrorMessage,
+  ]);
+
+  useEffect(() => {
+    if (!appliedPromoCode || !selectedAvailability) return;
+    if (promoAppliedSelectionKeyRef.current === selectedAvailabilityKey) return;
+
+    let cancelled = false;
+    validatePromoCode(
+      appliedPromoCode,
+      productCompanyId ?? '',
+      productId,
+      hasOngoingDiscount,
+      selectedAvailability.dateTime,
+    ).then((result) => {
+      if (cancelled) return;
+      if (!result.valid) {
+        promoAppliedSelectionKeyRef.current = null;
+        setAppliedPromoCode(null);
+        setPromoCodeInput(appliedPromoCode);
+        setPromoCodeError(getPromoErrorMessage(result.error));
+        setForcedCancellationPolicy(null);
+        setCancellationPolicyId(null);
+        clearFetchedAvailabilityRanges();
+      }
+    });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    hasOngoingDiscount,
+    appliedPromoCode,
+    productCompanyId,
+    productId,
+    selectedAvailabilityKey,
+    selectedAvailability,
+    setAppliedPromoCode,
+    setPromoCodeInput,
+    setCancellationPolicyId,
+    clearFetchedAvailabilityRanges,
+    getPromoErrorMessage,
+  ]);
+
+  const handleApplyPromoRef = useRef(handleApplyPromo);
+  handleApplyPromoRef.current = handleApplyPromo;
+
+  useEffect(() => {
+    const trimmed = promoCodeInput.trim().toUpperCase();
+    if (!trimmed) return;
+    if (!selectedAvailability || totalQuantity <= 0) return;
+    if (appliedPromoCode === trimmed) return;
+
+    const timer = setTimeout(() => {
+      handleApplyPromoRef.current();
+    }, 600);
+
+    return () => clearTimeout(timer);
+  }, [promoCodeInput, appliedPromoCode, selectedAvailability, totalQuantity]);
+
+  return {
+    promoCodeError,
+    promoCodeValidating,
+    forcedCancellationPolicy,
+    cancellationPolicyRef,
+    handlePromoInputChange,
+    handleApplyPromo,
+    handleRemovePromo,
+  };
+}