@ticketboothapp/booking 0.1.4 → 0.1.8

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

@@ -0,0 +1,192 @@
+{
+  "common": {
+    "back": "Retour",
+    "continue": "Continuer",
+    "select": "Sélectionner",
+    "change": "Changer",
+    "cancel": "Annuler",
+    "close": "Fermer",
+    "loading": "Chargement...",
+    "error": "Erreur",
+    "total": "Total",
+    "email": "Courriel",
+    "emailPlaceholder": "votre@courriel.com",
+    "emailForConfirmation": "Courriel (pour confirmation)"
+  },
+  "booking": {
+    "selectDate": "Sélectionner la date",
+    "selectPickupTime": "Sélectionner l'heure de prise en charge",
+    "requestDifferentTime": "Demander une autre heure",
+    "preferredPickupTime": "Heure de prise en charge préférée",
+    "selectReturnTime": "Sélectionner l'heure de retour",
+    "mostPopular": "Le plus populaire",
+    "pickupAtTourStart": "<b>Votre heure de prise en charge dépend de votre lieu de prise en charge.</b><br>Votre heure de prise en charge exacte sera confirmée une fois que vous aurez confirmé votre lieu de prise en charge. Les prises en charge commencent à Canmore et se terminent à Lake Louise.",
+    "pickupAtTourStartLocation": "lieu de départ du tour",
+    "pickupLocationUnknown": "Je ne sais pas",
+    "arrivalTimeMessage": "Vous arriverez à {destination} vers <b>{time}</b>.",
+    "yourItinerary": "Votre itinéraire",
+    "buildYourItinerary": "Construisez votre itinéraire",
+    "selectPickupTimeToSeeItinerary": "Sélectionnez une heure de prise en charge ci-dessous pour voir votre horaire.",
+    "selectTourOption": "Sélectionner l'option de tour",
+    "selectTourOptionToSeeItinerary": "Sélectionnez une option de tour ci-dessous pour voir votre itinéraire.",
+    "timesToBeDetermined": "heures à confirmer…",
+    "proposedStops": "Arrêts proposés",
+    "orderAndTimesToBeConfirmed": "(ordre et horaires à confirmer par notre équipe)",
+    "startingAtPerShuttle": "À partir de {price} par navette",
+    "hoursTour": "Tour de {hours} h",
+    "hoursTourStarting": "Tour commençant avec {hours} heures",
+    "startingAtForHours": "À partir de {price} par navette pour {hours}.",
+    "hoursUnit": "heures",
+    "additionalHoursAvailable": "Heures supplémentaires disponibles moyennant des frais.",
+    "pickupAt": "Prise en charge à",
+    "pickupAtPrefix": "Prise en charge à ",
+    "pickupAtLocation": "Prise en charge à {location}",
+    "arriveAt": "Arrivée à",
+    "arriveAtPlace": "Arrivée à {place}",
+    "departFrom": "Départ de",
+    "departFromPlace": "Départ de {place}",
+    "dropOffAt": "Retour à {location}",
+    "dropOffAtPrefix": "Retour à ",
+    "tripEnd": "Fin du voyage",
+    "stopAtPlaceTbd": "Arrêt à {place} (heure à confirmer)",
+    "placeTheDestination": "le lieu de destination",
+    "dropOffAtPickup": "Arrivée à {pickupLocation}",
+    "yourPickupLocation": "votre lieu de prise en charge",
+    "tickets": "Billets",
+    "available": "disponible",
+    "soldOut": "Complet",
+    "continueToPayment": "Continuer vers le paiement",
+    "creatingReservation": "Création de la réservation...",
+    "securePayment": "Paiement sécurisé par Stripe",
+    "selectTimeAndTickets": "Veuillez sélectionner une heure et au moins un billet",
+    "selectPickupLocation": "Veuillez sélectionner un lieu de prise en charge",
+    "loadingTimes": "Chargement des heures disponibles...",
+    "noAvailability": "Aucune disponibilité trouvée pour les 30 prochains jours. Veuillez réessayer plus tard.",
+    "communicationPreference": "Comment souhaitez-vous recevoir les communications futures (confirmation, rappels, etc.)?",
+    "communicationEmail": "Courriel",
+    "communicationEmailDesc": "Envoyer la confirmation par courriel",
+    "communicationWhatsApp": "WhatsApp",
+    "communicationWhatsAppDesc": "Envoyer la confirmation par WhatsApp",
+    "emailForConfirmation": "Courriel",
+    "phoneNumberForConfirmation": "Numéro de téléphone",
+    "phoneNumberPlaceholder": "(555) 123-4567",
+    "invalidEmail": "Veuillez entrer une adresse courriel valide",
+    "invalidPhoneNumber": "Veuillez entrer un numéro de téléphone valide",
+    "selectCommunicationPreference": "Veuillez sélectionner comment vous souhaitez recevoir votre confirmation",
+    "enterEmail": "Veuillez entrer votre adresse courriel",
+    "enterLastName": "Veuillez entrer votre nom de famille",
+    "enterPhoneNumber": "Veuillez entrer votre numéro de téléphone",
+    "firstName": "Prénom",
+    "firstNamePlaceholder": "Jeanne",
+    "lastName": "Nom de famille",
+    "lastNamePlaceholder": "Dupont",
+    "noActiveOption": "Aucune option de produit disponible",
+    "people": "personnes",
+    "person": "personne",
+    "rounding": "Arrondi",
+    "deposit": "Acompte",
+    "subtotal": "Sous-total",
+    "tax": "Taxes et frais",
+    "returnOption": "Option de retour",
+    "fromPrice": "À partir de {price}",
+    "communicationPermission": "En fournissant vos coordonnées, vous autorisez la réception de confirmations de réservation, de rappels et de mises à jour par cette méthode.",
+    "communicationPermissionCheckbox": "J'autorise la réception de communications par cette méthode",
+    "communicationPermissionRequired": "Veuillez sélectionner au moins une méthode de communication",
+    "emailPermissionCheckbox": "Me contacter par courriel (nous ne vous enverrons que les communications pertinentes pour votre réservation)",
+    "whatsappPermissionCheckbox": "Me contacter par WhatsApp (nous ne vous enverrons que les communications pertinentes pour votre réservation)",
+    "reviewAndPay": "Réviser et payer",
+    "payNow": "Payer maintenant",
+    "paying": "Paiement en cours...",
+    "checkout": "Paiement",
+    "paymentNotConfigured": "Le paiement n'est pas configuré. Veuillez utiliser le paiement standard.",
+    "loadingPayment": "Chargement du formulaire de paiement...",
+    "promoCode": "Code promo",
+    "optionalPromoCode": "Promo / bon / carte cadeau",
+    "promoCodePlaceholder": "Entrez le code",
+    "applyPromo": "Appliquer",
+    "removePromo": "Retirer",
+    "promoApplied": "Appliqué : {{code}}",
+    "invalidPromoCode": "Code promo invalide ou expiré",
+    "promoCodesCannotStackWithDiscounts": "Les codes promo ne peuvent pas être cumulés avec les offres",
+    "discount": "Réduction",
+    "cancellationPolicy": "Politique d'annulation",
+    "promoRequiresCancellationPolicy": "Ce code promo exige {{policy}}",
+    "promoRequiresThisPolicy": "Exigé par votre code promo",
+    "cancellationStandard": "Annulation standard",
+    "included": "Inclus",
+    "flexibleCancellation": "Annulation flexible",
+    "depositPaymentNotice": "Vous payez l'acompte aujourd'hui.",
+    "balanceChargeNotice": "Le solde restant sera facturé {days} jours avant votre réservation. Vous pouvez également le payer plus tôt depuis la page Gérer ma réservation.",
+    "balancePayEarlier": "Vous pouvez payer le solde restant à tout moment depuis la page Gérer ma réservation.",
+    "remainingBalance": "Solde restant"
+  },
+  "pickup": {
+    "title": "Savez-vous où vous souhaitez être pris en charge?",
+    "yesAddNow": "Oui, je peux l'ajouter maintenant",
+    "dontKnow": "Je ne sais pas encore",
+    "pickupLocation": "Lieu de prise en charge",
+    "enterAddress": "Entrez votre adresse de prise en charge",
+    "searchingLocation": "Recherche de l'emplacement...",
+    "locationNotFound": "Impossible de trouver cet emplacement. Veuillez essayer une autre adresse.",
+    "chooseNearby": "Choisissez un lieu de prise en charge à proximité",
+    "exactMatch": "Correspondance exacte trouvée",
+    "locationsInCity": "Points de ramassage à {{city}}",
+    "selectThisLocation": "Sélectionner ce lieu",
+    "yourLocation": "Votre emplacement",
+    "chooseClosest": "Choisissez un lieu de prise en charge ci-dessous pour voir l'option la plus proche.",
+    "useThisAddress": "Utiliser cette adresse",
+    "away": "de distance",
+    "walk": "à pied",
+    "drive": "en voiture",
+    "switchUnits": "Passer aux unités {unit}",
+    "metric": "métriques",
+    "imperial": "impériales",
+    "dontKnowSubtext": "Nous vous enverrons des rappels pour sélectionner votre lieu de prise en charge.",
+    "yesAddNowSubtext": "Vous pourrez modifier cela plus tard.",
+    "skipWarningTitle": "Avis important",
+    "skipWarningMessage": "Vous n'êtes pas garanti d'être pris en charge si vous ne <b>mettez pas à jour votre réservation avec votre lieu de prise en charge au moins 12 heures à l'avance</b>.",
+    "iUnderstand": "Je comprends"
+  },
+  "calendar": {
+    "previousWeeks": "2 semaines précédentes",
+    "nextWeeks": "2 semaines suivantes",
+    "soldOut": "Complet",
+    "left": "{count} restant",
+    "days": {
+      "sun": "DIM",
+      "mon": "LUN",
+      "tue": "MAR",
+      "wed": "MER",
+      "thu": "JEU",
+      "fri": "VEN",
+      "sat": "SAM"
+    },
+    "months": {
+      "january": "Janvier",
+      "february": "Février",
+      "march": "Mars",
+      "april": "Avril",
+      "may": "Mai",
+      "june": "Juin",
+      "july": "Juillet",
+      "august": "Août",
+      "september": "Septembre",
+      "october": "Octobre",
+      "november": "Novembre",
+      "december": "Décembre"
+    }
+  },
+  "products": {
+    "backToExperiences": "Retour aux expériences",
+    "from": "À partir de",
+    "noDescription": "Aucune description disponible"
+  },
+  "terms": {
+    "title": "Conditions générales",
+    "viewTerms": "Conditions générales",
+    "acceptPrefix": "J'accepte les",
+    "acceptAndClose": "J'ai lu et j'accepte",
+    "content": "En finalisant cette réservation, vous acceptez les conditions générales suivantes.\n\n1. Réservation et paiement\nVotre réservation est confirmée une fois le paiement traité. Vous recevrez une confirmation par courriel ou par le mode de contact choisi.\n\n2. Annulation et modifications\nLes politiques d'annulation et de modification dépendent de l'option choisie au paiement. Veuillez consulter votre confirmation pour la politique applicable.\n\n3. Participation\nVous êtes responsable d'arriver à l'heure et au lieu indiqués. Un retard peut entraîner la perte de l'expérience sans remboursement.\n\n4. Responsabilité\nL'opérateur n'est pas responsable des pertes ou dommages au-delà de ce qu'exige la loi applicable. La participation est à vos risques lorsque les activités comportent des risques inhérents.\n\n5. Contact\nPour toute question ou modification de réservation, utilisez les coordonnées indiquées dans votre confirmation."
+  }
+}
+

package/src/lib/itinerary-labels.ts

@@ -0,0 +1,70 @@
+import type { ItineraryDisplayStep } from './api';
+
+export type TranslationFn = (key: string, params?: Record<string, string>) => string;
+
+/** Step shape accepted for label building (stepType may be string when from JSON). */
+type StepForLabel = Pick<ItineraryDisplayStep, 'time' | 'place'> & { stepType: string };
+
+const EN_PLACE: Record<string, string> = {
+  your_pickup_location: 'your pickup location',
+  the_destination: 'the destination',
+};
+
+/**
+ * English-only label (for provider dashboard, email, or when t() is not available).
+ */
+export function getStepLabelEn(step: StepForLabel): string {
+  const place = step.place;
+  const placeDisplay = place ? (EN_PLACE[place] ?? place) : '';
+
+  switch (step.stepType) {
+    case 'pickup':
+      return `Pickup at ${placeDisplay}`;
+    case 'drop_off':
+      return `Drop off at ${placeDisplay}`;
+    case 'arrive':
+      return `Arrive at ${place ?? ''}`;
+    case 'depart':
+      return `Depart ${place ?? ''}`;
+    case 'trip_end':
+      return 'Trip ends';
+    case 'draft':
+      return `Stop at ${place ?? ''} (time TBD)`;
+    default:
+      return place ? `${place}` : step.stepType;
+  }
+}
+
+/**
+ * Builds the display label for an itinerary step from stepType + place.
+ * All labels are built on the FE so the user's language choice is respected.
+ */
+export function getStepLabel(
+  step: StepForLabel,
+  t: TranslationFn
+): string {
+  const place = step.place;
+  const placeDisplay =
+    place === 'your_pickup_location'
+      ? t('booking.yourPickupLocation')
+      : place === 'the_destination'
+        ? t('booking.placeTheDestination')
+        : place ?? '';
+
+  switch (step.stepType) {
+    case 'pickup':
+      return t('booking.pickupAtLocation', { location: placeDisplay });
+    case 'drop_off':
+      return t('booking.dropOffAt', { location: placeDisplay });
+    case 'arrive':
+      return t('booking.arriveAtPlace', { place: place ?? '' });
+    case 'depart':
+      return t('booking.departFromPlace', { place: place ?? '' });
+    case 'trip_end':
+      return t('booking.tripEnd');
+    case 'draft':
+      return t('booking.stopAtPlaceTbd', { place: place ?? '' });
+    default:
+      return place ? `${place}` : step.stepType;
+  }
+}

package/src/lib/location-calculations.ts

@@ -0,0 +1,43 @@
+/**
+ * Location calculation utilities
+ */
+
+import type { PickupLocation } from './api';
+import type { Coordinates } from './location-utils';
+import type { NearbyLocation } from './pickup-location-types';
+import {
+  calculateDistance,
+  estimateWalkingTime,
+  estimateDrivingTime,
+} from './location-utils';
+
+const EXACT_MATCH_THRESHOLD_KM = 0.05; // 50 meters - tighter threshold for exact matches
+
+/**
+ * Calculate nearby locations with distances and travel times
+ */
+export function calculateNearbyLocations(
+  searchCoordinates: Coordinates,
+  pickupLocations: PickupLocation[]
+): NearbyLocation[] {
+  return pickupLocations
+    .filter((loc) => loc.coordinates)
+    .map((loc) => {
+      const distance = calculateDistance(searchCoordinates, loc.coordinates!);
+      return {
+        ...loc,
+        distance,
+        walkingTime: estimateWalkingTime(distance),
+        drivingTime: estimateDrivingTime(distance),
+      };
+    })
+    .sort((a, b) => a.distance - b.distance);
+}
+
+/**
+ * Check if searched location is very close to a pickup location (exact match)
+ */
+export function isExactMatch(nearbyLocations: NearbyLocation[]): boolean {
+  return nearbyLocations.some((loc) => loc.distance < EXACT_MATCH_THRESHOLD_KM);
+}
+

package/src/lib/location-utils.ts

@@ -0,0 +1,139 @@
+// Location utilities for distance calculation and travel time estimation
+
+export interface Coordinates {
+  lat: number;
+  lng: number;
+}
+
+/**
+ * Calculate the distance between two coordinates using the Haversine formula
+ * Returns distance in kilometers
+ */
+export function calculateDistance(
+  coord1: Coordinates,
+  coord2: Coordinates
+): number {
+  const R = 6371; // Earth's radius in kilometers
+  const dLat = toRadians(coord2.lat - coord1.lat);
+  const dLon = toRadians(coord2.lng - coord1.lng);
+  
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos(toRadians(coord1.lat)) *
+      Math.cos(toRadians(coord2.lat)) *
+      Math.sin(dLon / 2) *
+      Math.sin(dLon / 2);
+  
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+
+function toRadians(degrees: number): number {
+  return degrees * (Math.PI / 180);
+}
+
+/**
+ * Convert kilometers to miles
+ */
+export function kmToMiles(km: number): number {
+  return km * 0.621371;
+}
+
+/**
+ * Convert miles to kilometers
+ */
+export function milesToKm(miles: number): number {
+  return miles * 1.60934;
+}
+
+/**
+ * Estimate walking time in minutes
+ * Assumes average walking speed of 5 km/h
+ */
+export function estimateWalkingTime(distanceKm: number): number {
+  const walkingSpeedKmh = 5;
+  return Math.round((distanceKm / walkingSpeedKmh) * 60);
+}
+
+/**
+ * Estimate driving time in minutes
+ * Assumes average driving speed of 50 km/h (urban/suburban)
+ */
+export function estimateDrivingTime(distanceKm: number): number {
+  const drivingSpeedKmh = 50;
+  return Math.round((distanceKm / drivingSpeedKmh) * 60);
+}
+
+/**
+ * Format distance with appropriate unit
+ */
+export function formatDistance(
+  distanceKm: number,
+  useImperial: boolean = false
+): string {
+  if (useImperial) {
+    const miles = kmToMiles(distanceKm);
+    if (miles < 0.1) {
+      return `${Math.round(miles * 5280)} ft`;
+    } else if (miles < 1) {
+      return `${miles.toFixed(1)} mi`;
+    } else {
+      return `${miles.toFixed(1)} mi`;
+    }
+  } else {
+    if (distanceKm < 0.1) {
+      return `${Math.round(distanceKm * 1000)} m`;
+    } else if (distanceKm < 1) {
+      return `${Math.round(distanceKm * 1000)} m`;
+    } else {
+      return `${distanceKm.toFixed(1)} km`;
+    }
+  }
+}
+
+/**
+ * Format time duration
+ */
+export function formatTime(minutes: number): string {
+  if (minutes < 60) {
+    return `${minutes} min`;
+  } else {
+    const hours = Math.floor(minutes / 60);
+    const mins = minutes % 60;
+    return mins > 0 ? `${hours} h ${mins} min` : `${hours} h`;
+  }
+}
+
+/**
+ * Geocode an address using Google Maps Geocoding API
+ * Note: This requires a Google Maps API key
+ */
+export async function geocodeAddress(
+  address: string,
+  apiKey?: string
+): Promise<Coordinates | null> {
+  if (!apiKey) {
+    // Fallback: try to use browser geolocation or return null
+    console.warn('Google Maps API key not provided');
+    return null;
+  }
+
+  try {
+    const response = await fetch(
+      `https://maps.googleapis.com/maps/api/geocode/json?address=${encodeURIComponent(
+        address
+      )}&key=${apiKey}`
+    );
+    const data = await response.json();
+    
+    if (data.status === 'OK' && data.results.length > 0) {
+      const location = data.results[0].geometry.location;
+      return { lat: location.lat, lng: location.lng };
+    }
+    return null;
+  } catch (error) {
+    console.error('Geocoding error:', error);
+    return null;
+  }
+}
+

package/src/lib/map-utils.ts

@@ -0,0 +1,153 @@
+/**
+ * Google Maps utilities
+ */
+
+import type { Coordinates } from './location-utils';
+import type { PickupLocation } from './api';
+import type { NearbyLocation } from './pickup-location-types';
+
+export interface MapCenter {
+  lat: number;
+  lng: number;
+}
+
+const DEFAULT_CENTER: MapCenter = { lat: 51.1784, lng: -115.5708 };
+
+/**
+ * Calculate map center based on available locations
+ */
+export function calculateMapCenter(
+  searchedLocation: { coordinates: Coordinates | null } | null,
+  nearbyLocations: NearbyLocation[],
+  pickupLocations: PickupLocation[]
+): MapCenter {
+  // Prioritize searched location - center on it when found
+  if (searchedLocation?.coordinates) {
+    return searchedLocation.coordinates;
+  }
+
+  if (nearbyLocations.length > 0 && nearbyLocations[0].coordinates) {
+    return {
+      lat: nearbyLocations[0].coordinates.lat,
+      lng: nearbyLocations[0].coordinates.lng,
+    };
+  }
+
+  // Default to first pickup location if available
+  if (pickupLocations.length > 0 && pickupLocations[0].coordinates) {
+    return {
+      lat: pickupLocations[0].coordinates.lat,
+      lng: pickupLocations[0].coordinates.lng,
+    };
+  }
+
+  return DEFAULT_CENTER;
+}
+
+/**
+ * Get map options configuration
+ * Note: Returns a plain object that will be typed by Google Maps API
+ */
+export function getMapOptions(): google.maps.MapOptions {
+  return {
+    disableDefaultUI: false,
+    clickableIcons: false,
+    scrollwheel: true,
+    zoomControl: true,
+    streetViewControl: false,
+    mapTypeControl: false,
+    fullscreenControl: true,
+    gestureHandling: 'cooperative',
+    panControl: false,
+  } as google.maps.MapOptions;
+}
+
+/**
+ * Calculate bounds for all locations to fit on map
+ * Note: Requires Google Maps API to be loaded
+ */
+export function calculateMapBounds(
+  nearbyLocations: NearbyLocation[],
+  searchedLocation: { coordinates: Coordinates | null } | null,
+  isValidLocation: boolean | null,
+  pickupLocations: PickupLocation[]
+): google.maps.LatLngBounds | null {
+  if (typeof google === 'undefined' || !google.maps) {
+    console.warn('Google Maps API not loaded');
+    return null;
+  }
+
+  try {
+    const bounds = new google.maps.LatLngBounds();
+    let hasLocations = false;
+
+    // Add nearby locations to bounds (if user searched)
+    nearbyLocations.forEach((location) => {
+      if (location.coordinates) {
+        bounds.extend(location.coordinates);
+        hasLocations = true;
+      }
+    });
+
+    // Add searched location to bounds if invalid
+    if (searchedLocation?.coordinates && !isValidLocation) {
+      bounds.extend(searchedLocation.coordinates);
+      hasLocations = true;
+    }
+
+    // If no search results, show all pickup locations
+    if (!hasLocations) {
+      pickupLocations.forEach((location) => {
+        if (location.coordinates) {
+          bounds.extend(location.coordinates);
+          hasLocations = true;
+        }
+      });
+    }
+
+    return hasLocations ? bounds : null;
+  } catch (error) {
+    console.error('Error calculating map bounds:', error);
+    return null;
+  }
+}
+
+/**
+ * Pan map to location if it's outside viewport
+ * Note: Requires Google Maps API to be loaded
+ */
+export function panToLocationIfNeeded(
+  map: google.maps.Map,
+  coordinates: Coordinates
+): void {
+  if (typeof google === 'undefined' || !google.maps) {
+    console.warn('Google Maps API not loaded');
+    return;
+  }
+
+  try {
+    const latLng = new google.maps.LatLng(coordinates.lat, coordinates.lng);
+    const bounds = map.getBounds();
+
+    if (bounds && !bounds.contains(latLng)) {
+      const currentCenter = map.getCenter();
+      if (currentCenter) {
+        const panBounds = new google.maps.LatLngBounds();
+        panBounds.extend(currentCenter);
+        panBounds.extend(latLng);
+        // Add padding to make the pan more visible
+        map.fitBounds(panBounds, {
+          top: 50,
+          right: 50,
+          bottom: 50,
+          left: 50,
+        });
+      } else {
+        map.panTo(latLng);
+      }
+    }
+  } catch (error) {
+    console.error('Error panning map:', error);
+  }
+}
+