@ticketboothapp/booking 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ticketboothapp/booking",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "sideEffects": false,
   "publishConfig": {

package/src/components/booking/booking-flow-ui.ts

@@ -0,0 +1,24 @@
+/**
+ * Optional UI/behavior overrides for booking flows.
+ */
+export interface BookingFlowUiOptions {
+  showCollage?: boolean;
+  showTourDescription?: boolean;
+  autoSelectFirstAvailableDate?: boolean;
+  autoSelectFirstHighlightedPickup?: boolean;
+  partnerDeferredInvoice?: boolean;
+  partnerDeferredInvoiceSubmitLabel?: string;
+  partnerAttributionSummary?: string;
+  partnerAttributionConfirmLabel?: string;
+  itineraryStickyTopOffsetPx?: number;
+}
+
+/**
+ * Baseline UX for embedded partner-style surfaces.
+ */
+export const PARTNER_EMBEDDED_BOOKING_FLOW_UI_BASE: BookingFlowUiOptions = {
+  showCollage: false,
+  showTourDescription: false,
+  autoSelectFirstAvailableDate: true,
+  autoSelectFirstHighlightedPickup: true,
+};

package/src/components/partner/PartnerBookingPageWithBrowserMetadata.tsx

@@ -0,0 +1,61 @@
+'use client';
+
+import { useMemo, type ReactNode } from 'react';
+import { usePathname } from 'next/navigation';
+import type { BookingFlowUiOptions } from '../booking/booking-flow-ui';
+import {
+  buildBookingSourceMetadataFromLocation,
+  mergeBookingSourceMetadata,
+  type BookingSourceMetadata,
+} from '../../lib/booking/source-metadata';
+
+export interface PartnerBookingPageRenderProps {
+  bookingSourceAttribution: Partial<BookingSourceMetadata>;
+  flowUi?: BookingFlowUiOptions;
+  onBookingFlowSuccess?: (data: { reservationReference: string; bookingReference?: string }) => void;
+}
+
+export interface PartnerBookingPageWithBrowserMetadataProps {
+  canonicalAttribution: Partial<BookingSourceMetadata>;
+  bookingSourceAttributionMerge?: Partial<BookingSourceMetadata> | null;
+  flowUi?: BookingFlowUiOptions;
+  onBookingFlowSuccess?: (data: { reservationReference: string; bookingReference?: string }) => void;
+  render: (props: PartnerBookingPageRenderProps) => ReactNode;
+}
+
+/**
+ * Lightweight, package-safe partner metadata wrapper.
+ * It computes attribution from browser URL + canonical route + runtime merge.
+ */
+export default function PartnerBookingPageWithBrowserMetadata({
+  canonicalAttribution,
+  bookingSourceAttributionMerge,
+  flowUi,
+  onBookingFlowSuccess,
+  render,
+}: PartnerBookingPageWithBrowserMetadataProps) {
+  const pathname = usePathname() ?? '';
+
+  const bookingSourceAttribution = useMemo(
+    () => {
+      // Trigger recompute when route path changes; location parser reads from window.
+      void pathname;
+      return mergeBookingSourceMetadata(
+        buildBookingSourceMetadataFromLocation(),
+        canonicalAttribution,
+        bookingSourceAttributionMerge,
+      );
+    },
+    [pathname, canonicalAttribution, bookingSourceAttributionMerge],
+  );
+
+  return (
+    <>
+      {render({
+        bookingSourceAttribution,
+        flowUi,
+        onBookingFlowSuccess,
+      })}
+    </>
+  );
+}

package/src/contexts/AvailabilitiesCacheContext.tsx

@@ -0,0 +1,107 @@
+'use client';
+
+import { createContext, useContext, useRef, useCallback, type ReactNode } from 'react';
+
+export const AVAILABILITIES_CACHE_TTL_MS = 5 * 60 * 1000;
+
+export type AvailabilityLike = Record<string, unknown>;
+export type PricingConfigLike = Record<string, unknown>;
+export type PrecomputedPricesByCategoryLike = Record<string, unknown>;
+
+export interface CachedAvailabilitiesData {
+  fetchedRanges: Array<{ start: Date; end: Date }>;
+  availabilities: AvailabilityLike[];
+  pricingConfig: PricingConfigLike | null;
+  precomputedPricesByOption: Record<string, PrecomputedPricesByCategoryLike> | null;
+  precomputedPrices?: PrecomputedPricesByCategoryLike | null;
+  resourcePriceByCurrency?: Record<string, number> | null;
+  resourcePriceByOption?: Record<string, Record<string, number>> | null;
+  cachedAt: number;
+}
+
+interface AvailabilitiesCacheContextValue {
+  get: (cacheKey: string) => CachedAvailabilitiesData | undefined;
+  isStale: (cached: CachedAvailabilitiesData) => boolean;
+  set: (cacheKey: string, data: CachedAvailabilitiesData) => void;
+  merge: (
+    cacheKey: string,
+    update: {
+      fetchedRanges?: Array<{ start: Date; end: Date }>;
+      availabilities?: AvailabilityLike[];
+      pricingConfig?: PricingConfigLike | null;
+      precomputedPricesByOption?: Record<string, PrecomputedPricesByCategoryLike> | null;
+      precomputedPrices?: PrecomputedPricesByCategoryLike | null;
+      resourcePriceByCurrency?: Record<string, number> | null;
+      resourcePriceByOption?: Record<string, Record<string, number>> | null;
+    }
+  ) => void;
+}
+
+const AvailabilitiesCacheContext = createContext<AvailabilitiesCacheContextValue | null>(null);
+
+export function useAvailabilitiesCache() {
+  const ctx = useContext(AvailabilitiesCacheContext);
+  return ctx;
+}
+
+export function buildAvailabilitiesCacheKey(
+  productId: string,
+  optionIdsKey: string,
+  promoCode: string | null,
+  pricingProfileId?: string | null
+): string {
+  const pp = (pricingProfileId ?? '').trim();
+  return `${productId}|${optionIdsKey}|${promoCode ?? ''}|pp:${pp}`;
+}
+
+export function AvailabilitiesCacheProvider({ children }: { children: ReactNode }) {
+  const cacheRef = useRef<Map<string, CachedAvailabilitiesData>>(new Map());
+
+  const get = useCallback((cacheKey: string) => cacheRef.current.get(cacheKey), []);
+
+  const isStale = useCallback((cached: CachedAvailabilitiesData) => {
+    const age = Date.now() - (cached.cachedAt ?? 0);
+    return age > AVAILABILITIES_CACHE_TTL_MS;
+  }, []);
+
+  const set = useCallback((cacheKey: string, data: CachedAvailabilitiesData) => {
+    cacheRef.current.set(cacheKey, data);
+  }, []);
+
+  const merge = useCallback(
+    (
+      cacheKey: string,
+      update: {
+        fetchedRanges?: Array<{ start: Date; end: Date }>;
+        availabilities?: AvailabilityLike[];
+        pricingConfig?: PricingConfigLike | null;
+        precomputedPricesByOption?: Record<string, PrecomputedPricesByCategoryLike> | null;
+        precomputedPrices?: PrecomputedPricesByCategoryLike | null;
+        resourcePriceByCurrency?: Record<string, number> | null;
+        resourcePriceByOption?: Record<string, Record<string, number>> | null;
+      }
+    ) => {
+      const existing = cacheRef.current.get(cacheKey);
+      const next: CachedAvailabilitiesData = {
+        fetchedRanges: update.fetchedRanges ?? existing?.fetchedRanges ?? [],
+        availabilities: update.availabilities ?? existing?.availabilities ?? [],
+        pricingConfig: update.pricingConfig !== undefined ? update.pricingConfig : existing?.pricingConfig ?? null,
+        precomputedPricesByOption:
+          update.precomputedPricesByOption !== undefined
+            ? update.precomputedPricesByOption
+            : existing?.precomputedPricesByOption ?? null,
+        precomputedPrices: update.precomputedPrices !== undefined ? update.precomputedPrices : existing?.precomputedPrices ?? null,
+        resourcePriceByCurrency:
+          update.resourcePriceByCurrency !== undefined ? update.resourcePriceByCurrency : existing?.resourcePriceByCurrency ?? null,
+        resourcePriceByOption:
+          update.resourcePriceByOption !== undefined ? update.resourcePriceByOption : existing?.resourcePriceByOption ?? null,
+        cachedAt: Date.now(),
+      };
+      cacheRef.current.set(cacheKey, next);
+    },
+    []
+  );
+
+  const value: AvailabilitiesCacheContextValue = { get, set, merge, isStale };
+  return <AvailabilitiesCacheContext.Provider value={value}>{children}</AvailabilitiesCacheContext.Provider>;
+}

package/src/contexts/BookingAppContext.tsx

@@ -0,0 +1,93 @@
+'use client';
+
+import { createContext, useContext, type ReactNode } from 'react';
+
+/** Host app / embedding context (standalone site, provider-dashboard, etc.). */
+export type BookingAppMode = 'standalone' | 'provider-dashboard' | (string & Record<never, never>);
+
+/** Viewer role for the booking app. */
+export type ViewerRole = 'public' | 'reseller' | 'admin';
+
+/** Feature flags and permissions for the booking app in this context. */
+export interface BookingAppPermissions {
+  canViewPriceBreakdown?: boolean;
+  viewerRole?: ViewerRole;
+  /** @deprecated Prefer viewerRole. */
+  priceBreakdownDetail?: 'full' | 'simplified';
+}
+
+export interface ManageParams {
+  ref?: string;
+  reservationRef?: string;
+  lastName: string;
+}
+
+export interface BookingAppContextValue {
+  mode: BookingAppMode;
+  permissions: BookingAppPermissions;
+  isSimplifiedPricingView: boolean;
+  googleMapsApiKey?: string;
+  onShowManage?: (params: ManageParams) => void;
+  getSuccessUrl?: (params: { reservationRef: string; lastName: string; focusDate?: string }) => string;
+  showLanguageSelector: boolean;
+  suppressCalendarDateScroll?: boolean;
+}
+
+const BookingAppContext = createContext<BookingAppContextValue | undefined>(undefined);
+
+function deriveIsSimplifiedPricingView(permissions: BookingAppPermissions): boolean {
+  const role = permissions.viewerRole;
+  if (role === 'public' || role === 'reseller') return true;
+  if (role === 'admin') return false;
+  return permissions.priceBreakdownDetail === 'simplified';
+}
+
+const DEFAULT_STANDALONE: BookingAppContextValue = {
+  mode: 'standalone',
+  permissions: { canViewPriceBreakdown: false },
+  isSimplifiedPricingView: false,
+  showLanguageSelector: true,
+  suppressCalendarDateScroll: false,
+};
+
+export interface BookingAppProviderProps {
+  children: ReactNode;
+  mode?: BookingAppMode;
+  permissions?: Partial<BookingAppPermissions>;
+  googleMapsApiKey?: string;
+  onShowManage?: (params: ManageParams) => void;
+  getSuccessUrl?: (params: { reservationRef: string; lastName: string; focusDate?: string }) => string;
+  showLanguageSelector?: boolean;
+  suppressCalendarDateScroll?: boolean;
+}
+
+export function BookingAppProvider({
+  children,
+  mode = 'standalone',
+  permissions = {},
+  googleMapsApiKey,
+  onShowManage,
+  getSuccessUrl,
+  showLanguageSelector = true,
+  suppressCalendarDateScroll = false,
+}: BookingAppProviderProps) {
+  const mergedPermissions = { ...DEFAULT_STANDALONE.permissions, ...permissions };
+  const value: BookingAppContextValue = {
+    mode,
+    permissions: mergedPermissions,
+    isSimplifiedPricingView: deriveIsSimplifiedPricingView(mergedPermissions),
+    googleMapsApiKey,
+    onShowManage,
+    getSuccessUrl,
+    showLanguageSelector,
+    suppressCalendarDateScroll,
+  };
+
+  return <BookingAppContext.Provider value={value}>{children}</BookingAppContext.Provider>;
+}
+
+export function useBookingApp(): BookingAppContextValue {
+  const context = useContext(BookingAppContext);
+  if (context === undefined) return DEFAULT_STANDALONE;
+  return context;
+}

package/src/contexts/CompanyContext.tsx

@@ -0,0 +1,67 @@
+'use client';
+
+import { createContext, useContext, useState, useEffect, type ReactNode } from 'react';
+import { ENV } from '../lib/env';
+
+export interface Company {
+  settings?: {
+    timezone?: string;
+  };
+  [key: string]: unknown;
+}
+
+interface CompanyContextType {
+  company: Company | null;
+  loading: boolean;
+  error: string | null;
+}
+
+const CompanyContext = createContext<CompanyContextType | undefined>(undefined);
+
+interface CompanyProviderProps {
+  children: ReactNode;
+}
+
+async function getCompany(companyId: string): Promise<Company | null> {
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (ENV.BASIC_AUTH) headers.Authorization = `Basic ${ENV.BASIC_AUTH}`;
+  const response = await fetch(`${ENV.API_URL}/1/companies/${companyId}`, { method: 'GET', headers });
+  if (!response.ok) throw new Error(`Failed to load company (${response.status})`);
+  const data = await response.json();
+  return data?.data?.company ?? null;
+}
+
+export function CompanyProvider({ children }: CompanyProviderProps) {
+  const [company, setCompany] = useState<Company | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    async function fetchCompany() {
+      try {
+        const companyData = await getCompany(ENV.COMPANY_ID);
+        setCompany(companyData);
+        setError(null);
+      } catch (err) {
+        console.warn('Failed to fetch company data, using defaults:', err);
+        setError(err instanceof Error ? err.message : 'Failed to fetch company');
+      } finally {
+        setLoading(false);
+      }
+    }
+    fetchCompany();
+  }, []);
+
+  return <CompanyContext.Provider value={{ company, loading, error }}>{children}</CompanyContext.Provider>;
+}
+
+export function useCompany() {
+  const context = useContext(CompanyContext);
+  if (context === undefined) throw new Error('useCompany must be used within a CompanyProvider');
+  return context;
+}
+
+export function useCompanyTimezone(): string {
+  const { company } = useCompany();
+  return company?.settings?.timezone || 'America/Edmonton';
+}

package/src/index.ts

@@ -10,3 +10,71 @@ export {
   type PublicPartnerAgent,
   type PublicStaffPortalSignInOption,
 } from './public-partners';
+
+export {
+  BookingAppProvider,
+  useBookingApp,
+  type BookingAppMode,
+  type ViewerRole,
+  type BookingAppPermissions,
+  type BookingAppContextValue,
+  type BookingAppProviderProps,
+  type ManageParams,
+} from './contexts/BookingAppContext';
+
+export {
+  PARTNER_EMBEDDED_BOOKING_FLOW_UI_BASE,
+  type BookingFlowUiOptions,
+} from './components/booking/booking-flow-ui';
+
+export {
+  CompanyProvider,
+  useCompany,
+  useCompanyTimezone,
+  type Company,
+} from './contexts/CompanyContext';
+
+export {
+  AVAILABILITIES_CACHE_TTL_MS,
+  AvailabilitiesCacheProvider,
+  useAvailabilitiesCache,
+  buildAvailabilitiesCacheKey,
+  type CachedAvailabilitiesData,
+} from './contexts/AvailabilitiesCacheContext';
+
+export {
+  BookingDialogProvider,
+  useBookingDialog,
+  OPEN_BOOKING_FOR_PRODUCT,
+  OPEN_BOOKING_WITH_FILTER,
+  BOOKING_FLOW_ABANDON_EVENT,
+  type ProductGridFilterId,
+  type BookingScreen,
+  type ProductGridRestoreState,
+} from './providers/booking-dialog-provider';
+
+export {
+  setPartnerPortalBookingJwtGetter,
+  getPartnerPortalBookingJwt,
+} from './lib/booking-api-auth';
+
+export {
+  KnownBookingSource,
+  DEFAULT_BOOKING_SOURCE,
+  PARTNER_PORTAL_BOOKING_SOURCE,
+  inferClientBookingSourceFromProductIds,
+  mergedMetadataImpliesPartnerPortal,
+  isPublicPartnerMarketingPath,
+  isDedicatedPartnerBookingPortalHost,
+  buildBookingSourceMetadataFromLocation,
+  mergeBookingSourceMetadata,
+  buildBookingSourceContext,
+  type BookingSourceMetadata,
+  type BuildBookingSourceContextOptions,
+} from './lib/booking/source-metadata';
+
+export {
+  default as PartnerBookingPageWithBrowserMetadata,
+  type PartnerBookingPageWithBrowserMetadataProps,
+  type PartnerBookingPageRenderProps,
+} from './components/partner/PartnerBookingPageWithBrowserMetadata';

package/src/lib/booking/booking-source.ts

@@ -0,0 +1,33 @@
+export enum KnownBookingSource {
+  WEBSITE = 'WEBSITE',
+  PUBLIC_PARTNER_WEBSITE = 'PUBLIC_PARTNER_WEBSITE',
+  PARTNER_PORTAL = 'PARTNER_PORTAL',
+  AFFILIATE = 'AFFILIATE',
+  DASHBOARD = 'DASHBOARD',
+  GYG = 'GYG',
+  VIATOR = 'VIATOR',
+}
+
+export const DEFAULT_BOOKING_SOURCE = KnownBookingSource.WEBSITE;
+export const PARTNER_PORTAL_BOOKING_SOURCE = KnownBookingSource.PARTNER_PORTAL;
+
+const PUBLIC_BOOKING_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export function mergedMetadataImpliesPartnerPortal(
+  merged: Partial<{ partnerId?: string; partnerSlug?: string }>
+): boolean {
+  const pid = typeof merged.partnerId === 'string' ? merged.partnerId.trim() : '';
+  if (pid.startsWith('par_')) return true;
+  const slug = typeof merged.partnerSlug === 'string' ? merged.partnerSlug.trim().toLowerCase() : '';
+  return slug.length > 0 && PUBLIC_BOOKING_SLUG_RE.test(slug);
+}
+
+export function inferClientBookingSourceFromProductIds(
+  productId: string,
+  productOptionId?: string | null
+): KnownBookingSource {
+  const haystack = `${productId} ${productOptionId ?? ''}`.toLowerCase();
+  if (haystack.includes('gyg_')) return KnownBookingSource.GYG;
+  if (haystack.includes('viator_')) return KnownBookingSource.VIATOR;
+  return KnownBookingSource.WEBSITE;
+}

package/src/lib/booking/normalize-booking-product-id.ts

@@ -0,0 +1,14 @@
+export function normalizeBookingProductId(rawId: string): string {
+  const trimmed = rawId.trim();
+  if (!trimmed) return '';
+  const withoutHash = trimmed.split('#', 1)[0] ?? '';
+  const withoutQuery = withoutHash.split('?', 1)[0] ?? '';
+  const normalized = withoutQuery.split('&', 1)[0] ?? '';
+  return normalized.trim();
+}
+
+export function isSuspiciousBookingProductId(value: string): boolean {
+  return /[?&=]/.test(value);
+}
+
+export const normalizeAvailabilityLookupId = normalizeBookingProductId;

package/src/lib/booking/source-metadata.ts

@@ -0,0 +1,161 @@
+export {
+  KnownBookingSource,
+  DEFAULT_BOOKING_SOURCE,
+  PARTNER_PORTAL_BOOKING_SOURCE,
+  inferClientBookingSourceFromProductIds,
+  mergedMetadataImpliesPartnerPortal,
+} from './booking-source';
+
+import { KnownBookingSource, mergedMetadataImpliesPartnerPortal } from './booking-source';
+
+export interface BookingSourceMetadata {
+  pageUrl?: string;
+  pagePath?: string;
+  pageQuery?: string;
+  referrerUrl?: string;
+  utmSource?: string;
+  utmMedium?: string;
+  utmCampaign?: string;
+  utmTerm?: string;
+  utmContent?: string;
+  gclid?: string;
+  fbclid?: string;
+  msclkid?: string;
+  partnerId?: string;
+  partnerSlug?: string;
+  agentId?: string;
+  agentName?: string;
+}
+
+function withDefinedValues<T extends object>(obj: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => value !== undefined && value !== null && value !== ''),
+  ) as Partial<T>;
+}
+
+export function isPublicPartnerMarketingPath(pathname: string): boolean {
+  return /^\/partner\/[^/]+/i.test(pathname.trim());
+}
+
+export function isDedicatedPartnerBookingPortalHost(hostname: string): boolean {
+  const h = hostname.trim().toLowerCase();
+  return h === 'booking.viaviamorainelake.com' || h === 'staging.booking.viaviamorainelake.com';
+}
+
+export function buildBookingSourceMetadataFromLocation(): Partial<BookingSourceMetadata> {
+  if (typeof window === 'undefined') return {};
+  const currentUrl = new URL(window.location.href);
+  const params = currentUrl.searchParams;
+  const partnerMatch = currentUrl.pathname.match(/^\/partner\/([^/]+)/i);
+  const onPartnerEmbedPath = isPublicPartnerMarketingPath(currentUrl.pathname);
+  const onPortalHost = isDedicatedPartnerBookingPortalHost(currentUrl.hostname);
+  const partnerFromQuery =
+    onPartnerEmbedPath || onPortalHost ? params.get('partnerId') || undefined : undefined;
+  const partnerSlugFromPath = partnerMatch?.[1];
+  const agentIdFromQuery = params.get('agentId') || undefined;
+  const agentNameFromQuery = params.get('agentName') || undefined;
+
+  return withDefinedValues<BookingSourceMetadata>({
+    pageUrl: currentUrl.href,
+    pagePath: currentUrl.pathname,
+    pageQuery: currentUrl.search || undefined,
+    referrerUrl: document.referrer || undefined,
+    utmSource: params.get('utm_source') || undefined,
+    utmMedium: params.get('utm_medium') || undefined,
+    utmCampaign: params.get('utm_campaign') || undefined,
+    utmTerm: params.get('utm_term') || undefined,
+    utmContent: params.get('utm_content') || undefined,
+    gclid: params.get('gclid') || undefined,
+    fbclid: params.get('fbclid') || undefined,
+    msclkid: params.get('msclkid') || undefined,
+    partnerId: partnerFromQuery,
+    partnerSlug: partnerSlugFromPath,
+    agentId: agentIdFromQuery,
+    agentName: agentNameFromQuery,
+  });
+}
+
+export function mergeBookingSourceMetadata(
+  ...layers: Array<Partial<BookingSourceMetadata> | null | undefined>
+): Partial<BookingSourceMetadata> {
+  let acc: Partial<BookingSourceMetadata> = {};
+  for (const layer of layers) {
+    if (!layer) continue;
+    acc = { ...acc, ...withDefinedValues(layer as BookingSourceMetadata) };
+  }
+  return acc;
+}
+
+function hostnameForSourceDecision(merged: Partial<BookingSourceMetadata>): string {
+  if (typeof window !== 'undefined') {
+    try {
+      return new URL(window.location.href).hostname.toLowerCase();
+    } catch {
+      return '';
+    }
+  }
+  const pu = merged.pageUrl?.trim();
+  if (!pu) return '';
+  try {
+    return new URL(pu).hostname.toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+export type BuildBookingSourceContextOptions = {
+  clientChannelSource?: KnownBookingSource;
+  forcePartnerPortalChannel?: boolean;
+  forceDashboardSource?: boolean;
+};
+
+export function buildBookingSourceContext(
+  mergedMetadata: Partial<BookingSourceMetadata>,
+  options?: BuildBookingSourceContextOptions,
+): {
+  source: KnownBookingSource;
+  sourceMetadata?: BookingSourceMetadata;
+  source_metadata?: BookingSourceMetadata;
+} {
+  const merged = withDefinedValues(mergedMetadata as BookingSourceMetadata);
+  const channel = options?.clientChannelSource ?? KnownBookingSource.WEBSITE;
+
+  if (options?.forceDashboardSource === true) {
+    const hasMeta = Object.keys(merged).length > 0;
+    return {
+      source: KnownBookingSource.DASHBOARD,
+      ...(hasMeta
+        ? {
+            sourceMetadata: merged as BookingSourceMetadata,
+            source_metadata: merged as BookingSourceMetadata,
+          }
+        : {}),
+    };
+  }
+
+  if (Object.keys(merged).length === 0) return { source: channel };
+
+  const host = hostnameForSourceDecision(merged);
+  const dedicatedPartnerBookingHost =
+    host === 'booking.viaviamorainelake.com' || host === 'staging.booking.viaviamorainelake.com';
+  const pid = typeof merged.partnerId === 'string' ? merged.partnerId.trim() : '';
+  const pslug = typeof merged.partnerSlug === 'string' ? merged.partnerSlug.trim() : '';
+
+  const forceDedicatedPortal =
+    options?.forcePartnerPortalChannel === true ||
+    (dedicatedPartnerBookingHost && (pid.length > 0 || pslug.length > 0));
+  const mainSitePartnerEmbed =
+    !forceDedicatedPortal && mergedMetadataImpliesPartnerPortal(merged);
+
+  const source = forceDedicatedPortal
+    ? KnownBookingSource.PARTNER_PORTAL
+    : mainSitePartnerEmbed
+      ? KnownBookingSource.PUBLIC_PARTNER_WEBSITE
+      : channel;
+
+  return {
+    source,
+    sourceMetadata: merged as BookingSourceMetadata,
+    source_metadata: merged as BookingSourceMetadata,
+  };
+}

package/src/lib/booking-api-auth.ts

@@ -0,0 +1,9 @@
+let partnerPortalBookingJwtGetter: () => string | null = () => null;
+
+export function setPartnerPortalBookingJwtGetter(fn: () => string | null): void {
+  partnerPortalBookingJwtGetter = fn;
+}
+
+export function getPartnerPortalBookingJwt(): string | null {
+  return partnerPortalBookingJwtGetter();
+}

package/src/lib/env.ts

@@ -0,0 +1,14 @@
+const getApiUrl = (): string => {
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+  if (!apiUrl) return 'http://localhost:3001';
+  return apiUrl;
+};
+
+const getBasicAuth = (): string => process.env.NEXT_PUBLIC_BASIC_AUTH ?? '';
+const getCompanyId = (): string => process.env.NEXT_PUBLIC_COMPANY_ID ?? 'c_LFU0Vx9hS5v3';
+
+export const ENV = {
+  API_URL: getApiUrl(),
+  BASIC_AUTH: getBasicAuth(),
+  COMPANY_ID: getCompanyId(),
+} as const;

package/src/providers/booking-dialog-provider.tsx

@@ -0,0 +1,213 @@
+'use client';
+
+import {
+  createContext,
+  useContext,
+  useState,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  type ReactNode,
+} from 'react';
+import { getOrCreateBookingCorrelationId } from '../correlation-id';
+import { withBookingOutboundHeaders } from '../trace-context';
+import {
+  isSuspiciousBookingProductId,
+  normalizeBookingProductId,
+} from '../lib/booking/normalize-booking-product-id';
+import { ENV } from '../lib/env';
+
+export type ProductGridFilterId =
+  | 'all'
+  | 'sunrise'
+  | 'moraine-lake'
+  | 'lake-louise'
+  | 'emerald-lake'
+  | 'private';
+
+export type BookingScreen =
+  | { type: 'product-grid'; filterId?: ProductGridFilterId }
+  | { type: 'book-flow'; productId: string };
+
+export type ProductGridRestoreState = {
+  expandedId: string | null;
+  scrollTop: number;
+};
+
+export const OPEN_BOOKING_FOR_PRODUCT = 'openBookingForProduct';
+export const OPEN_BOOKING_WITH_FILTER = 'openBookingWithFilter';
+export const BOOKING_FLOW_ABANDON_EVENT = 'ticketbooth:booking-flow-abandon';
+
+function reportSuspiciousBookingProductId(original: string, sanitized: string): void {
+  if (typeof window === 'undefined') return;
+  const telemetryEndpoint = `${ENV.API_URL}/1/client-telemetry`;
+  const correlationId = getOrCreateBookingCorrelationId();
+  const event = {
+    event: 'BOOKING_DIALOG_SUSPICIOUS_PRODUCT_ID',
+    endpoint: '/booking-open',
+    correlationId,
+    originalProductId: original,
+    sanitizedProductId: sanitized,
+    pageUrl: window.location.href,
+    referrer: document.referrer || null,
+    userAgent: window.navigator.userAgent,
+    occurredAt: new Date().toISOString(),
+    stack: new Error('Suspicious booking productId input').stack ?? null,
+  };
+  fetch(telemetryEndpoint, {
+    method: 'POST',
+    headers: withBookingOutboundHeaders({ 'Content-Type': 'application/json' }),
+    body: JSON.stringify(event),
+    keepalive: true,
+  }).catch(() => {});
+}
+
+interface BookingDialogContextValue {
+  isOpen: boolean;
+  open: (options?: { filterId?: ProductGridFilterId }) => void;
+  openForProduct: (productId: string) => void;
+  close: (options?: { reason?: 'user' | 'completed' }) => void;
+  stack: BookingScreen[];
+  push: (screen: BookingScreen, options?: { productGridState?: ProductGridRestoreState }) => void;
+  pop: () => void;
+  canGoBack: boolean;
+  productGridRestoreState: ProductGridRestoreState | null;
+  clearProductGridRestoreState: () => void;
+}
+
+const BookingDialogContext = createContext<BookingDialogContextValue | null>(null);
+
+export function useBookingDialog() {
+  const ctx = useContext(BookingDialogContext);
+  if (!ctx) throw new Error('useBookingDialog must be used within BookingDialogProvider');
+  return ctx;
+}
+
+export function BookingDialogProvider({ children }: { children: ReactNode }) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [stack, setStack] = useState<BookingScreen[]>([{ type: 'product-grid' }]);
+  const [productGridRestoreState, setProductGridRestoreState] = useState<ProductGridRestoreState | null>(null);
+  const previouslyFocusedRef = useRef<HTMLElement | null>(null);
+
+  const open = useCallback((options?: { filterId?: ProductGridFilterId }) => {
+    previouslyFocusedRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    setStack([{ type: 'product-grid', filterId: options?.filterId }]);
+    setProductGridRestoreState(null);
+    setIsOpen(true);
+  }, []);
+
+  const openForProduct = useCallback((productId: string) => {
+    const sanitizedProductId = normalizeBookingProductId(productId);
+    if (!sanitizedProductId) return;
+    if (isSuspiciousBookingProductId(productId)) {
+      reportSuspiciousBookingProductId(productId, sanitizedProductId);
+    }
+    previouslyFocusedRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    setStack([{ type: 'book-flow', productId: sanitizedProductId }]);
+    setProductGridRestoreState(null);
+    setIsOpen(true);
+  }, []);
+
+  const close = useCallback((options?: { reason?: 'user' | 'completed' }) => {
+    if (options?.reason !== 'completed' && typeof window !== 'undefined') {
+      window.dispatchEvent(new Event(BOOKING_FLOW_ABANDON_EVENT));
+    }
+    const prev = previouslyFocusedRef.current;
+    setIsOpen(false);
+    requestAnimationFrame(() => {
+      if (prev && typeof prev.focus === 'function') prev.focus();
+    });
+  }, []);
+
+  const push = useCallback((screen: BookingScreen, options?: { productGridState?: ProductGridRestoreState }) => {
+    if (options?.productGridState) setProductGridRestoreState(options.productGridState);
+    setStack((prev) => [...prev, screen]);
+  }, []);
+
+  const pop = useCallback(() => {
+    setStack((prev) => (prev.length > 1 ? prev.slice(0, -1) : prev));
+  }, []);
+
+  const clearProductGridRestoreState = useCallback(() => {
+    setProductGridRestoreState(null);
+  }, []);
+
+  useEffect(() => {
+    const handleOpen = () => open();
+    window.addEventListener('openSimpleModal', handleOpen);
+    return () => window.removeEventListener('openSimpleModal', handleOpen);
+  }, [open]);
+
+  useEffect(() => {
+    const handleOpenWithFilter = (e: Event) => {
+      const customEvent = e as CustomEvent<{ filterId: ProductGridFilterId }>;
+      const filterId = customEvent.detail?.filterId;
+      if (filterId) open({ filterId });
+      else open();
+    };
+    window.addEventListener(OPEN_BOOKING_WITH_FILTER, handleOpenWithFilter);
+    return () => window.removeEventListener(OPEN_BOOKING_WITH_FILTER, handleOpenWithFilter);
+  }, [open]);
+
+  useEffect(() => {
+    const handleOpenForProduct = (e: Event) => {
+      const customEvent = e as CustomEvent<{ productId: string }>;
+      const productId = customEvent.detail?.productId;
+      if (productId) openForProduct(productId);
+    };
+    window.addEventListener(OPEN_BOOKING_FOR_PRODUCT, handleOpenForProduct);
+    return () => window.removeEventListener(OPEN_BOOKING_FOR_PRODUCT, handleOpenForProduct);
+  }, [openForProduct]);
+
+  useEffect(() => {
+    const handlePageShow = (e: PageTransitionEvent) => {
+      if (e.persisted && isOpen) close();
+    };
+    window.addEventListener('pageshow', handlePageShow);
+    return () => window.removeEventListener('pageshow', handlePageShow);
+  }, [isOpen, close]);
+
+  useEffect(() => {
+    const handleBookNowClick = (e: Event) => {
+      const target = e.target as HTMLElement;
+      const link = target.closest('a[href^="#book-now"]') as HTMLAnchorElement | null;
+      if (!link) return;
+      e.preventDefault();
+      const href = link.getAttribute('href') ?? '';
+      const filterMatch = href.match(/^#book-now\/filter\/([a-z0-9-]+)$/i);
+      if (filterMatch) {
+        const filterId = filterMatch[1] as ProductGridFilterId;
+        if (['sunrise', 'moraine-lake', 'lake-louise', 'emerald-lake', 'private'].includes(filterId)) {
+          open({ filterId });
+          return;
+        }
+      }
+      const productMatch = href.match(/^#book-now\/([a-z0-9-]+)$/i);
+      const productSlug = productMatch?.[1];
+      if (productSlug) openForProduct(productSlug);
+      else open();
+    };
+    document.addEventListener('click', handleBookNowClick);
+    return () => document.removeEventListener('click', handleBookNowClick);
+  }, [open, openForProduct]);
+
+  const canGoBack = stack.length > 1;
+  const value = useMemo(
+    () => ({
+      isOpen,
+      open,
+      openForProduct,
+      close,
+      stack,
+      push,
+      pop,
+      canGoBack,
+      productGridRestoreState,
+      clearProductGridRestoreState,
+    }),
+    [isOpen, open, openForProduct, close, stack, push, pop, canGoBack, productGridRestoreState, clearProductGridRestoreState]
+  );
+
+  return <BookingDialogContext.Provider value={value}>{children}</BookingDialogContext.Provider>;
+}