@ticketboothapp/booking 1.2.123 → 1.2.124

package/src/components/booking/standard-booking-availability.ts

@@ -0,0 +1,305 @@
+import { addWeeks, parseISO } from 'date-fns';
+import { formatInTimeZone, fromZonedTime } from 'date-fns-tz';
+
+import type {
+  Availability,
+  GetAvailabilitiesResponse,
+  PrecomputedPricesByCategory,
+  PricingConfig,
+  Product,
+  ReturnOption,
+} from '../../lib/booking-api';
+import {
+  EARLIEST_AVAILABILITY_DATE,
+  INITIAL_FETCH_WEEKS,
+  LATEST_AVAILABILITY_DATE,
+  VISIBLE_RANGE_BUFFER_WEEKS,
+} from '../../lib/booking-constants';
+import {
+  computePriceBreakdown,
+  getDisplayPriceFromBaseInDisplayCurrency,
+} from '../../lib/booking/pricing';
+import type { Currency } from './CurrencySwitcher';
+
+export function findMergedAvailabilityForSelection(
+  merged: Availability[],
+  selected: Availability | null
+): Availability | undefined {
+  if (!selected) return undefined;
+  const optId = getAvailabilityOptionId(selected) || undefined;
+  const dt = selected.dateTime;
+  const availId = selected.availabilityId?.trim();
+  if (availId && optId) {
+    const exact = merged.find(
+      (a) =>
+        a.availabilityId === availId &&
+        getAvailabilityOptionId(a) === optId
+    );
+    if (exact) return exact;
+  }
+  return merged.find((a) => a.dateTime === dt && getAvailabilityOptionId(a) === optId);
+}
+
+export function getAvailabilityOptionId(availability: Availability, fallbackOptionId?: string): string {
+  const productOptionId = availability.productOptionId?.trim();
+  if (productOptionId) return productOptionId;
+  const productId = availability.productId?.trim();
+  if (productId?.startsWith('po_')) return productId;
+  return fallbackOptionId?.trim() ?? '';
+}
+
+export function availabilityWithOptionId(availability: Availability, fallbackOptionId?: string): Availability {
+  const productOptionId = getAvailabilityOptionId(availability, fallbackOptionId);
+  return productOptionId ? { ...availability, productOptionId } : availability;
+}
+
+/** Prefer full availability rows over calendar summary rows when merging fetches. */
+export function mergeAvailabilityRecord(
+  existing: Availability | undefined,
+  incoming: Availability,
+): Availability {
+  if (!existing) return incoming;
+  const existingIsSummary = existing.isSummary === true;
+  const incomingIsSummary = incoming.isSummary === true;
+  if (existingIsSummary && !incomingIsSummary) return incoming;
+  if (!existingIsSummary && incomingIsSummary) return existing;
+  return incoming;
+}
+
+export function mergeAvailabilitiesIntoMap(
+  map: Map<string, Availability>,
+  availabilities: Availability[],
+): void {
+  for (const availability of availabilities) {
+    const key = getAvailabilityCacheKey(availability);
+    map.set(key, mergeAvailabilityRecord(map.get(key), availability));
+  }
+}
+
+export function getAvailabilityCacheKey(availability: Availability): string {
+  return `${availability.dateTime}-${getAvailabilityOptionId(availability)}`;
+}
+
+export function pickDefaultAvailabilityForTimes(
+  times: Availability[],
+  activeOptions: Product['options'],
+): Availability | null {
+  if (times.length === 0) return null;
+  const mostPopularOption = activeOptions.find((opt) => opt.mostPopular);
+  const candidate = mostPopularOption
+    ? times.find(
+        (avail) => getAvailabilityOptionId(avail) === mostPopularOption.optionId && avail.vacancies > 0,
+      )
+    : null;
+  const fallback = times.find((avail) => avail.vacancies > 0);
+  return candidate ?? fallback ?? null;
+}
+
+export function availabilityMatchesSelectedDate(
+  availability: Availability,
+  selectedDate: string,
+  companyTimezone: string,
+): boolean {
+  try {
+    const dateInCompanyTz = formatInTimeZone(
+      parseAvailabilityDateTime(availability.dateTime),
+      companyTimezone,
+      'yyyy-MM-dd',
+    );
+    return dateInCompanyTz === selectedDate;
+  } catch {
+    return false;
+  }
+}
+
+export function shouldSyncSelectedAvailability(
+  current: Availability,
+  updated: Availability,
+): boolean {
+  return (
+    current !== updated &&
+    (current.isSummary !== updated.isSummary ||
+      current.vacancies !== updated.vacancies ||
+      current.availabilityId !== updated.availabilityId ||
+      (current.returnOptions?.length ?? 0) !== (updated.returnOptions?.length ?? 0))
+  );
+}
+
+export function mergePrecomputedPricesFromAvailabilityResult(
+  next: Record<string, PrecomputedPricesByCategory>,
+  result: GetAvailabilitiesResponse,
+  fallbackOptionId?: string,
+) {
+  if (result.precomputedPricesByOption) {
+    Object.entries(result.precomputedPricesByOption).forEach(([optionId, prices]) => {
+      if (prices && Object.keys(prices).length > 0) next[optionId] = prices;
+    });
+  }
+  if (fallbackOptionId && result.precomputedPrices && Object.keys(result.precomputedPrices).length > 0) {
+    next[fallbackOptionId] = result.precomputedPrices;
+  }
+}
+
+/** Ticket rates for one availability row - mirrors main cart pricing so baseline slots match BE. */
+export function buildPricingFromAvailability(
+  selectedAvailability: Availability | null,
+  activeOptions: Product['options'],
+  precomputedPricesByOption: Record<string, PrecomputedPricesByCategory> | null | undefined,
+  currency: Currency,
+  pricingConfig: PricingConfig | null,
+  hasFees: boolean,
+  isSimplifiedPricingView: boolean,
+) {
+  if (!selectedAvailability || !pricingConfig) return [];
+  const optionId = getAvailabilityOptionId(selectedAvailability);
+  const selectedOption = activeOptions.find((opt) => opt.optionId === optionId);
+  const precomputed = optionId ? precomputedPricesByOption?.[optionId] : undefined;
+  const rateToDisplayPrice = (backendInDisplayCurrency: number) =>
+    getDisplayPriceFromBaseInDisplayCurrency(backendInDisplayCurrency, currency, pricingConfig, hasFees);
+  const getBaseInDisplayCurrency = (category: string) => {
+    const fromPrecomputed = precomputed?.[category]?.[currency];
+    if (fromPrecomputed != null) return fromPrecomputed;
+    return 0;
+  };
+  const buildRate = (
+    category: string,
+    backendPriceCAD: number,
+    backendInDisplayCurrency: number,
+    baseInDisplayCurrency: number,
+    appliedAdjustments: Array<{ type: string; id: string; name: string; changeByCurrency?: Record<string, number> }>,
+  ) => {
+    const basePriceCAD = selectedOption?.pricing?.[category.toUpperCase()] ?? 0;
+    const hasOptionScopedPrice = baseInDisplayCurrency > 0;
+    const priceCADForBreakdown =
+      hasOptionScopedPrice && currency === 'CAD' ? baseInDisplayCurrency : backendPriceCAD;
+    const displayCurrencyPriceForFallback = hasOptionScopedPrice
+      ? baseInDisplayCurrency
+      : backendInDisplayCurrency;
+    const isPublicMode = isSimplifiedPricingView;
+    const breakdown = computePriceBreakdown(
+      pricingConfig,
+      currency,
+      priceCADForBreakdown,
+      basePriceCAD,
+      hasFees,
+      appliedAdjustments,
+      undefined,
+      baseInDisplayCurrency,
+      isPublicMode,
+    );
+    const price = breakdown?.finalPrice ?? rateToDisplayPrice(displayCurrencyPriceForFallback);
+    return { category, baseInDisplayCurrency, appliedAdjustments, price, priceCAD: priceCADForBreakdown };
+  };
+  return (
+    selectedAvailability.rates?.map((rate) => {
+      const backendPriceCAD = rate.price ?? 0;
+      const backendInDisplayCurrency =
+        rate.priceByCurrency?.[currency] ?? (currency === 'CAD' ? backendPriceCAD : 0);
+      const baseInDisplayCurrency = getBaseInDisplayCurrency(rate.category);
+      const built = buildRate(
+        rate.category,
+        backendPriceCAD,
+        backendInDisplayCurrency,
+        baseInDisplayCurrency,
+        rate.appliedAdjustments ?? rate.applied_adjustments ?? [],
+      );
+      return {
+        category: rate.category,
+        rateId: rate.rateId || rate.category,
+        available: rate.available,
+        price: built.price,
+        priceCAD: built.priceCAD,
+        baseInDisplayCurrency: built.baseInDisplayCurrency,
+        appliedAdjustments: built.appliedAdjustments,
+      };
+    }) ||
+    selectedAvailability.pricesByCategory?.retailPrices?.map((p) => {
+      const priceCADFromApi = p.price / 100;
+      const baseInDisplayCurrency = getBaseInDisplayCurrency(p.category);
+      const backendInDisplayCurrency = currency === 'CAD' ? priceCADFromApi : 0;
+      const built = buildRate(p.category, priceCADFromApi, backendInDisplayCurrency, baseInDisplayCurrency, []);
+      return {
+        category: p.category,
+        rateId: p.category,
+        available: selectedAvailability.vacancies,
+        price: built.price,
+        priceCAD: built.priceCAD,
+        baseInDisplayCurrency: built.baseInDisplayCurrency,
+        appliedAdjustments: built.appliedAdjustments,
+      };
+    }) ||
+    []
+  );
+}
+
+export function findMergedReturnVacancies(
+  outbound: Availability | undefined,
+  selectedReturn: ReturnOption | null | undefined
+): number | null {
+  if (!selectedReturn?.returnAvailabilityId || !outbound?.returnOptions?.length) return null;
+  const ro = outbound.returnOptions.find(
+    (r) => r.returnAvailabilityId === selectedReturn.returnAvailabilityId
+  );
+  return ro ? ro.vacancies : null;
+}
+
+export function normalizeAddOnSelections(
+  selections: Array<{ addOnId: string; variantId?: string; quantity?: number }>
+): Array<{ addOnId: string; variantId?: string; quantity?: number }> {
+  const qtyByKey = new Map<string, number>();
+  for (const sel of selections) {
+    const addOnId = sel.addOnId?.trim();
+    if (!addOnId) continue;
+    const variantId = sel.variantId?.trim() || '';
+    const key = `${addOnId}::${variantId}`;
+    qtyByKey.set(key, (qtyByKey.get(key) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
+  }
+  return Array.from(qtyByKey.entries()).map(([key, qty]) => {
+    const [addOnId, variantIdRaw] = key.split('::');
+    const variantId = variantIdRaw?.trim() || undefined;
+    return { addOnId, variantId, quantity: qty };
+  });
+}
+
+export function parseAvailabilityDateTime(value: string): Date {
+  // If API omits timezone offset, treat it as UTC to prevent user-local day shifts.
+  const hasExplicitOffset = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(value);
+  return parseISO(hasExplicitOffset ? value : `${value}Z`);
+}
+
+export function getStartOfCurrentDay(companyTimezone: string): Date {
+  const todayStr = formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd');
+  return fromZonedTime(parseISO(`${todayStr}T00:00:00.000`), companyTimezone);
+}
+
+export function getInitialAvailabilityRangeStart(companyTimezone: string): Date {
+  const todayStr = formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd');
+  const seasonStartStr = formatInTimeZone(EARLIEST_AVAILABILITY_DATE, companyTimezone, 'yyyy-MM-dd');
+  const seasonEndStr = formatInTimeZone(LATEST_AVAILABILITY_DATE, companyTimezone, 'yyyy-MM-dd');
+  const initialDateStr =
+    todayStr < seasonStartStr
+      ? seasonStartStr
+      : todayStr > seasonEndStr
+        ? seasonStartStr
+        : todayStr;
+
+  return fromZonedTime(parseISO(`${initialDateStr}T00:00:00.000`), companyTimezone);
+}
+
+export function getInitialAvailabilityRangeEnd(initialStart: Date): Date {
+  return addWeeks(initialStart, INITIAL_FETCH_WEEKS + VISIBLE_RANGE_BUFFER_WEEKS);
+}
+
+export function deriveDefaultQuantitiesFromAvailabilities(
+  availabilities: Availability[]
+): Record<string, number> | null {
+  const firstWithRates = availabilities.find((avail) => avail.rates && avail.rates.length > 0);
+  if (!firstWithRates?.rates?.length) return null;
+
+  const initialQuantities: Record<string, number> = {};
+  firstWithRates.rates.forEach((rate) => {
+    initialQuantities[rate.category] = rate.category === 'ADULT' ? 1 : 0;
+  });
+
+  return Object.keys(initialQuantities).length > 0 ? initialQuantities : null;
+}

package/src/components/booking/standard-booking-checkout-builders.ts

@@ -0,0 +1,289 @@
+import type {
+  AddOn,
+  CheckoutBreakdown,
+  PricingV2QuoteSnapshot,
+} from '../../lib/booking-api';
+import type { CheckoutLineInput } from '../../lib/booking/checkout-breakdown';
+import {
+  buildCheckoutBreakdown,
+  buildCheckoutBreakdownFromPricingV2Quote,
+} from '../../lib/booking/checkout-breakdown';
+import type {
+  OrderSummaryFeeLine,
+  OrderSummaryTicketLine,
+  PriceBreakdown as PriceBreakdownData,
+} from '../../lib/booking/pricing';
+import type { CheckoutModalLineItem, CheckoutModalSummaryOverride } from './CheckoutModal';
+import type { PriceSummaryLine } from './PriceSummary';
+import { buildCheckoutModalSummaryFromPricingV2Quote } from './pricing-v2-checkout-summary';
+
+type AppliedAdjustment = {
+  type: string;
+  id: string;
+  name: string;
+  changeByCurrency?: Record<string, number>;
+};
+
+export type StandardBookingAddOnSelection = {
+  addOnId: string;
+  variantId?: string;
+  quantity?: number;
+};
+
+export type StandardBookingPricingLine = {
+  category: string;
+  priceCAD: number;
+  baseInDisplayCurrency?: number;
+  appliedAdjustments?: AppliedAdjustment[];
+};
+
+export interface BuildStandardBookingCheckoutArtifactsParams {
+  ticketLineItems: OrderSummaryTicketLine[];
+  pricing: StandardBookingPricingLine[];
+  getPriceBreakdown: (
+    category: string,
+    priceCAD: number,
+    baseInDisplayCurrency: number | undefined,
+    appliedAdjustments?: AppliedAdjustment[]
+  ) => PriceBreakdownData | null;
+  totalQuantity: number;
+  checkoutReturnLineAmount: number;
+  returnOptionLabel: string;
+  personLabel: string;
+  peopleLabel: string;
+  cancellationPolicyFee: number;
+  cancellationPolicyLabel: string;
+  addOnSelections: StandardBookingAddOnSelection[];
+  addOns: AddOn[];
+  feeLineItems: OrderSummaryFeeLine[];
+  feeLineItemsWithAddOns: OrderSummaryFeeLine[];
+  priceSummaryLines?: PriceSummaryLine[];
+  checkoutPriceSummaryLineCount: number;
+  isTaxIncludedInPrice: boolean;
+  taxForBreakdown: number;
+  taxLabel: string;
+  effectivePromoDiscountAmount: number;
+  appliedPromoCode?: string | null;
+  discountLabel: string;
+  promoLineType: 'GIFT_CARD' | 'PROMO_CODE';
+  displayTotalPrice: number;
+  currency: string;
+  pricingV2Quote?: PricingV2QuoteSnapshot | null;
+  roundingLabel: string;
+}
+
+export interface StandardBookingCheckoutArtifacts {
+  checkoutBreakdown: CheckoutBreakdown;
+  pricingV2SummaryOverride: CheckoutModalSummaryOverride | undefined;
+  amountDueForCheckout: number;
+  ticketLinesForModal: CheckoutModalLineItem[];
+  feeLineItemsForModal: OrderSummaryFeeLine[];
+}
+
+function buildStandardBookingAddOnLineItems(
+  addOnSelections: StandardBookingAddOnSelection[],
+  addOns: AddOn[]
+): {
+  checkoutLines: CheckoutLineInput[];
+  modalFeeLineItems: OrderSummaryFeeLine[];
+} {
+  const checkoutLines: CheckoutLineInput[] = [];
+  const modalFeeLineItems: OrderSummaryFeeLine[] = [];
+
+  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 quantity = selection.quantity ?? 1;
+    const amount = ((addOn.price ?? 0) + (variant?.priceAdjustment ?? 0)) * quantity;
+    const label = variant?.label
+      ? `${addOn.name} (${variant.label})${quantity > 1 ? ` \u00d7 ${quantity}` : ''}`
+      : addOn.name;
+
+    checkoutLines.push({
+      label,
+      amount,
+      type: 'FEE',
+      quantity,
+    });
+    modalFeeLineItems.push({
+      name: label,
+      totalAmount: amount,
+      description: addOn.description ?? undefined,
+    });
+  }
+
+  return { checkoutLines, modalFeeLineItems };
+}
+
+function externalPriceSummaryLineItems(
+  priceSummaryLines: PriceSummaryLine[] | undefined,
+  checkoutPriceSummaryLineCount: number
+): Extract<PriceSummaryLine, { kind: 'line' }>[] {
+  return (
+    priceSummaryLines
+      ?.slice(checkoutPriceSummaryLineCount)
+      .filter((line): line is Extract<PriceSummaryLine, { kind: 'line' }> => line.kind === 'line') ??
+    []
+  );
+}
+
+function buildStandardBookingTicketLinesForModal({
+  ticketLineItems,
+  pricing,
+  getPriceBreakdown,
+}: Pick<
+  BuildStandardBookingCheckoutArtifactsParams,
+  'ticketLineItems' | 'pricing' | 'getPriceBreakdown'
+>): CheckoutModalLineItem[] {
+  return ticketLineItems.map((line) => {
+    const rate = pricing.find((candidate) => candidate.category === line.category);
+    const breakdown = getPriceBreakdown(
+      line.category,
+      rate?.priceCAD ?? 0,
+      rate?.baseInDisplayCurrency,
+      rate?.appliedAdjustments ?? []
+    );
+    return { line, breakdown };
+  });
+}
+
+export function buildStandardBookingCheckoutArtifacts(
+  params: BuildStandardBookingCheckoutArtifactsParams
+): StandardBookingCheckoutArtifacts {
+  const {
+    ticketLineItems,
+    pricing,
+    getPriceBreakdown,
+    totalQuantity,
+    checkoutReturnLineAmount,
+    returnOptionLabel,
+    personLabel,
+    peopleLabel,
+    cancellationPolicyFee,
+    cancellationPolicyLabel,
+    addOnSelections,
+    addOns,
+    feeLineItems,
+    feeLineItemsWithAddOns,
+    priceSummaryLines,
+    checkoutPriceSummaryLineCount,
+    isTaxIncludedInPrice,
+    taxForBreakdown,
+    taxLabel,
+    effectivePromoDiscountAmount,
+    appliedPromoCode,
+    discountLabel,
+    promoLineType,
+    displayTotalPrice,
+    currency,
+    pricingV2Quote,
+    roundingLabel,
+  } = params;
+
+  const personCountLabel = totalQuantity === 1 ? personLabel : peopleLabel;
+  const externalSummaryLines = externalPriceSummaryLineItems(
+    priceSummaryLines,
+    checkoutPriceSummaryLineCount
+  );
+  const { checkoutLines: addOnCheckoutLines } = buildStandardBookingAddOnLineItems(
+    addOnSelections,
+    addOns
+  );
+  const externalCheckoutLines: CheckoutLineInput[] = externalSummaryLines.map((line) => ({
+    label: line.label,
+    amount: line.amount,
+    type: line.type ?? 'FEE',
+    quantity: line.quantity ?? undefined,
+  }));
+  const lines: CheckoutLineInput[] = [
+    ...ticketLineItems.map((line) => ({
+      label: line.category,
+      amount: line.itemTotal,
+      type: 'TICKET',
+      quantity: line.qty,
+    })),
+    ...(checkoutReturnLineAmount !== 0
+      ? [
+          {
+            label: `${returnOptionLabel} (${totalQuantity} ${personCountLabel})`,
+            amount: checkoutReturnLineAmount,
+            type: 'RETURN_OPTION',
+            quantity: totalQuantity,
+          },
+        ]
+      : []),
+    ...(cancellationPolicyFee > 0
+      ? [
+          {
+            label: cancellationPolicyLabel,
+            amount: cancellationPolicyFee,
+            type: 'CANCELLATION_UPGRADE',
+          },
+        ]
+      : []),
+    ...addOnCheckoutLines,
+    ...externalCheckoutLines,
+    ...feeLineItems.map((fee) => ({
+      label: `${fee.name} (${totalQuantity} ${personCountLabel})`,
+      amount: fee.totalAmount,
+      type: 'FEE',
+      quantity: totalQuantity,
+    })),
+    ...(!isTaxIncludedInPrice && taxForBreakdown > 0
+      ? [
+          {
+            label: taxLabel,
+            amount: taxForBreakdown,
+            type: 'TAX',
+          },
+        ]
+      : []),
+    ...(effectivePromoDiscountAmount > 0
+      ? [
+          {
+            label: appliedPromoCode ? `Promo: ${appliedPromoCode}` : discountLabel,
+            amount: -effectivePromoDiscountAmount,
+            type: promoLineType,
+          },
+        ]
+      : []),
+  ];
+  const legacyCheckoutBreakdown = buildCheckoutBreakdown({
+    lines,
+    totalAmount: displayTotalPrice,
+    currency,
+    roundingLabel,
+  });
+  const checkoutBreakdown =
+    buildCheckoutBreakdownFromPricingV2Quote(pricingV2Quote, roundingLabel) ??
+    legacyCheckoutBreakdown;
+  const pricingV2SummaryOverride = buildCheckoutModalSummaryFromPricingV2Quote(
+    pricingV2Quote,
+    roundingLabel
+  );
+  const ticketLinesForModal = buildStandardBookingTicketLinesForModal({
+    ticketLineItems,
+    pricing,
+    getPriceBreakdown,
+  });
+  const externalModalFeeLineItems: OrderSummaryFeeLine[] = externalSummaryLines.map((line) => ({
+    name: line.label,
+    totalAmount: line.amount,
+    showQuantityLabel: false,
+  }));
+
+  return {
+    checkoutBreakdown,
+    pricingV2SummaryOverride,
+    amountDueForCheckout: checkoutBreakdown.totalAmount,
+    ticketLinesForModal,
+    feeLineItemsForModal: [...feeLineItemsWithAddOns, ...externalModalFeeLineItems],
+  };
+}