@aranova/tracking-react 1.2.4 → 1.3.0

package/dist/index.mjs

@@ -221,6 +221,8 @@ var TRACKING_CAPABILITIES = [
   "ad_tags_meta",
   "base_tracking",
   "blog_rendering",
+  "booking_handoff",
+  "booking_integration",
   "calendar_read",
   "calendar_write",
   "consent_controls",
@@ -500,6 +502,42 @@ function buildLandingPayloadFields(sessionId, override) {
   };
 }
 
+// ../tracking-core/src/uuid.ts
+function uuidV4() {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === "function") return cryptoApi.randomUUID();
+  const bytes = new Uint8Array(16);
+  if (typeof cryptoApi?.getRandomValues === "function") cryptoApi.getRandomValues(bytes);
+  else for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// ../tracking-core/src/session.ts
+var SESSION_STORAGE_KEY = "aranova_tracking_session";
+var SESSION_IDLE_MS = 30 * 60 * 1e3;
+function readLocalStorage(key) {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function peekSessionId(now = Date.now()) {
+  if (typeof window === "undefined") return null;
+  const raw = readLocalStorage(SESSION_STORAGE_KEY);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.id !== "string" || typeof parsed.last_event_at !== "number") return null;
+    return now - parsed.last_event_at <= SESSION_IDLE_MS ? parsed.id : null;
+  } catch {
+    return null;
+  }
+}
+
 // ../tracking-core/src/cross-site-link.ts
 var LINK_PARAM = "_arv";
 var LINK_TOKEN_TTL_MS = 5 * 60 * 1e3;
@@ -641,6 +679,69 @@ function parseFiring(value) {
     currency: typeof f.currency === "string" ? f.currency : null
   };
 }
+function isNumberList(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "number");
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function parseWindowsMap(value) {
+  const windowsByKey = {};
+  if (!value || typeof value !== "object") return windowsByKey;
+  for (const [key, windows] of Object.entries(value)) {
+    if (!windows || typeof windows !== "object") continue;
+    const w = windows;
+    windowsByKey[key] = {
+      morning: isNumberList(w.morning) ? w.morning : [],
+      afternoon: isNumberList(w.afternoon) ? w.afternoon : []
+    };
+  }
+  return windowsByKey;
+}
+function parseBookingRules(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (typeof r.min_days_ahead !== "number" || typeof r.max_days_ahead !== "number") return null;
+  if (!r.hours || typeof r.hours !== "object") return null;
+  const hours = parseWindowsMap(r.hours);
+  return {
+    min_days_ahead: r.min_days_ahead,
+    max_days_ahead: r.max_days_ahead,
+    hours,
+    closed_dates: isStringList(r.closed_dates) ? r.closed_dates : [],
+    special_hours: parseWindowsMap(r.special_hours),
+    vehicle_required: r.vehicle_required === true,
+    drop_off_options: isStringList(r.drop_off_options) ? r.drop_off_options : []
+  };
+}
+function parseBookingOption(value) {
+  if (!value || typeof value !== "object") return [];
+  const o = value;
+  if (typeof o.key !== "string" || !o.key || typeof o.label !== "string") return [];
+  return [{ key: o.key, label: o.label }];
+}
+function parseIntegrations(value) {
+  if (!value || typeof value !== "object") return {};
+  const autoleap = value.autoleap;
+  if (!autoleap || typeof autoleap !== "object") return {};
+  const booking = autoleap.booking;
+  if (!booking || typeof booking !== "object") return {};
+  const b = booking;
+  if (typeof b.fallback_url !== "string" || !b.fallback_url) return {};
+  return {
+    autoleap: {
+      booking: {
+        enabled: b.enabled === true,
+        fallback_url: b.fallback_url,
+        timezone: typeof b.timezone === "string" ? b.timezone : "UTC",
+        config_version: typeof b.config_version === "number" ? b.config_version : null,
+        accepts_bookings: b.accepts_bookings === true,
+        rules: parseBookingRules(b.rules),
+        options: Array.isArray(b.options) ? b.options.flatMap(parseBookingOption) : []
+      }
+    }
+  };
+}
 function parseTrigger(value) {
   if (!value || typeof value !== "object") return null;
   const t = value;
@@ -700,7 +801,8 @@ function parseConversionConfig(raw) {
     meta_pixel_ids: isStringMap(obj.meta_pixel_ids) ? obj.meta_pixel_ids : {},
     services,
     goals,
-    linked_hostnames: Array.isArray(obj.linked_hostnames) ? obj.linked_hostnames.filter((h) => typeof h === "string" && h.length > 0) : []
+    linked_hostnames: Array.isArray(obj.linked_hostnames) ? obj.linked_hostnames.filter((h) => typeof h === "string" && h.length > 0) : [],
+    integrations: parseIntegrations(obj.integrations)
   };
 }
 var CACHE_PREFIX = "_aranova_cfg_";
@@ -1147,6 +1249,13 @@ var TrackingConfigRuntime = class {
   linkedHostnames() {
     return this.current?.linked_hostnames ?? [];
   }
+  /**
+   * Integration blocks, from the cached object even while unconfirmed: the booking fallback
+   * link is safe to show stale. Same reference until the next adopt, for `useSyncExternalStore`.
+   */
+  integrations() {
+    return this.current?.integrations ?? null;
+  }
   async revalidateNow() {
     try {
       const headers = {};
@@ -1316,6 +1425,105 @@ function getTrackingConfigRuntime(ref, fetchImpl) {
   return runtime;
 }
 
+// ../../contracts/autoleap-booking-links.json
+var autoleap_booking_links_default = {
+  hosts: ["myalp.io"]
+};
+
+// ../tracking-core/src/integrations-public.ts
+var HANDOFF_HOSTS = new Set(autoleap_booking_links_default.hosts);
+function getBookingIntegration(integrations) {
+  const booking = integrations?.autoleap?.booking;
+  if (!booking) return null;
+  const rules = booking.rules ? camelRules(booking.rules) : null;
+  return {
+    provider: "autoleap",
+    enabled: booking.enabled,
+    fallbackUrl: booking.fallback_url,
+    acceptsBookings: booking.accepts_bookings && rules !== null && booking.config_version !== null,
+    timezone: booking.timezone,
+    configVersion: booking.config_version,
+    rules,
+    options: booking.options.map((option) => ({ key: option.key, label: option.label }))
+  };
+}
+function camelRules(rules) {
+  return {
+    minDaysAhead: rules.min_days_ahead,
+    maxDaysAhead: rules.max_days_ahead,
+    hours: rules.hours,
+    closedDates: rules.closed_dates,
+    specialHours: rules.special_hours,
+    vehicleRequired: rules.vehicle_required,
+    dropOffOptions: rules.drop_off_options
+  };
+}
+var WEEKDAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+function shopToday(timeZone, now = /* @__PURE__ */ new Date()) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(now);
+  const part = (type) => parts.find((p) => p.type === type)?.value ?? "";
+  return `${part("year")}-${part("month")}-${part("day")}`;
+}
+function addDays(isoDate, days) {
+  const [year, month, day] = isoDate.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day + days));
+  return date.toISOString().slice(0, 10);
+}
+function bookableSlots(rules, { timeZone, now = /* @__PURE__ */ new Date() }) {
+  const today = shopToday(timeZone, now);
+  const days = [];
+  const closed = new Set(rules.closedDates);
+  for (let offset = rules.minDaysAhead; offset <= rules.maxDaysAhead; offset += 1) {
+    const date = addDays(today, offset);
+    if (closed.has(date)) continue;
+    const weekday = WEEKDAYS[(/* @__PURE__ */ new Date(`${date}T00:00:00Z`)).getUTCDay()];
+    const windows = rules.specialHours[date] ?? rules.hours[weekday];
+    if (!windows || windows.morning.length === 0 && windows.afternoon.length === 0) continue;
+    days.push({
+      date,
+      weekday,
+      morning: [...windows.morning],
+      afternoon: [...windows.afternoon]
+    });
+  }
+  return days;
+}
+function buildBookingHandoffUrl(fallbackUrl, prefill = {}) {
+  let url;
+  try {
+    url = new URL(fallbackUrl);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" || !HANDOFF_HOSTS.has(url.hostname) || url.username || url.password || url.port) {
+    return null;
+  }
+  const [firstName, lastName] = prefill.firstName?.trim() ? [prefill.firstName, prefill.lastName] : splitFullName(prefill.name);
+  const values = [
+    ["firstName", firstName?.trim()],
+    ["lastName", lastName?.trim()],
+    ["phone", prefill.phone ? nationalDigits(prefill.phone) : ""],
+    ["email", prefill.email?.trim()]
+  ];
+  for (const [key, value] of values) {
+    if (value) url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
+function splitFullName(name) {
+  const [first = "", ...rest] = (name ?? "").trim().split(/\s+/);
+  return [first, rest.join(" ")];
+}
+function nationalDigits(phone) {
+  const parsed = parsePhone(phone);
+  return (parsed.isValid ? parsed.national : phone).replace(/\D/g, "");
+}
+
 // ../tracking-core/src/events/semantics.ts
 var EVENT_SEMANTICS = {
   page_view: {
@@ -1422,6 +1630,7 @@ var AranovaApiError = class extends Error {
     this.status = options.status;
     this.code = options.code;
     this.requestId = options.requestId;
+    this.context = options.context;
   }
 };
 
@@ -1448,19 +1657,24 @@ async function apiRequest(config, method, path, body, extraHeaders) {
   if (!response.ok) {
     let detail;
     let code;
+    let context;
     try {
       const parsed = await response.json();
       if (parsed && typeof parsed === "object") {
         const record3 = parsed;
         if (typeof record3.detail === "string") detail = record3.detail;
         if (typeof record3.code === "string") code = record3.code;
+        if (record3.context && typeof record3.context === "object") {
+          context = record3.context;
+        }
       }
     } catch {
     }
     throw new AranovaApiError(detail ?? response.statusText ?? "Request failed", {
       status: response.status,
       code,
-      requestId: response.headers.get("x-request-id") ?? void 0
+      requestId: response.headers.get("x-request-id") ?? void 0,
+      context
     });
   }
   if (response.status === 204) return void 0;
@@ -1470,6 +1684,179 @@ async function apiRequest(config, method, path, body, extraHeaders) {
 // ../tracking-core/src/resources/sales/transport.ts
 var salesRequest = apiRequest;
 
+// ../tracking-core/src/resources/sales/bookings.ts
+var BOOKING_ERROR_CODES = {
+  unavailable: "booking_unavailable",
+  stale: "booking_config_stale",
+  rejected: "booking_rejected"
+};
+var POLL_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
+var INVALID_DETAILS = "Please check your details and try again.";
+var newBookingAttemptKey = uuidV4;
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function outcomeOf(body) {
+  if (body.status === "created")
+    return { status: "created", id: body.id, requestCode: body.request_code };
+  if (body.status === "pending") return { status: "pending", id: body.id };
+  return { status: "failed", id: body.id, fallbackUrl: body.fallback_url };
+}
+function formSubmitPayload(input, formId, labels) {
+  const vehicle = input.vehicle ? `${input.vehicle.year} ${input.vehicle.make} ${input.vehicle.model}` : "";
+  const field = (name, type, label, value) => ({
+    name,
+    type,
+    label,
+    value
+  });
+  return {
+    form: {
+      id: formId,
+      action: "/tracking/bookings",
+      fields: [
+        field("first_name", "text", "First name", input.firstName),
+        field("last_name", "text", "Last name", input.lastName),
+        // E.164 on the wire: it keys the customer and enhanced-conversion matching.
+        field("phone", "tel", "Phone", toE164(input.phone) ?? input.phone),
+        field("email", "email", "Email", input.email ?? ""),
+        field(
+          "service",
+          "select",
+          "Service",
+          input.services.map((key) => labels.get(key) ?? key).join(", ")
+        ),
+        field("vehicle", "text", "Vehicle", vehicle),
+        field(
+          "start",
+          "text",
+          "Requested time",
+          `${input.startDate} ${String(input.startHour).padStart(2, "0")}:00`
+        ),
+        field("note", "textarea", "Notes", input.notes ?? "")
+      ]
+    },
+    page: { path: typeof window === "undefined" ? "/" : window.location.pathname }
+  };
+}
+function runtimeOf(firing) {
+  return firing && "integrations" in firing ? firing : null;
+}
+function createSalesBookingsClient(config, firing) {
+  const submittedForms = /* @__PURE__ */ new Set();
+  const staleAttempts = /* @__PURE__ */ new Set();
+  function handoff(input) {
+    const booking = getBookingIntegration(runtimeOf(firing)?.integrations());
+    if (!booking) return null;
+    return buildBookingHandoffUrl(booking.fallbackUrl, {
+      firstName: input.firstName,
+      lastName: input.lastName,
+      phone: input.phone,
+      email: input.email
+    });
+  }
+  function withHandoff(outcome, input) {
+    if (outcome.status === "failed" && !outcome.fallbackUrl) {
+      return { ...outcome, fallbackUrl: handoff(input) };
+    }
+    return outcome;
+  }
+  async function poll(id) {
+    let outcome = { status: "pending", id };
+    for (const delay of POLL_DELAYS_MS) {
+      await sleep(delay);
+      try {
+        const path = `/bookings/${encodeURIComponent(id)}`;
+        outcome = outcomeOf(await salesRequest(config, "GET", path));
+      } catch {
+        continue;
+      }
+      if (outcome.status !== "pending") return outcome;
+    }
+    return outcome;
+  }
+  async function rejected(error, input, attemptKey, runtime) {
+    if (!(error instanceof AranovaApiError)) {
+      return { status: "failed", id: null, fallbackUrl: handoff(input) };
+    }
+    if (error.code === BOOKING_ERROR_CODES.stale) {
+      if (staleAttempts.has(attemptKey)) {
+        return { status: "failed", id: null, fallbackUrl: handoff(input) };
+      }
+      staleAttempts.add(attemptKey);
+      await runtime?.revalidate();
+      return { status: "stale", message: error.message };
+    }
+    if (error.code === BOOKING_ERROR_CODES.rejected) {
+      const reasons = error.context?.reasons;
+      return {
+        status: "invalid",
+        message: error.message,
+        reasons: Array.isArray(reasons) ? reasons.map(String) : []
+      };
+    }
+    if (error.code === "validation_error") {
+      return { status: "invalid", message: INVALID_DETAILS, reasons: [] };
+    }
+    return { status: "failed", id: null, fallbackUrl: handoff(input) };
+  }
+  return {
+    async submit(input, { attemptKey, formSubmit }) {
+      registerCapability("booking_integration");
+      const runtime = runtimeOf(firing);
+      const booking = getBookingIntegration(runtime?.integrations());
+      if (!booking?.acceptsBookings || booking.configVersion === null) {
+        return { status: "failed", id: null, fallbackUrl: handoff(input) };
+      }
+      if (formSubmit && !submittedForms.has(attemptKey)) {
+        submittedForms.add(attemptKey);
+        const labels = new Map(booking.options.map((option) => [option.key, option.label]));
+        formSubmit.tracking.trackEvent(
+          "form_submit",
+          formSubmitPayload(input, formSubmit.formId, labels)
+        );
+      }
+      const body = {
+        idempotency_key: attemptKey,
+        // The tracking client's own visit, so the booking and its form_submit share one session.
+        session_id: formSubmit?.tracking.getSessionId() ?? peekSessionId() ?? `no-session-${attemptKey}`,
+        config_version: booking.configVersion,
+        start_date: input.startDate,
+        start_hour: input.startHour,
+        first_name: input.firstName.trim(),
+        last_name: input.lastName.trim(),
+        phone: input.phone,
+        email: input.email?.trim() || null,
+        vehicle: input.vehicle ?? null,
+        drop_off: input.dropOff ?? null,
+        services: input.services,
+        notes: input.notes?.trim() || null,
+        marketing_sms_consent: input.marketingSmsConsent === true,
+        page_path: typeof window === "undefined" ? null : window.location.pathname
+      };
+      let response;
+      try {
+        response = await salesRequest(config, "POST", "/bookings", body);
+      } catch (error) {
+        return rejected(error, input, attemptKey, runtime);
+      }
+      const outcome = outcomeOf(response);
+      return withHandoff(outcome.status === "pending" ? await poll(outcome.id) : outcome, input);
+    },
+    async status(id) {
+      return outcomeOf(
+        await salesRequest(
+          config,
+          "GET",
+          `/bookings/${encodeURIComponent(id)}`
+        )
+      );
+    }
+  };
+}
+
 // ../tracking-core/src/resources/sales/client.ts
 function fireRecordedConversions(firing, input, recorded, sale, currency) {
   if (!firing) return;
@@ -1644,7 +2031,8 @@ function createSalesClient(config) {
       async config() {
         return salesRequest(config, "GET", "/business/config");
       }
-    }
+    },
+    bookings: createSalesBookingsClient(config, config.firing)
   };
 }
 
@@ -1653,6 +2041,12 @@ import * as z3 from "zod/mini";
 
 // ../tracking-core/src/resources/sales/generated/zod.gen.ts
 import * as z2 from "zod/mini";
+var zAutoLeapSaleFacts = z2.object({
+  first_order: z2.boolean(),
+  fleet_customer: z2.boolean(),
+  invoice_code: z2.string(),
+  invoice_id: z2.string()
+});
 var zErrorCode = z2.enum([
   "missing_credentials",
   "invalid_api_key",
@@ -1680,6 +2074,9 @@ var zErrorCode = z2.enum([
   "booking_not_reschedulable",
   "manage_token_invalid",
   "google_error",
+  "booking_unavailable",
+  "booking_config_stale",
+  "booking_rejected",
   "calendar_not_owned",
   "calendar_is_sandbox",
   "sandbox_exists",
@@ -1721,6 +2118,7 @@ var zSaleServiceInputSchema = z2.strictObject({
   amount_cents: z2.int().check(z2.gte(0)),
   service: z2.string()
 });
+var zSaleSource = z2.enum(["api", "admin", "autoleap"]);
 var zSmsAutomationState = z2.enum([
   "needs_check",
   "failed",
@@ -1752,7 +2150,8 @@ var zSmsWithheldReason = z2.enum([
   "number_not_active",
   "a2p_registration_required",
   "alert_recipient_cannot_receive_sms",
-  "line_type_unresolved"
+  "line_type_unresolved",
+  "sale_source_sends_own_messages"
 ]);
 var zSaleSmsStatusSchema = z2.object({
   can_send_now: z2._default(z2.boolean(), false),
@@ -1861,6 +2260,8 @@ var zSaleEntitySchema = z2.object({
   sms_automation: z2.nullable(zSaleSmsStatusSchema),
   sms_consent: z2._default(z2.boolean(), false),
   sms_consent_granted_at: z2.nullable(z2.iso.datetime({ offset: true })),
+  source: zSaleSource,
+  source_facts: z2.nullable(zAutoLeapSaleFacts),
   updated_at: z2.iso.datetime({ offset: true }),
   writeback: z2.nullable(zSaleWritebackStatusSchema)
 });
@@ -1870,6 +2271,7 @@ var saleItemSchema = zSaleItemInputSchema;
 var saleServiceSchema = zSaleServiceInputSchema;
 var currencySchema = zSupportedCurrency;
 var SUPPORTED_CURRENCIES = currencySchema.options;
+var SALE_SOURCES = zSaleSource.options;
 var centsSchema = z3.int().check(z3.gte(0));
 var metadataSchema = z3.record(z3.string(), z3.unknown());
 var customerNameSchema = z3.string().check(z3.maxLength(200));
@@ -1958,9 +2360,17 @@ import {
   usePhoneConfig,
   usePhoneField
 } from "@aranova/tracking-react/client";
+import {
+  BookingHandoffLink,
+  useBookingHandoffUrl,
+  useBookingIntegration,
+  useBookingSlots,
+  useBookingSubmit
+} from "@aranova/tracking-react/client";
 export {
   AdPlatformTracking,
   AranovaApiError,
+  BookingHandoffLink,
   ConsentBanner,
   DEFAULT_DECLINE_TTL_DAYS,
   DEFAULT_PHONE_COUNTRY,
@@ -1968,9 +2378,12 @@ export {
   GoogleAdsTracking,
   NAMED_RANGES,
   PhoneField,
+  SALE_SOURCES,
   SUPPORTED_CURRENCIES,
   TRACKING_PARAM_KEYS,
   TRACKING_RANGES,
+  bookableSlots,
+  buildBookingHandoffUrl,
   captureTrackingParamsFromLocation,
   clearStashedUserData,
   createSalesClient,
@@ -1985,10 +2398,12 @@ export {
   formatPhone,
   formatPhoneAsTyped,
   fromMinor,
+  getBookingIntegration,
   getConsentChoice,
   getConsentState,
   getEventSemantics,
   getTrackingConfigRuntime,
+  newBookingAttemptKey,
   onConsentChange,
   optIn,
   optOut,
@@ -2003,9 +2418,14 @@ export {
   saleUpdateSchema,
   salesRequest,
   setConsentState,
+  shopToday,
   stashUserData,
   toE164,
   toMinor,
+  useBookingHandoffUrl,
+  useBookingIntegration,
+  useBookingSlots,
+  useBookingSubmit,
   useConsent,
   useConsentState,
   useCookiePreferences,