@ticketboothapp/booking 1.2.100 → 1.2.102

package/src/data/dap-descriptions/session-proposals.en.json

@@ -7,27 +7,24 @@
       "title": "What's included",
       "content": [
         {
-          "title": "30-minute session",
+          "title": "Essentials - 30 minutes",
           "items": [
-            "📸 20 to 25 minutes of photography time",
             "📍 2 Locations within walking distance",
-            "🖼️ 25 professionally edited photos delivered in a personalized online gallery"
+            "🖼️ 30 professionally edited photos delivered in a personalized online gallery"
           ]
         },
         {
-          "title": "60-minute session",
+          "title": "Celebration - 60 minutes",
           "items": [
-            "📸 50 to 55 minutes of photography time",
             "📍 2-3 Locations within walking distance",
-            "🖼️ 50 professionally edited photos delivered in a personalized online gallery"
+            "🖼️ 60 professionally edited photos delivered in a personalized online gallery"
           ]
         },
         {
-          "title": "90-minute session",
+          "title": "Immersive - 90 minutes",
           "items": [
-            "📸 80-90 mins of Photography Time",
             "📍 5 Locations within walking distance",
-            "🖼️ 75 professionally edited photos delivered in a personalized online gallery"
+            "🖼️ 90 professionally edited photos delivered in a personalized online gallery"
           ]
         },
         {

package/src/data/products-config.json

@@ -6,6 +6,11 @@
     {
       "productId": "p_qa5keidRoV6H",
       "optionIds": ["po_cSD2wlJfQqc0"],
+      "dependentAddOnProductIds": [
+        "dap_sM8pSzbFfU7P",
+        "dap_6tITweGzVyg8",
+        "dap_Xy3OCPIKQ7vr"
+      ],
       "display": {
         "path": "/moraine-lake-shuttle",
         "slug": "moraine-lake-sunrise-lake-louise-golden-hour",
@@ -20,6 +25,11 @@
     {
       "productId": "p_YKQsLmKhfYFp",
       "optionIds": ["po_82wA2gUZBZ9z"],
+      "dependentAddOnProductIds": [
+        "dap_sM8pSzbFfU7P",
+        "dap_6tITweGzVyg8",
+        "dap_Xy3OCPIKQ7vr"
+      ],
       "display": {
         "path": "/moraine-lake-shuttle",
         "slug": "moraine-lake-sunrise",
@@ -33,6 +43,11 @@
     {
       "productId": "p_CUJ4sVvaOkjk",
       "optionIds": ["po_ImWip6rbg0D6", "po_lOO7wz6uMus1", "po_fvrAfalgI673"],
+      "dependentAddOnProductIds": [
+        "dap_sM8pSzbFfU7P",
+        "dap_6tITweGzVyg8",
+        "dap_Xy3OCPIKQ7vr"
+      ],
       "display": {
         "path": "/moraine-lake-shuttle",
         "slug": "two-lakes-combo",
@@ -47,6 +62,11 @@
     {
       "productId": "p_wQHE15ITi7TS",
       "optionIds": ["po_FTLSMsahWKjM", "po_nbp2pFQo9AH7", "po_nzlCuOVJU181"],
+      "dependentAddOnProductIds": [
+        "dap_sM8pSzbFfU7P",
+        "dap_6tITweGzVyg8",
+        "dap_Xy3OCPIKQ7vr"
+      ],
       "display": {
         "path": "/moraine-lake-shuttle",
         "slug": "moraine-lake-adventure",

package/src/lib/booking/checkout-contact.ts

@@ -0,0 +1,8 @@
+import { normalizeOptionalPhoneNumber } from './phone';
+
+/** Optional phone from checkout — omitted when blank or country-code-only (e.g. "+1"). */
+export function optionalCheckoutContactFields(phoneNumber: string) {
+  return {
+    customerPhoneNumber: normalizeOptionalPhoneNumber(phoneNumber),
+  };
+}

package/src/lib/booking/i18n/messages/en.json

@@ -102,6 +102,12 @@
     "firstNamePlaceholder": "Jane",
     "lastName": "Last Name",
     "lastNamePlaceholder": "Smith",
+    "phoneOptional": "Phone",
+    "phoneOptionalPlaceholder": "e.g. +1 403 555 0123",
+    "phoneOptionalHint": "For pickup and day-of updates",
+    "whatsAppOptional": "WhatsApp",
+    "whatsAppOptionalPlaceholder": "e.g. +1 403 555 0123",
+    "whatsAppOptionalHint": "Leave blank if same as phone",
     "dapNoLastNameOnFile": "We couldn’t find a last name on this booking in our system. Please contact us, or use Manage booking with the last name from your confirmation email.",
     "dapCancellationPolicyHeading": "Cancellation policy",
     "dapCancellationPolicyBody": "You may cancel this add-on for a full refund up to {days} {daysUnit} before your scheduled photo session. Cancellations made after that deadline may forfeit the entire add-on cost.",

package/src/lib/booking/i18n/messages/fr.json

@@ -102,6 +102,12 @@
     "firstNamePlaceholder": "Jeanne",
     "lastName": "Nom de famille",
     "lastNamePlaceholder": "Dupont",
+    "phoneOptional": "Téléphone",
+    "phoneOptionalPlaceholder": "p. ex. +1 403 555 0123",
+    "phoneOptionalHint": "Pour la prise en charge et les mises à jour le jour même",
+    "whatsAppOptional": "WhatsApp",
+    "whatsAppOptionalPlaceholder": "p. ex. +1 403 555 0123",
+    "whatsAppOptionalHint": "Laissez vide si identique au téléphone",
     "dapNoLastNameOnFile": "Nous n’avons pas trouvé de nom de famille pour cette réservation. Contactez-nous, ou utilisez Gérer la réservation avec le nom figurant sur votre courriel de confirmation.",
     "dapCancellationPolicyHeading": "Politique d’annulation",
     "dapCancellationPolicyBody": "Vous pouvez annuler cette option avec remboursement intégral jusqu’à {days} {daysUnit} avant votre séance photo prévue. Toute annulation après cette date peut entraîner la perte du montant total de l’option.",

package/src/lib/booking/phone.ts

@@ -0,0 +1,18 @@
+/** Minimum digit count for a stored phone (country code + national number). */
+const MIN_PHONE_DIGITS = 10;
+
+/**
+ * Treat empty input and country-code-only values (e.g. default "+1") as no phone.
+ * Returns the trimmed E.164-style string when meaningful, otherwise undefined.
+ */
+export function normalizeOptionalPhoneNumber(raw: string | undefined | null): string | undefined {
+  const trimmed = (raw ?? '').trim();
+  if (!trimmed) return undefined;
+  const digits = trimmed.replace(/\D/g, '');
+  if (digits.length < MIN_PHONE_DIGITS) return undefined;
+  return trimmed;
+}
+
+export function hasMeaningfulPhoneNumber(raw: string | undefined | null): boolean {
+  return normalizeOptionalPhoneNumber(raw) !== undefined;
+}

package/src/lib/booking-api.ts

@@ -355,26 +355,304 @@ function getAuthHeaders(): Record<string, string> {
 
 /** Idempotent GET retries: transient network errors and 502/503/504 (new trace span each attempt). */
 const BOOKING_GET_MAX_RETRIES = 2;
+const BOOKING_ATTEMPT_HEADER = 'X-Booking-Attempt-Id';
+const SLOW_REQUEST_THRESHOLD_MS = 2500;
+const SUCCESS_TIMING_SAMPLE_RATE = 0.02;
+const NETWORK_FAILURE_PROBE_TIMEOUT_MS = 1500;
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function newBookingAttemptId(): string {
+  try {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+  } catch {
+    /* fall through */
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
+}
+
+function getEndpointFromUrl(url: string): string {
+  try {
+    const parsed = new URL(url, typeof window !== 'undefined' ? window.location.href : API_BASE);
+    return parsed.pathname;
+  } catch {
+    return '';
+  }
+}
+
+function isBookingCriticalEndpoint(endpoint: string): boolean {
+  return (
+    endpoint === '/1/get-availabilities' ||
+    endpoint === '/1/products' ||
+    endpoint === '/1/reserve' ||
+    endpoint.startsWith('/1/companies/')
+  );
+}
+
+function getConnectionDiagnostics(): Record<string, number | string | boolean> | null {
+  if (typeof navigator === 'undefined') return null;
+  const connection = (
+    navigator as Navigator & {
+      connection?: {
+        effectiveType?: string;
+        rtt?: number;
+        downlink?: number;
+        saveData?: boolean;
+      };
+    }
+  ).connection;
+  if (!connection) return null;
+  return {
+    effectiveType: connection.effectiveType ?? 'unknown',
+    rtt: typeof connection.rtt === 'number' ? connection.rtt : -1,
+    downlink: typeof connection.downlink === 'number' ? connection.downlink : -1,
+    saveData: Boolean(connection.saveData),
+  };
+}
+
+function getBrowserDiagnostics(): Record<string, number | string | boolean> {
+  if (typeof window === 'undefined') return {};
+  return {
+    siteOrigin: window.location.origin,
+    siteProtocol: window.location.protocol,
+    isSecureContext: window.isSecureContext,
+    referrer: document.referrer || '',
+  };
+}
+
+function getAvailabilityQueryShape(url: string): Record<string, string | boolean | string[]> | null {
+  try {
+    const parsed = new URL(url, typeof window !== 'undefined' ? window.location.href : API_BASE);
+    if (parsed.pathname !== '/1/get-availabilities') return null;
+    const params = parsed.searchParams;
+    return {
+      queryKeys: Array.from(params.keys()).sort(),
+      productId: params.get('productId') ?? '',
+      productOptionId: params.get('productOptionId') ?? '',
+      startDate: params.get('startDate') ?? '',
+      endDate: params.get('endDate') ?? '',
+      fromDateTime: params.get('fromDateTime') ?? '',
+      toDateTime: params.get('toDateTime') ?? '',
+      allOptions: params.get('allOptions') === 'true',
+      summary: params.get('summary') === 'true',
+    };
+  } catch {
+    return null;
+  }
+}
+
+function latestResourceTiming(url: string): Record<string, number | string | boolean> | null {
+  if (typeof performance === 'undefined') return null;
+  const entry = performance
+    .getEntriesByName(url)
+    .filter((item): item is PerformanceResourceTiming => item.entryType === 'resource')
+    .at(-1);
+  if (!entry) return null;
+  return {
+    name: entry.name,
+    durationMs: Math.round(entry.duration),
+    startTimeMs: Math.round(entry.startTime),
+    fetchStartMs: Math.round(entry.fetchStart),
+    domainLookupStartMs: Math.round(entry.domainLookupStart),
+    domainLookupEndMs: Math.round(entry.domainLookupEnd),
+    connectStartMs: Math.round(entry.connectStart),
+    connectEndMs: Math.round(entry.connectEnd),
+    secureConnectionStartMs: Math.round(entry.secureConnectionStart),
+    requestStartMs: Math.round(entry.requestStart),
+    responseStartMs: Math.round(entry.responseStart),
+    responseEndMs: Math.round(entry.responseEnd),
+    transferSize: entry.transferSize,
+    encodedBodySize: entry.encodedBodySize,
+    decodedBodySize: entry.decodedBodySize,
+    timingRestricted: entry.responseStart === 0 && entry.responseEnd === 0,
+  };
+}
+
+function resourceTimingStatus(
+  timing: Record<string, number | string | boolean> | null
+): string {
+  if (!timing) return 'missing';
+  if (timing.timingRestricted === true) return 'timing_restricted';
+  if (typeof timing.responseStartMs === 'number' && timing.responseStartMs > 0) return 'response_started';
+  if (typeof timing.requestStartMs === 'number' && timing.requestStartMs > 0) return 'request_started';
+  if (typeof timing.connectStartMs === 'number' && timing.connectStartMs > 0) return 'connect_started';
+  if (typeof timing.fetchStartMs === 'number' && timing.fetchStartMs > 0) return 'fetch_started';
+  return 'unknown';
+}
+
+async function runNetworkFailureProbe(
+  label: string,
+  url: string,
+  init: RequestInit
+): Promise<Record<string, number | string | boolean | null>> {
+  const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+  const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+  let timedOut = false;
+  const timeoutId =
+    controller && typeof window !== 'undefined'
+      ? window.setTimeout(() => {
+          timedOut = true;
+          controller.abort();
+        }, NETWORK_FAILURE_PROBE_TIMEOUT_MS)
+      : null;
+  try {
+    const response = await fetch(url, {
+      ...init,
+      cache: 'no-store',
+      signal: controller?.signal,
+    });
+    const timing = latestResourceTiming(url);
+    return {
+      label,
+      reachedFetchResponse: true,
+      ok: response.ok,
+      status: response.status,
+      responseType: response.type,
+      elapsedMs: Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt),
+      timedOut,
+      resourceTimingStatus: resourceTimingStatus(timing),
+    };
+  } catch (error) {
+    const timing = latestResourceTiming(url);
+    return {
+      label,
+      reachedFetchResponse: false,
+      ok: false,
+      status: null,
+      elapsedMs: Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt),
+      timedOut,
+      errorName: error instanceof Error ? error.name : 'UnknownError',
+      errorMessage: error instanceof Error ? error.message : String(error),
+      resourceTimingStatus: resourceTimingStatus(timing),
+    };
+  } finally {
+    if (timeoutId != null) window.clearTimeout(timeoutId);
+  }
+}
+
+async function collectNetworkFailureProbeResults(
+  endpoint: string,
+  correlationId: string,
+  traceparent: string
+): Promise<Array<Record<string, number | string | boolean | null>>> {
+  if (typeof window === 'undefined') return [];
+  const cacheBust = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return Promise.all([
+    runNetworkFailureProbe(
+      'same_origin_asset_head',
+      `${window.location.origin}/favicon.ico?tb_probe=${cacheBust}`,
+      { method: 'HEAD', mode: 'same-origin' }
+    ),
+    runNetworkFailureProbe(
+      'api_telemetry_cors_post',
+      `${API_BASE}/1/client-telemetry`,
+      {
+        method: 'POST',
+        mode: 'cors',
+        headers: {
+          'Content-Type': 'application/json',
+          [BOOKING_CORRELATION_HEADER]: correlationId,
+          traceparent,
+        },
+        body: JSON.stringify({
+          event: 'BOOKING_DIALOG_NETWORK_PROBE_PING',
+          endpoint,
+          correlationId,
+          traceparent,
+          apiBase: API_BASE,
+          pageUrl: window.location.href,
+          userAgent: window.navigator.userAgent,
+          online: window.navigator.onLine,
+          occurredAt: new Date().toISOString(),
+          ...getBrowserDiagnostics(),
+        }),
+      }
+    ),
+  ]);
+}
+
+function bookingRequestTelemetryContext(
+  url: string,
+  endpoint: string,
+  headers: Record<string, string>,
+  requestAttemptId: string,
+  attemptNumber: number,
+  elapsedMs?: number,
+): Record<string, unknown> {
+  const traceparent = headers.traceparent;
+  const traceId = traceparent ? traceIdFromTraceparent(traceparent) : undefined;
+  return {
+    endpoint,
+    method: 'GET',
+    correlationId: headers[BOOKING_CORRELATION_HEADER],
+    traceparent,
+    ...(traceId ? { traceId } : {}),
+    requestAttemptId,
+    attemptNumber,
+    maxRetries: BOOKING_GET_MAX_RETRIES,
+    requestUrlPath: endpoint,
+    requestMode: 'cors',
+    requestCache: 'default',
+    requestCredentials: 'same-origin',
+    requestUrlSearchLength: (() => {
+      try {
+        return new URL(url, window.location.href).search.length;
+      } catch {
+        return 0;
+      }
+    })(),
+    availabilityQueryShape: getAvailabilityQueryShape(url),
+    visibilityState: typeof document !== 'undefined' ? document.visibilityState : undefined,
+    pageAgeMs: typeof performance !== 'undefined' ? Math.round(performance.now()) : undefined,
+    connection: getConnectionDiagnostics(),
+    ...getBrowserDiagnostics(),
+    ...(elapsedMs != null ? { elapsedMs } : {}),
+  };
+}
+
 async function fetchBookingGetWithRetry(
   url: string,
   extra?: Pick<RequestInit, 'cache' | 'signal'>,
 ): Promise<Response> {
   let lastErr: unknown;
+  const endpoint = getEndpointFromUrl(url);
   for (let attempt = 0; attempt <= BOOKING_GET_MAX_RETRIES; attempt++) {
     if (attempt > 0) {
       await sleep(250 * attempt);
     }
+    const requestAttemptId = newBookingAttemptId();
+    const headers: Record<string, string> = {
+      ...getAuthHeaders(),
+      [BOOKING_ATTEMPT_HEADER]: requestAttemptId,
+    };
+    const startedAt = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    if (isBookingCriticalEndpoint(endpoint)) {
+      reportBookingClientTelemetryEvent('BOOKING_DIALOG_REQUEST_STARTED', {
+        ...bookingRequestTelemetryContext(url, endpoint, headers, requestAttemptId, attempt + 1),
+      });
+    }
     try {
       const res = await fetch(url, {
         ...extra,
         method: 'GET',
-        headers: getAuthHeaders(),
+        headers,
       });
+      const elapsedMs = Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt);
+      if (
+        elapsedMs >= SLOW_REQUEST_THRESHOLD_MS ||
+        (isBookingCriticalEndpoint(endpoint) && Math.random() < SUCCESS_TIMING_SAMPLE_RATE)
+      ) {
+        reportBookingClientTelemetryEvent('BOOKING_DIALOG_REQUEST_TIMING', {
+          ...bookingRequestTelemetryContext(url, endpoint, headers, requestAttemptId, attempt + 1, elapsedMs),
+          httpStatus: res.status,
+          ok: res.ok,
+          resourceTiming: latestResourceTiming(url),
+        });
+      }
       if (res.ok) {
         return res;
       }
@@ -388,8 +666,36 @@ async function fetchBookingGetWithRetry(
     } catch (e) {
       lastErr = e;
       if (attempt < BOOKING_GET_MAX_RETRIES) {
+        const elapsedMs = Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt);
+        reportBookingClientTelemetryEvent('BOOKING_DIALOG_REQUEST_RETRYING', {
+          ...bookingRequestTelemetryContext(url, endpoint, headers, requestAttemptId, attempt + 1, elapsedMs),
+          errorName: e instanceof Error ? e.name : undefined,
+          errorMessage: e instanceof Error ? e.message : String(e),
+          requestSignalAborted: Boolean(extra?.signal?.aborted),
+        });
         continue;
       }
+      const elapsedMs = Math.round((typeof performance !== 'undefined' ? performance.now() : Date.now()) - startedAt);
+      const resourceTiming = latestResourceTiming(url);
+      const probeResults = await collectNetworkFailureProbeResults(
+        endpoint,
+        headers[BOOKING_CORRELATION_HEADER],
+        headers.traceparent
+      );
+      reportBookingClientTelemetryEvent('BOOKING_DIALOG_NETWORK_DIAGNOSTIC', {
+        ...bookingRequestTelemetryContext(url, endpoint, headers, requestAttemptId, attempt + 1, elapsedMs),
+        errorName: e instanceof Error ? e.name : undefined,
+        errorMessage: e instanceof Error ? e.message : String(e),
+        errorCause: e instanceof Error && e.cause ? String(e.cause) : undefined,
+        requestSignalAborted: Boolean(extra?.signal?.aborted),
+        abortReason:
+          extra?.signal && 'reason' in extra.signal
+            ? String(extra.signal.reason ?? '')
+            : undefined,
+        resourceTiming,
+        resourceTimingStatus: resourceTimingStatus(resourceTiming),
+        probeResults,
+      });
       throw e;
     }
   }
@@ -1678,6 +1984,7 @@ export interface CreatePaymentIntentRequest {
   customerEmail?: string;
   customerFirstName?: string;
   customerLastName?: string;
+  customerPhoneNumber?: string;
   currency?: string;
   reservationReference?: string;
   travelerHotel?: string;
@@ -1781,6 +2088,7 @@ export interface ConfirmFreeBookingRequest {
   customerEmail?: string;
   customerFirstName?: string;
   customerLastName?: string;
+  customerPhoneNumber?: string;
   currency?: string;
   travelerHotel?: string;
   pickupLocationId?: string;
@@ -1860,6 +2168,7 @@ export interface ConfirmBookingWithoutPaymentRequest {
   customerEmail?: string;
   customerFirstName?: string;
   customerLastName?: string;
+  customerPhoneNumber?: string;
   currency?: string;
   travelerHotel?: string;
   pickupLocationId?: string;

package/src/lib/booking-types.ts

@@ -20,6 +20,11 @@ export interface ProductConfig {
   optionIds: string[];
   /** STANDARD or PRIVATE_SHUTTLE - affects availability date format. Default STANDARD. */
   productType?: 'STANDARD' | 'PRIVATE_SHUTTLE';
+  /**
+   * TicketBooth dependent add-on product ids this primary product supports at checkout.
+   * Used by photo-first flows to filter the shuttle picker.
+   */
+  dependentAddOnProductIds?: string[];
   display: ProductDisplayConfig;
 }
 

package/src/lib/dap-descriptions.ts

@@ -16,12 +16,16 @@ export interface DapDescriptionResult {
   paragraphs: string[];
   review?: { text: string; name: string };
   sections: { title: string; content: DapSectionContent }[];
+  learnMoreUrl?: string;
+  learnMoreLabel?: string;
 }
 
 interface DapDescriptionData {
   paragraphs: string[];
   review?: { text: string; name: string };
   sections: { title: string; content: DapSectionContent }[];
+  learnMoreUrl?: string;
+  learnMoreLabel?: string;
 }
 
 const EN: Record<PhotoDapSlug, DapDescriptionData> = {
@@ -46,5 +50,7 @@ export function getDapDescription(
     paragraphs: data.paragraphs ?? [],
     review: data.review,
     sections: data.sections ?? [],
+    learnMoreUrl: data.learnMoreUrl,
+    learnMoreLabel: data.learnMoreLabel,
   };
 }

package/src/lib/dependent-add-on-api.ts

@@ -305,6 +305,12 @@ export async function getDependentAddOnAvailability(
   }
   const payload = await parseJsonSafely(res);
   if (!res.ok) {
+    if (res.status === 404) {
+      throw new Error('We could not find that shuttle booking reference. Check the code and try again.');
+    }
+    if (res.status === 403) {
+      throw new Error('That last name does not match the shuttle booking. Check the spelling and try again.');
+    }
     throw new Error(messageFromPayload(payload, `Could not load times (HTTP ${res.status})`));
   }
   const data = payload as { data?: Record<string, unknown> } | null;