@ticketboothapp/booking 1.2.123 → 1.2.125

package/src/components/booking/useChangeBookingSummaryLines.ts

@@ -0,0 +1,169 @@
+import { useMemo } from 'react';
+import type { Availability, ReturnOption } from '../../lib/booking-api';
+import type {
+  OrderSummaryFeeLine,
+  OrderSummaryTicketLine,
+  PriceBreakdown as PriceBreakdownData,
+} from '../../lib/booking/pricing';
+import type { PriceSummaryLine } from './PriceSummary';
+import {
+  mergePickerTicketQtyIntoPriceSummaryLines,
+  omitZeroAmountPromoDiscountSummaryLines,
+  type PricingRate,
+} from './change-booking-flow-helpers';
+
+type GetPriceBreakdown = (
+  category: string,
+  priceCAD: number,
+  baseInDisplayCurrency: number | undefined,
+  appliedAdjustments?: Array<{ type: string; id: string; name: string; changeByCurrency?: Record<string, number> }>,
+) => PriceBreakdownData | null;
+
+interface UseChangeBookingSummaryLinesParams {
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  ticketLineItemsForChangeFlowDisplay: OrderSummaryTicketLine[];
+  pricing: PricingRate[];
+  getPriceBreakdown: GetPriceBreakdown;
+  checkoutReturnLineAmount: number;
+  totalQuantity: number;
+  t: (key: string) => string;
+  cancellationPolicyFee: number;
+  hasSelectedCancellationPolicy: boolean;
+  effectiveCancellationPolicyLabel: string;
+  feeLineItemsWithAddOns: OrderSummaryFeeLine[];
+  feeLineItems: OrderSummaryFeeLine[];
+  suppressSelfServeCurrencyUi: boolean;
+  selfServePricingConfirmed: boolean;
+  latestServerPriceSummaryLines?: PriceSummaryLine[];
+  quantities: Record<string, number>;
+}
+
+export function useChangeBookingSummaryLines({
+  selectedAvailability,
+  selectedReturnOption,
+  ticketLineItemsForChangeFlowDisplay,
+  pricing,
+  getPriceBreakdown,
+  checkoutReturnLineAmount,
+  totalQuantity,
+  t,
+  cancellationPolicyFee,
+  hasSelectedCancellationPolicy,
+  effectiveCancellationPolicyLabel,
+  feeLineItemsWithAddOns,
+  feeLineItems,
+  suppressSelfServeCurrencyUi,
+  selfServePricingConfirmed,
+  latestServerPriceSummaryLines,
+  quantities,
+}: UseChangeBookingSummaryLinesParams) {
+  const checkoutPriceSummaryLines = useMemo((): PriceSummaryLine[] => {
+    if (!selectedAvailability) return [];
+    const returnLineAmount = checkoutReturnLineAmount;
+    const showReturnLine =
+      Boolean(selectedReturnOption) && Math.abs(returnLineAmount) > 0.0005;
+    return [
+      ...ticketLineItemsForChangeFlowDisplay.map((line): PriceSummaryLine => {
+        const rate = pricing.find((r) => r.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 && hasSelectedCancellationPolicy
+        ? [
+            {
+              kind: 'line' as const,
+              label: effectiveCancellationPolicyLabel,
+              amount: cancellationPolicyFee,
+              type: 'cancellation',
+            },
+          ]
+        : []),
+      ...feeLineItemsWithAddOns.map((fee) => {
+        const isMoraineLakeRoadAccessFee =
+          fee.name.toLowerCase().includes('moraine') &&
+          (fee.name.toLowerCase().includes('access') ||
+            fee.name.toLowerCase().includes('road') ||
+            fee.name.toLowerCase().includes('license'));
+        return {
+          kind: 'line' as const,
+          label: feeLineItems.some((f) => f.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,
+    ticketLineItemsForChangeFlowDisplay,
+    pricing,
+    getPriceBreakdown,
+    selectedReturnOption,
+    checkoutReturnLineAmount,
+    totalQuantity,
+    t,
+    cancellationPolicyFee,
+    hasSelectedCancellationPolicy,
+    effectiveCancellationPolicyLabel,
+    feeLineItemsWithAddOns,
+    feeLineItems,
+  ]);
+
+  const checkoutPriceSummaryLinesForCheckout = useMemo(() => {
+    let raw: PriceSummaryLine[];
+    if (suppressSelfServeCurrencyUi && selfServePricingConfirmed) {
+      raw =
+        latestServerPriceSummaryLines && latestServerPriceSummaryLines.length > 0
+          ? mergePickerTicketQtyIntoPriceSummaryLines(latestServerPriceSummaryLines, quantities)
+          : checkoutPriceSummaryLines;
+    } else {
+      raw = checkoutPriceSummaryLines;
+    }
+    return omitZeroAmountPromoDiscountSummaryLines(raw);
+  }, [
+    suppressSelfServeCurrencyUi,
+    selfServePricingConfirmed,
+    checkoutPriceSummaryLines,
+    latestServerPriceSummaryLines,
+    quantities,
+  ]);
+
+  const priceSummaryLinesIncludeTaxRow = useMemo(
+    () =>
+      checkoutPriceSummaryLinesForCheckout.some(
+        (line) => line.kind === 'line' && String(line.type ?? '').toUpperCase() === 'TAX',
+      ),
+    [checkoutPriceSummaryLinesForCheckout],
+  );
+
+  return {
+    checkoutPriceSummaryLinesForCheckout,
+    priceSummaryLinesIncludeTaxRow,
+  };
+}

package/src/components/booking/usePrivateShuttlePriceSummary.ts

@@ -0,0 +1,513 @@
+import { useCallback, useMemo } from 'react';
+import type {
+  AddOn,
+  Availability,
+  PrecomputedPricesByCategory,
+  PricingConfig,
+  Product,
+} from '../../lib/booking-api';
+import type { OrderSummaryFeeLine } from '../../lib/booking/pricing';
+import type { ProviderDashboardChangeBookingPayload } from './provider-dashboard-change-booking';
+import type { Currency } from './CurrencySwitcher';
+import type { PriceSummaryLine } from './PriceSummary';
+import {
+  applyResourceAdjustments,
+  getPrivateShuttleAvailabilityOptionId,
+  getResourceRate,
+  roundMoney,
+} from './private-shuttle-availability';
+import { usePrivateShuttlePromoDiscount } from './usePrivateShuttlePromoDiscount';
+
+export const PRIVATE_SHUTTLE_RESOURCE_CAPACITY = 13;
+export const PRIVATE_SHUTTLE_ADDITIONAL_HOUR_PRICE = 170;
+export const MORAINE_LAKE_ROAD_ACCESS_FEE_TOOLTIP =
+  "Since 2025, Parks Canada charges a per-trip fee for License of Occupation at Moraine Lake. This fee contributes towards Parks Canada's Moraine Lake Road operations.";
+
+type AddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+type PrivateShuttleDepositConfig = {
+  percentage?: number;
+  fixedAmount?: number;
+};
+
+export function isMoraineLakeRoadAccessFeeName(name: string): boolean {
+  const normalized = name.toLowerCase();
+  return (
+    normalized.includes('moraine') &&
+    (normalized.includes('access') ||
+      normalized.includes('road') ||
+      normalized.includes('license'))
+  );
+}
+
+function isMoraineLakeLocationText(value: string): boolean {
+  const normalized = value.toLowerCase().replace(/[_-]+/g, ' ');
+  return normalized.includes('moraine') && normalized.includes('lake');
+}
+
+interface UsePrivateShuttlePriceSummaryParams {
+  selectedOption: string;
+  selectedDate: string;
+  selectedStartTime: string;
+  selectedAvailability: Availability | null;
+  selectedOptionConfig: Product['options'][number] | undefined;
+  activeOptions: Product['options'];
+  availabilitiesByDate: Record<string, Availability[]>;
+  resourcePriceByOption: Record<string, Record<string, number>> | null | undefined;
+  resourcePriceByCurrency: Record<string, number> | null | undefined;
+  precomputedPrices: PrecomputedPricesByCategory | null | undefined;
+  passengerCount: number;
+  currency: Currency;
+  pricingConfig: PricingConfig | null;
+  cancellationPolicyId: string | null;
+  draftItineraryDestinations: string[];
+  itineraryDestinations: NonNullable<Product['itineraryBuilder']>['destinations'] | undefined;
+  addOnSelections: AddOnSelection[];
+  addOns: AddOn[];
+  isAdmin: boolean;
+  additionalHoursCount: number;
+  activePromoCode: string | null;
+  productCompanyId?: string | null;
+  productId: string;
+  depositConfig?: PrivateShuttleDepositConfig;
+  t: (key: string) => string;
+}
+
+export function usePrivateShuttlePriceSummary({
+  selectedOption,
+  selectedDate,
+  selectedStartTime,
+  selectedAvailability,
+  selectedOptionConfig,
+  activeOptions,
+  availabilitiesByDate,
+  resourcePriceByOption,
+  resourcePriceByCurrency,
+  precomputedPrices,
+  passengerCount,
+  currency,
+  pricingConfig,
+  cancellationPolicyId,
+  draftItineraryDestinations,
+  itineraryDestinations,
+  addOnSelections,
+  addOns,
+  isAdmin,
+  additionalHoursCount,
+  activePromoCode,
+  productCompanyId,
+  productId,
+  depositConfig,
+  t,
+}: UsePrivateShuttlePriceSummaryParams) {
+  const resourceCount = Math.ceil(passengerCount / PRIVATE_SHUTTLE_RESOURCE_CAPACITY);
+  const maxVacancies = selectedAvailability?.vacancies || 0;
+  const isSpecialRequest = passengerCount > maxVacancies;
+  const billableResourceCount = isSpecialRequest
+    ? Math.max(1, Math.ceil(maxVacancies / PRIVATE_SHUTTLE_RESOURCE_CAPACITY))
+    : resourceCount;
+
+  const getOptionPrice = useCallback(
+    (optionId: string) => {
+      const option = activeOptions.find((candidate) => candidate.optionId === optionId);
+      const dateAvailabilities = selectedDate ? availabilitiesByDate[selectedDate] || [] : [];
+      const availability = dateAvailabilities.find(
+        (candidate) => getPrivateShuttleAvailabilityOptionId(candidate) === optionId,
+      );
+      const profileOptionPrice = resourcePriceByOption?.[optionId]?.[currency];
+      if (profileOptionPrice != null) {
+        return applyResourceAdjustments(profileOptionPrice, availability, currency);
+      }
+      if (currency === 'CAD' && option?.pricing?.['RESOURCE'] != null) {
+        return applyResourceAdjustments(option.pricing['RESOURCE'], availability, currency);
+      }
+      if (availability?.rates) {
+        const resourceRate = getResourceRate(availability);
+        if (resourceRate?.priceByCurrency?.[currency] != null) {
+          return resourceRate.priceByCurrency[currency];
+        }
+        if (currency === 'CAD' && resourceRate?.price != null) return resourceRate.price;
+      }
+      if (currency === 'CAD' && resourcePriceByCurrency?.[currency] != null) {
+        return resourcePriceByCurrency[currency];
+      }
+      return option?.pricing?.['RESOURCE'] ?? 0;
+    },
+    [
+      activeOptions,
+      selectedDate,
+      availabilitiesByDate,
+      resourcePriceByOption,
+      resourcePriceByCurrency,
+      currency,
+    ],
+  );
+
+  const resourcePrice = useMemo(() => {
+    const selectedProfileOptionPrice = selectedOption
+      ? resourcePriceByOption?.[selectedOption]?.[currency]
+      : undefined;
+    if (selectedProfileOptionPrice != null) {
+      return applyResourceAdjustments(selectedProfileOptionPrice, selectedAvailability, currency);
+    }
+    if (currency === 'CAD' && selectedOptionConfig?.pricing?.['RESOURCE'] != null) {
+      return applyResourceAdjustments(
+        selectedOptionConfig.pricing['RESOURCE'],
+        selectedAvailability,
+        currency,
+      );
+    }
+    if (selectedAvailability?.rates) {
+      const resourceRate = getResourceRate(selectedAvailability);
+      if (resourceRate) {
+        const fromRate =
+          resourceRate.priceByCurrency?.[currency] ??
+          (currency === 'CAD' ? resourceRate.price : undefined);
+        if (fromRate != null) return fromRate;
+      }
+    }
+    if (currency === 'CAD' && resourcePriceByCurrency?.[currency] != null) {
+      return resourcePriceByCurrency[currency];
+    }
+    if (precomputedPrices?.['RESOURCE']?.[currency] != null) {
+      return precomputedPrices['RESOURCE'][currency];
+    }
+    if (selectedOptionConfig?.pricing?.['RESOURCE'] != null) {
+      return selectedOptionConfig.pricing['RESOURCE'];
+    }
+    return 0;
+  }, [
+    selectedOption,
+    selectedAvailability,
+    selectedOptionConfig,
+    resourcePriceByOption,
+    resourcePriceByCurrency,
+    precomputedPrices,
+    currency,
+  ]);
+
+  const basePrice = resourcePrice * resourceCount;
+  const isTaxIncludedInPrice = (pricingConfig?.currenciesWithTaxIncluded ?? []).includes(currency);
+  const taxRate = pricingConfig?.taxRate ?? 0.05;
+  const selectedCancellationPolicy = useMemo(
+    () => pricingConfig?.cancellationPolicies?.find((policy) => policy.id === cancellationPolicyId),
+    [pricingConfig?.cancellationPolicies, cancellationPolicyId],
+  );
+  const cancellationPolicyFee = selectedCancellationPolicy
+    ? (selectedCancellationPolicy.feeByCurrency[currency] ?? 0)
+    : 0;
+
+  const draftItineraryIncludesMoraineLake = useMemo(() => {
+    if (draftItineraryDestinations.length === 0) return false;
+    const destinationLabelsById = new Map(
+      (itineraryDestinations ?? []).map((destination) => [
+        destination.id,
+        destination.label,
+      ]),
+    );
+    return draftItineraryDestinations.some((destinationId) => {
+      const label = destinationLabelsById.get(destinationId);
+      return (
+        isMoraineLakeLocationText(destinationId) ||
+        (label ? isMoraineLakeLocationText(label) : false)
+      );
+    });
+  }, [draftItineraryDestinations, itineraryDestinations]);
+
+  const perBookingFeeLineItems = useMemo<OrderSummaryFeeLine[]>(() => {
+    if (isTaxIncludedInPrice) return [];
+    const amountsByName = pricingConfig?.perBookingFeesByCurrency?.[currency];
+    if (!amountsByName) return [];
+    const feeMetadata = pricingConfig?.perBookingFees ?? {};
+    return Object.entries(amountsByName)
+      .filter(
+        ([name]) =>
+          draftItineraryIncludesMoraineLake || !isMoraineLakeRoadAccessFeeName(name),
+      )
+      .map(([name, amount]) => ({
+        name,
+        totalAmount: amount,
+        description: feeMetadata[name]?.description,
+      }));
+  }, [currency, draftItineraryIncludesMoraineLake, isTaxIncludedInPrice, pricingConfig]);
+
+  const addOnTotal = useMemo(() => {
+    let sum = 0;
+    for (const selection of addOnSelections) {
+      const addOn = addOns.find((candidate) => candidate.addOnId === selection.addOnId);
+      if (!addOn) continue;
+      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;
+      sum += (base + adjustment) * (selection.quantity ?? 1);
+    }
+    return sum;
+  }, [addOnSelections, addOns]);
+
+  const additionalHoursAmount =
+    (isAdmin ? additionalHoursCount : 0) * PRIVATE_SHUTTLE_ADDITIONAL_HOUR_PRICE;
+  const perBookingFeeTotal = perBookingFeeLineItems.reduce(
+    (sum, fee) => sum + fee.totalAmount,
+    0,
+  );
+  const subtotal = basePrice + addOnTotal + additionalHoursAmount + perBookingFeeTotal;
+
+  const {
+    promoDiscountAmount,
+    isGiftCard,
+    isVoucher,
+    effectivePromoDiscountAmount,
+    resetPromoDiscount,
+  } = usePrivateShuttlePromoDiscount({
+    activePromoCode,
+    selectedOption,
+    selectedDate,
+    selectedStartTime,
+    resourceCount,
+    productCompanyId,
+    productId,
+    currency,
+    subtotal,
+  });
+
+  const taxAmount = isTaxIncludedInPrice ? 0 : subtotal * taxRate;
+  const effectiveTaxAmount =
+    effectivePromoDiscountAmount > 0 && !isGiftCard && !isVoucher
+      ? (isTaxIncludedInPrice ? 0 : (subtotal - effectivePromoDiscountAmount) * taxRate)
+      : taxAmount;
+  const totalPrice = subtotal + effectiveTaxAmount - effectivePromoDiscountAmount;
+
+  const providerChangeAuthoritativeReceipt = useMemo<
+    ProviderDashboardChangeBookingPayload['authoritativeReceipt']
+  >(() => {
+    const lineItems: NonNullable<
+      ProviderDashboardChangeBookingPayload['authoritativeReceipt']
+    >['lineItems'] = [
+      {
+        type: 'TICKET',
+        label: resourceCount > 1 ? 'Shuttles' : 'Shuttle',
+        amount: roundMoney(basePrice),
+        quantity: resourceCount,
+      },
+    ];
+
+    for (const selection of addOnSelections) {
+      const addOn = addOns.find((candidate) => candidate.addOnId === selection.addOnId);
+      if (!addOn) continue;
+      const hasVariant =
+        (addOn.variantType === 'single_choice' || addOn.variantType === 'multi_quantity') &&
+        selection.variantId;
+      const variant = hasVariant
+        ? addOn.variants?.find((candidate) => candidate.id === selection.variantId)
+        : null;
+      const amount =
+        ((addOn.price ?? 0) + (variant?.priceAdjustment ?? 0)) * (selection.quantity ?? 1);
+      lineItems.push({
+        type: 'FEE',
+        label: variant?.label ? `${addOn.name} (${variant.label})` : addOn.name,
+        amount: roundMoney(amount),
+      });
+    }
+
+    if (additionalHoursAmount > 0) {
+      lineItems.push({
+        type: 'FEE',
+        label:
+          additionalHoursCount === 1
+            ? 'Additional hour'
+            : `Additional hours (${additionalHoursCount})`,
+        amount: roundMoney(additionalHoursAmount),
+      });
+    }
+
+    for (const fee of perBookingFeeLineItems) {
+      lineItems.push({
+        type: 'FEE',
+        label: fee.name,
+        amount: roundMoney(fee.totalAmount),
+      });
+    }
+
+    if (cancellationPolicyFee > 0 && selectedCancellationPolicy) {
+      lineItems.push({
+        type: 'CANCELLATION_UPGRADE',
+        label: selectedCancellationPolicy.label,
+        amount: roundMoney(cancellationPolicyFee),
+      });
+    }
+
+    if (effectiveTaxAmount > 0) {
+      lineItems.push({
+        type: 'TAX',
+        label: t('booking.tax') !== 'booking.tax' ? t('booking.tax') : 'Taxes and fees',
+        amount: roundMoney(effectiveTaxAmount),
+      });
+    }
+
+    if (effectivePromoDiscountAmount > 0) {
+      lineItems.push({
+        type: isGiftCard ? 'GIFT_CARD' : 'PROMO_CODE',
+        label: activePromoCode ? `Promo: ${activePromoCode}` : (t('booking.discount') || 'Discount'),
+        amount: roundMoney(-effectivePromoDiscountAmount),
+      });
+    }
+
+    const expectedTotal = roundMoney(totalPrice);
+    const lineTotal = roundMoney(lineItems.reduce((sum, line) => sum + line.amount, 0));
+    const roundingDelta = roundMoney(expectedTotal - lineTotal);
+    if (Math.abs(roundingDelta) >= 0.01) {
+      lineItems.push({
+        type: 'ROUNDING',
+        label: t('booking.rounding') || 'Rounding',
+        amount: roundingDelta,
+      });
+    }
+
+    return {
+      currency,
+      lineItems,
+      subtotalBeforeTax: roundMoney(expectedTotal - roundMoney(effectiveTaxAmount)),
+      taxAmount: roundMoney(effectiveTaxAmount),
+      totalAmount: expectedTotal,
+    };
+  }, [
+    activePromoCode,
+    addOnSelections,
+    addOns,
+    additionalHoursAmount,
+    additionalHoursCount,
+    basePrice,
+    cancellationPolicyFee,
+    currency,
+    effectivePromoDiscountAmount,
+    effectiveTaxAmount,
+    isGiftCard,
+    perBookingFeeLineItems,
+    resourceCount,
+    selectedCancellationPolicy,
+    t,
+    totalPrice,
+  ]);
+
+  const depositInfo = useMemo(() => {
+    if (!depositConfig || totalPrice <= 0) return null;
+    let depositAmount = 0;
+    if (depositConfig.percentage != null) {
+      const percentage = depositConfig.percentage;
+      depositAmount =
+        percentage <= 1 ? totalPrice * percentage : (totalPrice * percentage) / 100;
+    } else if (depositConfig.fixedAmount != null) {
+      depositAmount = depositConfig.fixedAmount;
+    }
+    if (depositAmount <= 0) return null;
+    return {
+      depositAmount,
+      balanceAmount: totalPrice - depositAmount,
+      totalPrice,
+    };
+  }, [depositConfig, totalPrice]);
+
+  const priceSummaryLines = useMemo<PriceSummaryLine[]>(() => {
+    const addOnLines = addOnSelections
+      .map((selection): PriceSummaryLine | null => {
+        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;
+        return {
+          kind: 'line',
+          label: addOn.name,
+          amount: (base + adjustment) * (selection.quantity ?? 1),
+          type: 'fee',
+        };
+      })
+      .filter((line): line is PriceSummaryLine => line != null);
+
+    return [
+      {
+        kind: 'line',
+        label: resourceCount > 1 ? `Shuttle x ${resourceCount}` : 'Shuttle',
+        amount: basePrice,
+        type: 'ticket',
+      },
+      ...addOnLines,
+      ...(additionalHoursAmount > 0
+        ? [
+            {
+              kind: 'line' as const,
+              label:
+                additionalHoursCount === 1
+                  ? 'Additional hour'
+                  : `Additional hours (${additionalHoursCount})`,
+              amount: additionalHoursAmount,
+              type: 'fee',
+            },
+          ]
+        : []),
+      ...perBookingFeeLineItems.map((fee): PriceSummaryLine => ({
+        kind: 'line',
+        label: fee.name,
+        amount: fee.totalAmount,
+        type: 'fee',
+        tooltip: isMoraineLakeRoadAccessFeeName(fee.name)
+          ? MORAINE_LAKE_ROAD_ACCESS_FEE_TOOLTIP
+          : undefined,
+      })),
+      ...(cancellationPolicyFee > 0
+        ? [
+            {
+              kind: 'line' as const,
+              label: selectedCancellationPolicy?.label ?? 'Cancellation',
+              amount: cancellationPolicyFee,
+              type: 'cancellation',
+            },
+          ]
+        : []),
+    ];
+  }, [
+    addOnSelections,
+    addOns,
+    additionalHoursAmount,
+    additionalHoursCount,
+    basePrice,
+    cancellationPolicyFee,
+    perBookingFeeLineItems,
+    resourceCount,
+    selectedCancellationPolicy?.label,
+  ]);
+
+  return {
+    resourceCount,
+    maxVacancies,
+    isSpecialRequest,
+    billableResourceCount,
+    getOptionPrice,
+    resourcePrice,
+    basePrice,
+    isTaxIncludedInPrice,
+    taxRate,
+    selectedCancellationPolicy,
+    cancellationPolicyFee,
+    addOnTotal,
+    additionalHoursAmount,
+    perBookingFeeLineItems,
+    subtotal,
+    promoDiscountAmount,
+    isGiftCard,
+    effectivePromoDiscountAmount,
+    effectiveTaxAmount,
+    totalPrice,
+    providerChangeAuthoritativeReceipt,
+    depositInfo,
+    priceSummaryLines,
+    resetPromoDiscount,
+  };
+}