@ticketboothapp/booking 1.2.123 → 1.2.125

package/src/components/booking/useAdminChangePricingDebugPanel.tsx

@@ -0,0 +1,178 @@
+import { useMemo } from 'react';
+import type { AdminFeAuthoritativeReceipt } from '../../lib/booking-api';
+import { roundMoney } from '../../lib/booking/change-flow-pricing';
+import { formatCurrencyAmount } from '../../lib/currency';
+import type { ChangeBookingFlowProps } from './booking-flow-types';
+import type { Currency } from './CurrencySwitcher';
+import type { AdminChangeLatestQuote } from './useAdminChangeCheckoutController';
+
+type DisplayedChangeAmounts = {
+  subtotal: number;
+  tax: number;
+  total: number;
+};
+
+type EditableSummaryDebugRow = {
+  label: string;
+  baseline: number;
+  edited: number;
+  delta: number;
+};
+
+export interface UseAdminChangePricingDebugPanelParams {
+  isAdmin: boolean;
+  hasSelectedAvailability: boolean;
+  totalQuantity: number;
+  useAdminFeAuthoritativeQuote: boolean;
+  currency: Currency;
+  locale: string;
+  originalReceipt: ChangeBookingFlowProps['originalReceipt'];
+  isCustomerSelfServeChange: boolean;
+  latestChangeQuote: AdminChangeLatestQuote | null;
+  changeQuoteFetchError: string | null;
+  displayLayerUsesExternalPricing: boolean;
+  selfServePricingConfirmed: boolean;
+  changeQuoteLoading: boolean;
+  effectiveSubtotal: number;
+  adminCustomAdjustmentTotal: number;
+  editableSummaryPreSubtotalDebugRows: EditableSummaryDebugRow[];
+  effectiveSubtotalForCheckout: number;
+  effectiveTax: number;
+  effectivePromoDiscountAmount: number;
+  totalPrice: number;
+  changeFlowNewBookingTotal: number;
+  displayedChangeAmountsRaw: DisplayedChangeAmounts;
+  editableSummaryPreSubtotalDelta: number;
+  displayChangeFlowProposedTotal: number;
+  displayChangeFlowProposedTotalWithEditableLines: number;
+  adminFeAuthoritativeReceipt: AdminFeAuthoritativeReceipt;
+  changeFlowClientEstimateDue: number;
+  changeFlowAmountDue: number;
+}
+
+export function useAdminChangePricingDebugPanel({
+  isAdmin,
+  hasSelectedAvailability,
+  totalQuantity,
+  useAdminFeAuthoritativeQuote,
+  currency,
+  locale,
+  originalReceipt,
+  isCustomerSelfServeChange,
+  latestChangeQuote,
+  changeQuoteFetchError,
+  displayLayerUsesExternalPricing,
+  selfServePricingConfirmed,
+  changeQuoteLoading,
+  effectiveSubtotal,
+  adminCustomAdjustmentTotal,
+  editableSummaryPreSubtotalDebugRows,
+  effectiveSubtotalForCheckout,
+  effectiveTax,
+  effectivePromoDiscountAmount,
+  totalPrice,
+  changeFlowNewBookingTotal,
+  displayedChangeAmountsRaw,
+  editableSummaryPreSubtotalDelta,
+  displayChangeFlowProposedTotal,
+  displayChangeFlowProposedTotalWithEditableLines,
+  adminFeAuthoritativeReceipt,
+  changeFlowClientEstimateDue,
+  changeFlowAmountDue,
+}: UseAdminChangePricingDebugPanelParams) {
+  return useMemo(() => {
+    if (!isAdmin || !hasSelectedAvailability || totalQuantity <= 0) return null;
+    const fmt = (n: number) => formatCurrencyAmount(roundMoney(n), currency, locale as 'en' | 'fr');
+    const path = (() => {
+      if (!originalReceipt) return 'totalPrice (no original receipt)';
+      if (isCustomerSelfServeChange && latestChangeQuote != null && !changeQuoteFetchError) {
+        if (
+          latestChangeQuote.quotePreviousTotalCents != null &&
+          latestChangeQuote.quoteNewTotalCents != null
+        ) {
+          return 'POST /change/quote: (quoteNewTotalCents - quotePreviousTotalCents) / 100';
+        }
+        if (latestChangeQuote.serverDisplay != null) {
+          return 'POST /change/quote: serverDisplay.total - originalReceipt.total';
+        }
+        return 'POST /change/quote: priceDiff (API balance delta)';
+      }
+      return 'FE: displayChangeFlowProposedTotal - originalReceipt.total (signed; used when quote not driving amount-due)';
+    })();
+    const quoteTotalPreview =
+      latestChangeQuote?.serverDisplay != null ? fmt(latestChangeQuote.serverDisplay.total) : '-';
+
+    return (
+      <details className="mt-3 rounded-md border border-amber-200/80 bg-amber-50/50 p-2 text-left text-xs text-amber-950">
+        <summary className="cursor-pointer select-none font-medium text-stone-800">
+          Price calculation (admin debug)
+        </summary>
+        <pre className="mt-2 max-h-64 overflow-auto whitespace-pre-wrap break-words font-mono text-[11px] leading-relaxed text-stone-800">
+          {[
+            `Amount-due path: ${path}`,
+            `adminFeAuthoritativeQuote: ${String(useAdminFeAuthoritativeQuote)}`,
+            `displayLayerUsesExternalPricing: ${String(displayLayerUsesExternalPricing)} (server/provider totals omit FE admin lines until overlaid)`,
+            `selfServePricingConfirmed: ${String(selfServePricingConfirmed)} | changeQuoteLoading: ${String(changeQuoteLoading)}`,
+            `Cart subtotal (excl. admin custom lines): ${fmt(effectiveSubtotal)}`,
+            `Admin custom lines (sum): ${fmt(adminCustomAdjustmentTotal)}`,
+            `Pre-subtotal line overrides:`,
+            ...editableSummaryPreSubtotalDebugRows.map(
+              (row, idx) =>
+                `  ${idx + 1}. ${row.label} | baseline ${fmt(row.baseline)} -> edited ${fmt(row.edited)} (delta ${fmt(row.delta)})`
+            ),
+            `Checkout subtotal (incl. admin lines): ${fmt(effectiveSubtotalForCheckout)}`,
+            `effectiveTax | promo discount: ${fmt(effectiveTax)} | ${fmt(effectivePromoDiscountAmount)}`,
+            `totalPrice (subtotal + tax - promo): ${fmt(totalPrice)}`,
+            `changeFlowNewBookingTotal (after cent reconcile vs receipt): ${fmt(changeFlowNewBookingTotal)}`,
+            `Displayed layer subtotal / tax / total: ${fmt(displayedChangeAmountsRaw.subtotal)} / ${fmt(displayedChangeAmountsRaw.tax)} / ${fmt(displayedChangeAmountsRaw.total)}`,
+            `Pre-subtotal editable lines delta: ${fmt(editableSummaryPreSubtotalDelta)}`,
+            `displayChangeFlowProposedTotal (base): ${fmt(displayChangeFlowProposedTotal)}`,
+            `displayChangeFlowProposedTotal (with editable lines): ${fmt(displayChangeFlowProposedTotalWithEditableLines)}`,
+            `feReceipt sent subtotal/tax/total: ${fmt(adminFeAuthoritativeReceipt.subtotal)} / ${fmt(adminFeAuthoritativeReceipt.tax)} / ${fmt(adminFeAuthoritativeReceipt.total)}`,
+            `feReceipt sent lineItems count: ${String(adminFeAuthoritativeReceipt.lineItems.length)}`,
+            originalReceipt ? `originalReceipt.total: ${fmt(originalReceipt.total)}` : 'originalReceipt: -',
+            `Quote serverDisplay.total (if any): ${quoteTotalPreview}`,
+            `Quote serverDisplay subtotal/tax/total: ${
+              latestChangeQuote?.serverDisplay
+                ? `${fmt(latestChangeQuote.serverDisplay.subtotal)} / ${fmt(latestChangeQuote.serverDisplay.tax)} / ${fmt(latestChangeQuote.serverDisplay.total)}`
+                : '-'
+            }`,
+            `changeFlowClientEstimateDue (before near-zero): ${fmt(changeFlowClientEstimateDue)}`,
+            `changeFlowAmountDue (PriceSummary total row): ${fmt(changeFlowAmountDue)}`,
+          ].join('\n')}
+        </pre>
+      </details>
+    );
+  }, [
+    isAdmin,
+    hasSelectedAvailability,
+    totalQuantity,
+    useAdminFeAuthoritativeQuote,
+    currency,
+    locale,
+    originalReceipt,
+    isCustomerSelfServeChange,
+    latestChangeQuote,
+    changeQuoteFetchError,
+    displayLayerUsesExternalPricing,
+    selfServePricingConfirmed,
+    changeQuoteLoading,
+    effectiveSubtotal,
+    adminCustomAdjustmentTotal,
+    editableSummaryPreSubtotalDebugRows,
+    effectiveSubtotalForCheckout,
+    effectiveTax,
+    effectivePromoDiscountAmount,
+    totalPrice,
+    changeFlowNewBookingTotal,
+    displayedChangeAmountsRaw.subtotal,
+    displayedChangeAmountsRaw.tax,
+    displayedChangeAmountsRaw.total,
+    editableSummaryPreSubtotalDelta,
+    displayChangeFlowProposedTotal,
+    displayChangeFlowProposedTotalWithEditableLines,
+    adminFeAuthoritativeReceipt,
+    changeFlowClientEstimateDue,
+    changeFlowAmountDue,
+  ]);
+}

package/src/components/booking/useAdminChangeProductReset.ts

@@ -0,0 +1,60 @@
+import { useEffect, useRef, type Dispatch, type SetStateAction } from 'react';
+import type { AddOn, Availability, ReturnOption } from '../../lib/booking-api';
+import type { AdminChangeLatestQuote } from './useAdminChangeCheckoutController';
+
+interface ResetRef {
+  current: string | null;
+}
+
+export interface UseAdminChangeProductResetParams {
+  selectedChangeProductId: string;
+  setSelectedAvailability: Dispatch<SetStateAction<Availability | null>>;
+  setSelectedReturnOption: Dispatch<SetStateAction<ReturnOption | null>>;
+  setAddOns: Dispatch<SetStateAction<AddOn[]>>;
+  lastCompletedQuoteInputsKeyRef: ResetRef;
+  inFlightQuoteInputsKeyRef: ResetRef;
+  setLatestChangeQuote: Dispatch<SetStateAction<AdminChangeLatestQuote | null>>;
+  setChangeQuoteFetchError: Dispatch<SetStateAction<string | null>>;
+  setChangeQuoteLoading: Dispatch<SetStateAction<boolean>>;
+  setError: Dispatch<SetStateAction<string>>;
+}
+
+export function useAdminChangeProductReset({
+  selectedChangeProductId,
+  setSelectedAvailability,
+  setSelectedReturnOption,
+  setAddOns,
+  lastCompletedQuoteInputsKeyRef,
+  inFlightQuoteInputsKeyRef,
+  setLatestChangeQuote,
+  setChangeQuoteFetchError,
+  setChangeQuoteLoading,
+  setError,
+}: UseAdminChangeProductResetParams) {
+  const previousSelectedChangeProductIdRef = useRef(selectedChangeProductId);
+
+  useEffect(() => {
+    if (previousSelectedChangeProductIdRef.current === selectedChangeProductId) return;
+    previousSelectedChangeProductIdRef.current = selectedChangeProductId;
+    setSelectedAvailability(null);
+    setSelectedReturnOption(null);
+    setAddOns([]);
+    lastCompletedQuoteInputsKeyRef.current = null;
+    inFlightQuoteInputsKeyRef.current = null;
+    setLatestChangeQuote(null);
+    setChangeQuoteFetchError(null);
+    setChangeQuoteLoading(false);
+    setError('');
+  }, [
+    selectedChangeProductId,
+    setSelectedAvailability,
+    setSelectedReturnOption,
+    setAddOns,
+    lastCompletedQuoteInputsKeyRef,
+    inFlightQuoteInputsKeyRef,
+    setLatestChangeQuote,
+    setChangeQuoteFetchError,
+    setChangeQuoteLoading,
+    setError,
+  ]);
+}

package/src/components/booking/useAdminChangeProducts.ts

@@ -0,0 +1,102 @@
+import { useEffect, useMemo, useState } from 'react';
+import {
+  fetchProducts,
+  type Product,
+} from '../../lib/booking-api';
+import { isParentProductId } from '../../lib/booking/product-option-id';
+import {
+  getAdminChangeEligibleProducts,
+  isPrivateShuttleProduct,
+} from './change-booking-flow-helpers';
+
+interface UseAdminChangeProductsParams {
+  initialProduct: Product;
+  changeProductOptions?: Product[];
+  initialValuesProductId?: string | null;
+  isAdmin: boolean;
+  companyId?: string | null;
+}
+
+export function useAdminChangeProducts({
+  initialProduct,
+  changeProductOptions,
+  initialValuesProductId,
+  isAdmin,
+  companyId,
+}: UseAdminChangeProductsParams) {
+  const isInitialPrivateShuttleBooking = isPrivateShuttleProduct(initialProduct);
+  const [availableChangeProducts, setAvailableChangeProducts] = useState<Product[]>(
+    () => getAdminChangeEligibleProducts(changeProductOptions ?? [initialProduct], initialProduct),
+  );
+  const [selectedChangeProductId, setSelectedChangeProductId] = useState(initialProduct.productId);
+  const [changeProductsLoading, setChangeProductsLoading] = useState(false);
+  const [changeProductsError, setChangeProductsError] = useState<string | null>(null);
+
+  const product = useMemo(
+    () =>
+      availableChangeProducts.find((p) => p.productId === selectedChangeProductId) ??
+      initialProduct,
+    [availableChangeProducts, selectedChangeProductId, initialProduct],
+  );
+
+  const originalParentProductId = useMemo(() => {
+    const pid = initialValuesProductId?.trim();
+    if (pid && isParentProductId(pid)) return pid;
+    return initialProduct.productId;
+  }, [initialValuesProductId, initialProduct.productId]);
+
+  useEffect(() => {
+    if (changeProductOptions?.length) {
+      const nextProducts = getAdminChangeEligibleProducts(changeProductOptions, initialProduct);
+      setAvailableChangeProducts(nextProducts);
+      setSelectedChangeProductId((current) =>
+        nextProducts.some((p) => p.productId === current) ? current : initialProduct.productId,
+      );
+      return;
+    }
+    setAvailableChangeProducts((prev) => {
+      const hasInitial = prev.some((p) => p.productId === initialProduct.productId);
+      return hasInitial ? prev : [initialProduct, ...prev];
+    });
+    setSelectedChangeProductId((current) => current || initialProduct.productId);
+  }, [initialProduct, changeProductOptions]);
+
+  useEffect(() => {
+    if (changeProductOptions?.length) return;
+    if (!isAdmin || !companyId) return;
+    let cancelled = false;
+    setChangeProductsLoading(true);
+    setChangeProductsError(null);
+    fetchProducts(companyId)
+      .then((products) => {
+        if (cancelled) return;
+        const nextProducts = getAdminChangeEligibleProducts(products, initialProduct);
+        setAvailableChangeProducts(nextProducts);
+        setSelectedChangeProductId((current) =>
+          nextProducts.some((p) => p.productId === current) ? current : initialProduct.productId,
+        );
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        setChangeProductsError(err instanceof Error ? err.message : 'Failed to load products');
+      })
+      .finally(() => {
+        if (!cancelled) setChangeProductsLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [changeProductOptions, isAdmin, companyId, initialProduct]);
+
+  return {
+    availableChangeProducts,
+    changeProductsError,
+    changeProductsLoading,
+    isInitialPrivateShuttleBooking,
+    originalParentProductId,
+    product,
+    selectedChangeProductId,
+    selectedParentProductChanged: selectedChangeProductId !== originalParentProductId,
+    setSelectedChangeProductId,
+  };
+}

package/src/components/booking/useAdminChangePromoDiscount.ts

@@ -0,0 +1,235 @@
+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 {
+  deriveOriginalReceiptPromoAdjustment,
+  getAvailabilityOptionId,
+} from './change-booking-flow-helpers';
+
+interface UseAdminChangePromoDiscountParams {
+  appliedPromoCode: string | null;
+  selectedAvailability: Availability | null;
+  totalQuantity: number;
+  productCompanyId?: string | null;
+  envCompanyId?: string | null;
+  productId: string;
+  currency: Currency;
+  quantities: Record<string, number>;
+  ticketLineItemsForChangeFlowDisplay: OrderSummaryTicketLine[];
+  feeLineItemsWithAddOns: OrderSummaryFeeLine[];
+  effectiveSubtotalForCheckout: number;
+  lockedPromoCode: string | null;
+  originalReceipt: ChangeBookingFlowProps['originalReceipt'];
+  isTaxIncludedInPrice: boolean;
+  pricingConfig: PricingConfig | null;
+}
+
+export function useAdminChangePromoDiscount({
+  appliedPromoCode,
+  selectedAvailability,
+  totalQuantity,
+  productCompanyId,
+  envCompanyId,
+  productId,
+  currency,
+  quantities,
+  ticketLineItemsForChangeFlowDisplay,
+  feeLineItemsWithAddOns,
+  effectiveSubtotalForCheckout,
+  lockedPromoCode,
+  originalReceipt,
+  isTaxIncludedInPrice,
+  pricingConfig,
+}: UseAdminChangePromoDiscountParams) {
+  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 originalReceiptPromoAdjustment = useMemo(
+    () => deriveOriginalReceiptPromoAdjustment(originalReceipt),
+    [originalReceipt],
+  );
+
+  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(feeLineItemsWithAddOns.reduce((sum, fee) => sum + fee.totalAmount, 0) * 100)),
+      String(Math.round(effectiveSubtotalForCheckout * 100)),
+      lockedPromoCode ? String(Math.round(originalReceiptPromoAdjustment.amount * 100)) : '',
+    ].join('::');
+  }, [
+    appliedPromoCode,
+    selectedAvailability,
+    selectedAvailabilityOptionId,
+    totalQuantity,
+    productCompanyId,
+    envCompanyId,
+    productId,
+    currency,
+    quantitiesSignature,
+    ticketLineItemsForChangeFlowDisplay,
+    feeLineItemsWithAddOns,
+    effectiveSubtotalForCheckout,
+    lockedPromoCode,
+    originalReceiptPromoAdjustment.amount,
+  ]);
+
+  promoDiscountParamsRef.current = {
+    selectedAvailability,
+    ticketLineItems: ticketLineItemsForChangeFlowDisplay.map((line) => ({
+      category: line.category,
+      qty: line.qty,
+      itemTotal: line.itemTotal,
+    })),
+    effectiveSubtotal: effectiveSubtotalForCheckout,
+    displayedProductFeeTotal: feeLineItemsWithAddOns.reduce((sum, fee) => sum + fee.totalAmount, 0),
+    appliedPromoCode,
+    changeBookingPromo: lockedPromoCode
+      ? { priorAmount: originalReceiptPromoAdjustment.amount }
+      : 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 receiptPromoFallbackAmount = Math.max(0, originalReceiptPromoAdjustment.amount);
+  const effectivePromoDiscountAmount =
+    promoDiscountAmount > 0 ? promoDiscountAmount : receiptPromoFallbackAmount;
+  const effectivePromoLineType =
+    isGiftCard || originalReceiptPromoAdjustment.type === 'GIFT_CARD'
+      ? 'GIFT_CARD'
+      : isVoucher || originalReceiptPromoAdjustment.type === 'VOUCHER'
+        ? 'VOUCHER'
+        : originalReceiptPromoAdjustment.type;
+  const taxOnSubtotal = isTaxIncludedInPrice
+    ? 0
+    : effectiveSubtotalForCheckout * (pricingConfig?.taxRate ?? 0);
+  const effectiveTax =
+    effectivePromoDiscountAmount > 0 &&
+    effectivePromoLineType !== 'GIFT_CARD' &&
+    effectivePromoLineType !== 'VOUCHER'
+      ? (effectiveSubtotalForCheckout - effectivePromoDiscountAmount) * (pricingConfig?.taxRate ?? 0)
+      : taxOnSubtotal;
+  const totalPrice = effectiveSubtotalForCheckout + effectiveTax - effectivePromoDiscountAmount;
+
+  return {
+    originalReceiptPromoAdjustment,
+    effectivePromoDiscountAmount,
+    effectivePromoLineType,
+    effectiveTax,
+    totalPrice,
+  };
+}