@ticketboothapp/booking 0.1.11 → 0.1.12

package/src/lib/{constants.ts → booking-constants.ts}

@@ -1,17 +1,23 @@
 /**
- * Shared constants for booking components
+ * Shared constants for the booking flow.
+ * Aligns with TicketBooth availability season (Moraine Lake road).
  */
 
-// Date range for availability fetching
+// Date range for availability fetching (YYYY-MM-DD)
 export const EARLIEST_AVAILABILITY_DATE = new Date('2026-06-01');
 export const LATEST_AVAILABILITY_DATE = new Date('2026-10-12');
 
+// Initial fetch window (weeks) - smaller for faster first paint
+export const INITIAL_FETCH_WEEKS = 2;
+
 // Mini calendar date range (June 2026 - October 2026)
 export const MINI_CALENDAR_START_MONTH = new Date(2026, 5, 1); // June 1, 2026 (month index 5 = June)
 export const MINI_CALENDAR_END_MONTH = new Date(2026, 9, 1); // October 1, 2026 (month index 9 = October)
 export const MINI_CALENDAR_START_DATE = new Date(2026, 5, 1); // June 1, 2026
 export const MINI_CALENDAR_END_DATE = new Date(2026, 9, 12); // October 12, 2026 (inclusive)
 
-// Initial fetch buffer (weeks)
-export const INITIAL_FETCH_WEEKS = 4; // 2 visible weeks + 2 buffer weeks
-export const VISIBLE_RANGE_BUFFER_WEEKS = 2; // Buffer weeks before/after visible range
+// Buffer weeks before/after visible range
+export const VISIBLE_RANGE_BUFFER_WEEKS = 2;
+
+/** 8am MDT Mar 11, 2025 – full booking flow becomes available at this moment (UTC). */
+export const BOOKING_LAUNCH_AT = new Date('2026-03-11T14:00:00.000Z');

package/src/lib/booking-types.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared types for the booking flow.
+ * Aligns with TicketBooth API responses where applicable.
+ */
+
+export interface ProductDisplayConfig {
+  path: string;
+  slug: string;
+  imageIds: string[];
+  /** Optional: image IDs for the booking flow collage (4 images for the grid). Falls back to imageIds if not set. */
+  collageImageIds?: string[];
+  shortName: string;
+  description?: string;
+  themePage: string;
+  mostPopular?: boolean;
+}
+
+export interface ProductConfig {
+  productId: string;
+  optionIds: string[];
+  /** STANDARD or PRIVATE_SHUTTLE - affects availability date format. Default STANDARD. */
+  productType?: 'STANDARD' | 'PRIVATE_SHUTTLE';
+  display: ProductDisplayConfig;
+}
+
+export interface ProductsConfig {
+  version: string;
+  generatedAt: string;
+  companyId: string;
+  products: ProductConfig[];
+}
+
+/** Primary option ID for a product (used for availability/reserve API calls) */
+export function getPrimaryOptionId(product: ProductConfig): string {
+  return product.optionIds[0] ?? product.productId;
+}

package/src/lib/currency.ts

@@ -1,88 +1,81 @@
-import type { Currency } from '@/components/CurrencySwitcher';
-import type { Locale } from '@/lib/i18n/config';
-
 /**
- * Default exchange rates from CAD to other currencies (fallback if API doesn't provide them).
- * Keep in sync with backend ticketbooth-be/src/main/resources/pricing.json → companies.default.currencyRates.CAD
+ * Currency types supported by the booking system
  */
+export type Currency = 'CAD' | 'USD' | 'EUR' | 'GBP' | 'AUD';
+
+/** Default exchange rates from CAD to other currencies (fallback if API does not provide them). */
 export const DEFAULT_EXCHANGE_RATES: Record<Currency, number> = {
-  CAD: 1.0, // Base currency
+  CAD: 1.0,
   USD: 0.74,
   EUR: 0.62,
   GBP: 0.53,
   AUD: 1.04,
 };
 
-/**
- * Rounding targets for price rounding (from pricing.json).
- * Rounds up to nearest value ending in .99 (e.g., 24.99, 29.99).
- * Only used on BE when generating prices (product-fees / pricing config). Currently disabled on FE.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- targets used when rounding re-enabled
-export function roundToNearestTarget(amount: number, _targets: number[] = [4.99, 9.99]): number {
-  return amount;
-  // Re-enable rounding:
-  // if (_targets.length === 0) return amount;
-  // const integerPart = Math.floor(amount);
-  // const fractionalPart = amount - integerPart;
-  // const sortedTargets = [..._targets].sort((a, b) => a - b);
-  // let target = sortedTargets.find(t => t >= fractionalPart);
-  // if (!target) {
-  //   target = sortedTargets[sortedTargets.length - 1];
-  //   return integerPart + 1 + target;
-  // }
-  // return integerPart + target;
+/** Integer cents using half-up rounding. */
+export function toMoneyCents(amount: number): number {
+  return Math.round(amount * 100);
+}
+
+/** True when two money amounts differ by at most `toleranceCents` (default 1 cent). */
+export function isMoneyDeltaNegligible(a: number, b: number, toleranceCents = 1): boolean {
+  return Math.abs(toMoneyCents(a) - toMoneyCents(b)) <= toleranceCents;
+}
+
+/** For change-booking: send original total when delta is only rounding noise. */
+export function reconcileChangeBookingProposedTotal(
+  proposedTotal: number,
+  originalTotal: number,
+  toleranceCents = 1
+): number {
+  return isMoneyDeltaNegligible(proposedTotal, originalTotal, toleranceCents)
+    ? originalTotal
+    : proposedTotal;
 }
 
 /**
  * Format a numeric amount in the given currency using Intl.NumberFormat.
  * Falls back to a simple "123.45 CUR" string if formatting fails.
  */
-// Currency symbols map - using industry standard ISO 4217 symbols
-// When multiple dollar currencies are present, use distinguishing prefixes
 const CURRENCY_SYMBOLS: Record<Currency, string> = {
-  CAD: 'C$',    // Canadian Dollar - C$ is the standard when distinction needed
-  USD: 'US$',   // US Dollar - US$ when distinction needed (otherwise just $)
-  EUR: '€',     // Euro - standard symbol
-  GBP: '£',     // British Pound - standard symbol
-  AUD: 'A$',    // Australian Dollar - A$ is standard
+  CAD: 'C$',
+  USD: 'US$',
+  EUR: '€',
+  GBP: '£',
+  AUD: 'A$',
 };
 
 /**
  * Format a numeric amount in the given currency, respecting locale conventions.
  * For French: uses comma as decimal separator and proper symbol placement (e.g., "109,99 €")
  * For English: uses period as decimal separator (e.g., "C$109.99")
- * 
+ *
  * @param amount The amount to format
  * @param currency The currency code
  * @param locale Optional locale ('en' or 'fr'). If not provided, defaults to 'en'
  */
-export function formatCurrencyAmount(amount: number, currency: Currency, locale: Locale = 'en'): string {
-  // Use explicit symbols and format number part with locale conventions
-  // This ensures USD shows as "US$" and AUD shows as "A$" correctly
+export function formatCurrencyAmount(amount: number, currency: Currency, locale: 'en' | 'fr' = 'en'): string {
   const symbol = CURRENCY_SYMBOLS[currency] || currency;
-  
+
   // Handle negative amounts: extract sign and format absolute value.
-  // Don't show minus for zero or tiny rounding errors (e.g. -0.00 or -0.0001).
   const absoluteAmount = Math.abs(amount);
   const isNegative = amount < -0.001;
-  
+
   // Format the number part with locale-appropriate separators
   const numberFormatter = new Intl.NumberFormat(locale === 'fr' ? 'fr-CA' : 'en-CA', {
     minimumFractionDigits: 2,
     maximumFractionDigits: 2,
   });
-  
+
   const formattedNumber = numberFormatter.format(absoluteAmount);
-  
-  // For French: symbol after amount (e.g., "109,99 €" or "-109,99 €")
-  // For English: symbol before amount (e.g., "US$109.99" or "-US$109.99")
+
+  // For French: symbol after amount (e.g., "109,99 €")
+  // For English: symbol before amount (e.g., "C$109.99")
   const sign = isNegative ? '-' : '';
-  
+
   if (locale === 'fr') {
     return `${sign}${formattedNumber} ${symbol}`;
   } else {
     return `${sign}${symbol}${formattedNumber}`;
   }
 }
-

package/src/lib/dap-descriptions.ts

@@ -0,0 +1,50 @@
+/**
+ * Copy for dependent add-on (photo) booking dialog — src/data/dap-descriptions/{slug}.{locale}.json
+ */
+
+import type { PhotoDapSlug } from '@/lib/photo-dap-config';
+
+import sessionCouplesEn from '@/data/dap-descriptions/session-couples-families-friends.en.json';
+import sessionElopementsEn from '@/data/dap-descriptions/session-elopements.en.json';
+import sessionProposalsEn from '@/data/dap-descriptions/session-proposals.en.json';
+
+import type { TourDescriptionSubsection } from '@/components/booking/TourDescription';
+
+export type DapSectionContent = string | string[] | TourDescriptionSubsection[];
+
+export interface DapDescriptionResult {
+  paragraphs: string[];
+  review?: { text: string; name: string };
+  sections: { title: string; content: DapSectionContent }[];
+}
+
+interface DapDescriptionData {
+  paragraphs: string[];
+  review?: { text: string; name: string };
+  sections: { title: string; content: DapSectionContent }[];
+}
+
+const EN: Record<PhotoDapSlug, DapDescriptionData> = {
+  'session-couples-families-friends': sessionCouplesEn as DapDescriptionData,
+  'session-elopements': sessionElopementsEn as DapDescriptionData,
+  'session-proposals': sessionProposalsEn as DapDescriptionData,
+};
+
+const BY_LOCALE: Record<string, Record<PhotoDapSlug, DapDescriptionData>> = {
+  en: EN,
+};
+
+export function getDapDescription(
+  slug: PhotoDapSlug,
+  locale: string
+): DapDescriptionResult | null {
+  const localeKey = locale.split('-')[0] ?? 'en';
+  const table = BY_LOCALE[localeKey] ?? BY_LOCALE.en;
+  const data = table[slug];
+  if (!data) return null;
+  return {
+    paragraphs: data.paragraphs ?? [],
+    review: data.review,
+    sections: data.sections ?? [],
+  };
+}

package/src/lib/dap-itinerary-preview.ts

@@ -0,0 +1,315 @@
+/**
+ * Helpers for showing primary-booking itinerary in the DAP flow without last-name lookup.
+ * Real steps come from GET /1/dependent-add-ons/availability when the API includes
+ * `data.itineraryDisplay` (or `data.primaryItineraryDisplay`) — see dependent-add-on-api.ts.
+ *
+ * Photo-session preview row placement uses the selected slot’s ISO times plus each
+ * `arrive` → next `depart` on-site window (not string “last moraine mention”, which
+ * incorrectly anchored after “Depart Moraine Lake”).
+ *
+ * Availability: [filterDapSlotsToPrimaryItineraryWindows] drops any slot whose
+ * [slotStart, slotEnd] is not fully contained in at least one such window (defensive
+ * client filter; TicketBooth should enforce the same when generating offerings).
+ */
+
+import type { ItineraryDisplayStep, ItineraryStepType } from '@/lib/booking-api';
+import { ItineraryStepType as StepTypeConst } from '@/lib/booking-api';
+import { getStepLabel, type TranslationFn } from '@/lib/booking/itinerary-labels';
+
+const ITINERARY_STEP_TYPES: readonly string[] = Object.values(StepTypeConst);
+
+/** Clock / rounding tolerance when comparing itinerary strings to slot ISO instants. */
+const TIME_MATCH_TOLERANCE_MS = 90_000;
+
+export type DapItineraryStep = {
+  stepType: string;
+  time?: string | null;
+  place?: string | null;
+  label?: string | null;
+};
+
+export type DapPhotoSessionInsertOptions = {
+  slotStartIso: string;
+  slotEndIso: string;
+};
+
+function pickStr(v: unknown): string | undefined {
+  return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+}
+
+export function normalizeDapItinerarySteps(raw: unknown): DapItineraryStep[] {
+  if (!Array.isArray(raw)) return [];
+  const out: DapItineraryStep[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') continue;
+    const r = item as Record<string, unknown>;
+    const stepType = pickStr(r.stepType ?? r.step_type) ?? 'other';
+    out.push({
+      stepType,
+      time: pickStr(r.time) ?? null,
+      place: pickStr(r.place) ?? null,
+      label: pickStr(r.label) ?? null,
+    });
+  }
+  return out;
+}
+
+function normStepType(s: DapItineraryStep): string {
+  return (s.stepType ?? '').toLowerCase().trim();
+}
+
+/** Plain-text blob for matching place names in fallbacks */
+function stepBlob(s: DapItineraryStep): string {
+  return `${s.stepType} ${s.place ?? ''} ${s.label ?? ''} ${s.time ?? ''}`.toLowerCase();
+}
+
+/**
+ * Parse a step’s display `time` onto the trip’s local calendar day (from slot start).
+ * Supports ISO-ish strings, 12h (“4:30 AM”), and 24h (“14:30”).
+ */
+function stepTimeToMs(
+  step: DapItineraryStep,
+  tripDayRef: Date
+): number | null {
+  const raw = step.time?.trim();
+  if (!raw) return null;
+  const cleaned = raw.replace(/^at\s+/i, '').trim();
+  if (!cleaned) return null;
+
+  if (/^\d{4}-\d{2}-\d{2}/.test(cleaned) || cleaned.includes('T')) {
+    const ms = Date.parse(cleaned);
+    return Number.isNaN(ms) ? null : ms;
+  }
+
+  const y = tripDayRef.getFullYear();
+  const mo = tripDayRef.getMonth();
+  const d = tripDayRef.getDate();
+
+  const m12 = cleaned.match(/^(\d{1,2})(?::(\d{2}))?\s*(AM|PM)\s*$/i);
+  if (m12) {
+    let h = parseInt(m12[1], 10);
+    const min = m12[2] ? parseInt(m12[2], 10) : 0;
+    const ap = m12[3].toUpperCase();
+    if (ap === 'PM' && h !== 12) h += 12;
+    if (ap === 'AM' && h === 12) h = 0;
+    if (h < 0 || h > 23 || min < 0 || min > 59) return null;
+    return new Date(y, mo, d, h, min, 0, 0).getTime();
+  }
+
+  const m24 = cleaned.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+  if (m24) {
+    const h = parseInt(m24[1], 10);
+    const min = parseInt(m24[2], 10);
+    if (h >= 0 && h <= 23 && min >= 0 && min <= 59) {
+      return new Date(y, mo, d, h, min, 0, 0).getTime();
+    }
+  }
+
+  const trial = Date.parse(
+    `${tripDayRef.toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+    })} ${cleaned}`
+  );
+  return Number.isNaN(trial) ? null : trial;
+}
+
+type ArriveDepartWindow = {
+  arriveIndex: number;
+  departIndex: number;
+  startMs: number;
+  endMs: number;
+  blob: string;
+};
+
+function listArriveDepartWindows(
+  steps: DapItineraryStep[],
+  tripDayRef: Date
+): ArriveDepartWindow[] {
+  const out: ArriveDepartWindow[] = [];
+  for (let i = 0; i < steps.length; i++) {
+    if (normStepType(steps[i]) !== 'arrive') continue;
+    const startMs = stepTimeToMs(steps[i], tripDayRef);
+    let j = i + 1;
+    while (j < steps.length && normStepType(steps[j]) !== 'depart') {
+      j += 1;
+    }
+    if (j >= steps.length) continue;
+    const endMs = stepTimeToMs(steps[j], tripDayRef);
+    if (startMs == null || endMs == null) continue;
+    if (endMs < startMs) continue;
+    out.push({
+      arriveIndex: i,
+      departIndex: j,
+      startMs,
+      endMs,
+      blob: `${stepBlob(steps[i])} ${stepBlob(steps[j])}`,
+    });
+  }
+  return out;
+}
+
+function slotFitsWindow(
+  slotStartMs: number,
+  slotEndMs: number,
+  w: ArriveDepartWindow
+): boolean {
+  return (
+    slotStartMs >= w.startMs - TIME_MATCH_TOLERANCE_MS &&
+    slotEndMs <= w.endMs + TIME_MATCH_TOLERANCE_MS
+  );
+}
+
+function slotWindowOverlapMs(
+  slotStartMs: number,
+  slotEndMs: number,
+  w: ArriveDepartWindow
+): number {
+  const lo = Math.max(slotStartMs, w.startMs);
+  const hi = Math.min(slotEndMs, w.endMs);
+  return Math.max(0, hi - lo);
+}
+
+/**
+ * When no arrive/depart windows parse, place the row before the first `depart` after
+ * the first `arrive` at Moraine (or first arrive→depart pair, then pickup heuristic).
+ */
+function fallbackInsertDepartIndex(steps: DapItineraryStep[]): number {
+  for (let i = 0; i < steps.length; i++) {
+    if (normStepType(steps[i]) !== 'arrive') continue;
+    if (!stepBlob(steps[i]).includes('moraine')) continue;
+    for (let j = i + 1; j < steps.length; j++) {
+      if (normStepType(steps[j]) === 'depart') return j;
+    }
+  }
+
+  const firstArrive = steps.findIndex((s) => normStepType(s) === 'arrive');
+  if (firstArrive >= 0) {
+    const departAfter = steps.findIndex(
+      (s, idx) => idx > firstArrive && normStepType(s) === 'depart'
+    );
+    if (departAfter >= 0) return departAfter;
+  }
+
+  const pickupIdx = steps.findIndex((s) => normStepType(s) === 'pickup');
+  if (pickupIdx >= 0) return Math.min(pickupIdx + 1, steps.length);
+  return 0;
+}
+
+/**
+ * Index in `steps` **before which** the photo row is rendered (i.e. immediately after
+ * the preceding step, typically right after “Arrive at …” and before “Depart …”).
+ */
+export function getPhotoSessionInsertPosition(
+  steps: DapItineraryStep[],
+  options?: DapPhotoSessionInsertOptions | null
+): number {
+  if (steps.length === 0) return 0;
+
+  const slotStartMs = options?.slotStartIso ? Date.parse(options.slotStartIso) : NaN;
+  const slotEndMs = options?.slotEndIso ? Date.parse(options.slotEndIso) : NaN;
+  const hasValidSlot =
+    !Number.isNaN(slotStartMs) &&
+    !Number.isNaN(slotEndMs) &&
+    slotEndMs >= slotStartMs;
+
+  const tripDayRef = hasValidSlot ? new Date(slotStartMs) : new Date();
+  const windows = listArriveDepartWindows(steps, tripDayRef);
+
+  if (hasValidSlot && windows.length > 0) {
+    for (const w of windows) {
+      if (slotFitsWindow(slotStartMs, slotEndMs, w)) {
+        return w.departIndex;
+      }
+    }
+
+    let bestDepart = windows[windows.length - 1].departIndex;
+    let bestOverlap = -1;
+    for (const w of windows) {
+      const ov = slotWindowOverlapMs(slotStartMs, slotEndMs, w);
+      if (ov > bestOverlap) {
+        bestOverlap = ov;
+        bestDepart = w.departIndex;
+      }
+    }
+    if (bestOverlap > 0) {
+      return bestDepart;
+    }
+
+    for (let wi = windows.length - 1; wi >= 0; wi--) {
+      if (windows[wi].blob.includes('moraine')) {
+        return windows[wi].departIndex;
+      }
+    }
+    return windows[windows.length - 1].departIndex;
+  }
+
+  if (windows.length > 0) {
+    for (let wi = windows.length - 1; wi >= 0; wi--) {
+      if (windows[wi].blob.includes('moraine')) {
+        return windows[wi].departIndex;
+      }
+    }
+    return windows[windows.length - 1].departIndex;
+  }
+
+  return fallbackInsertDepartIndex(steps);
+}
+
+/**
+ * Keeps only slots that fall entirely inside an on-site window: each `arrive` step paired
+ * with the next `depart`. Uses the same time parsing and tolerance as preview insertion.
+ *
+ * If no windows can be parsed from `steps`, returns `slots` unchanged (do not hide offers).
+ */
+export function filterDapSlotsToPrimaryItineraryWindows<
+  T extends { slotStart: string; slotEnd: string },
+>(slots: T[], steps: DapItineraryStep[]): T[] {
+  if (steps.length === 0 || slots.length === 0) return slots;
+
+  return slots.filter((slot) => {
+    const slotStartMs = Date.parse(slot.slotStart);
+    const slotEndMs = Date.parse(slot.slotEnd);
+    if (
+      Number.isNaN(slotStartMs) ||
+      Number.isNaN(slotEndMs) ||
+      slotEndMs < slotStartMs
+    ) {
+      return false;
+    }
+
+    const tripDayRef = new Date(slotStartMs);
+    const windows = listArriveDepartWindows(steps, tripDayRef);
+    if (windows.length === 0) return true;
+
+    return windows.some((w) => slotFitsWindow(slotStartMs, slotEndMs, w));
+  });
+}
+
+export function formatDapItineraryStepLabel(step: DapItineraryStep, t: TranslationFn): string {
+  if (step.label?.trim()) return step.label.trim();
+  return getStepLabel(
+    {
+      stepType: step.stepType || 'other',
+      place: step.place ?? '',
+      time: step.time ?? '',
+    },
+    t
+  );
+}
+
+/** Map DAP availability steps to the same shape as main booking [ItineraryBox] uses. */
+export function dapItineraryStepsToDisplay(steps: DapItineraryStep[]): ItineraryDisplayStep[] {
+  return steps.map((s) => {
+    const raw = (s.stepType ?? '').toLowerCase().trim();
+    const stepType = (ITINERARY_STEP_TYPES.includes(raw)
+      ? raw
+      : 'other') as ItineraryStepType;
+    return {
+      stepType,
+      time: s.time?.trim() ?? '',
+      place: s.place ?? undefined,
+    };
+  });
+}