@aranova/tracking-react 1.2.5 → 1.4.0

package/dist/client.mjs

@@ -243,6 +243,8 @@ var TRACKING_CAPABILITIES = [
   "ad_tags_meta",
   "base_tracking",
   "blog_rendering",
+  "booking_handoff",
+  "booking_integration",
   "calendar_read",
   "calendar_write",
   "consent_controls",
@@ -645,15 +647,23 @@ 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 VISITOR_STORAGE_KEY = "aranova_tracking_visitor";
 var SESSION_STORAGE_KEY = "aranova_tracking_session";
 var SESSION_IDLE_MS = 30 * 60 * 1e3;
-function safeUuid() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
-    return crypto.randomUUID();
-  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}-${Math.random().toString(16).slice(2)}`;
-}
 function readLocalStorage(key) {
   try {
     return window.localStorage.getItem(key);
@@ -668,10 +678,10 @@ function writeLocalStorage(key, value) {
   }
 }
 function getVisitorId() {
-  if (typeof window === "undefined") return safeUuid();
+  if (typeof window === "undefined") return uuidV4();
   const existing = readLocalStorage(VISITOR_STORAGE_KEY);
   if (existing && existing.length > 0) return existing;
-  const fresh = safeUuid();
+  const fresh = uuidV4();
   writeLocalStorage(VISITOR_STORAGE_KEY, fresh);
   return fresh;
 }
@@ -683,7 +693,7 @@ function adoptVisitorId(visitorId) {
   return readLocalStorage(VISITOR_STORAGE_KEY) === visitorId;
 }
 function getOrRotateSessionId(now = Date.now()) {
-  if (typeof window === "undefined") return { id: safeUuid(), isNew: true };
+  if (typeof window === "undefined") return { id: uuidV4(), isNew: true };
   const raw = readLocalStorage(SESSION_STORAGE_KEY);
   if (raw) {
     try {
@@ -698,7 +708,7 @@ function getOrRotateSessionId(now = Date.now()) {
     } catch {
     }
   }
-  const fresh = { id: safeUuid(), last_event_at: now };
+  const fresh = { id: uuidV4(), last_event_at: now };
   writeLocalStorage(SESSION_STORAGE_KEY, JSON.stringify(fresh));
   return { id: fresh.id, isNew: true };
 }
@@ -918,6 +928,10 @@ function fireConversionWithConsent(input, options) {
 }
 
 // ../tracking-core/src/resources/conversion-config.ts
+var BOOKING_MODES = ["live", "test", "simulated"];
+function isBookingMode(value) {
+  return BOOKING_MODES.includes(value);
+}
 function isStringMap(value) {
   return typeof value === "object" && value !== null && Object.values(value).every((v) => typeof v === "string");
 }
@@ -931,6 +945,70 @@ 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) : [],
+        ...isBookingMode(b.mode) ? { mode: b.mode } : {}
+      }
+    }
+  };
+}
 function parseTrigger(value) {
   if (!value || typeof value !== "object") return null;
   const t = value;
@@ -990,7 +1068,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_";
@@ -1414,6 +1493,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 = {};
@@ -1583,6 +1669,106 @@ 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 })),
+    mode: booking.mode ?? "live"
+  };
+}
+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/resources/conversion-autofire.ts
 function currentPath() {
   return typeof window === "undefined" ? "" : window.location.pathname;
@@ -3402,6 +3588,9 @@ function attachPhoneClickCapture(client, config) {
   };
 }
 
+// ../tracking-core/src/resources/sales/bookings.ts
+var newBookingAttemptKey = uuidV4;
+
 // src/hooks.ts
 function useGclid() {
   const [gclid, setGclid] = useState(null);
@@ -3733,7 +3922,7 @@ function GoogleAdsTracking(props) {
 import { createContext as createContext2, useContext as useContext2, useEffect as useEffect5, useMemo as useMemo4 } from "react";
 
 // package.json
-var version = "1.2.5";
+var version = "1.4.0";
 
 // ../tracking-core/src/phone-react.tsx
 import {
@@ -4007,12 +4196,94 @@ function createTracking(options) {
     )
   };
 }
+
+// ../tracking-core/src/booking-react.tsx
+import { useCallback as useCallback3, useMemo as useMemo5, useRef, useState as useState4, useSyncExternalStore } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function serverSnapshot() {
+  return null;
+}
+function useBookingIntegration(trackingConfig) {
+  registerCapability("booking_handoff");
+  const subscribe = useCallback3(
+    (listener) => trackingConfig ? getTrackingConfigRuntime(trackingConfig).subscribe(listener) : () => {
+    },
+    [trackingConfig]
+  );
+  const integrations = useSyncExternalStore(
+    subscribe,
+    () => trackingConfig ? getTrackingConfigRuntime(trackingConfig).integrations() : null,
+    serverSnapshot
+  );
+  return useMemo5(() => getBookingIntegration(integrations), [integrations]);
+}
+function useBookingHandoffUrl(trackingConfig, { fallbackUrl, prefill } = {}) {
+  const booking = useBookingIntegration(trackingConfig);
+  const base = booking?.fallbackUrl ?? fallbackUrl;
+  return base ? buildBookingHandoffUrl(base, prefill) : null;
+}
+function BookingHandoffLink({
+  trackingConfig,
+  fallbackUrl,
+  prefill,
+  children,
+  target = "_blank",
+  rel = "noopener noreferrer",
+  ...anchorProps
+}) {
+  const href = useBookingHandoffUrl(trackingConfig, { fallbackUrl, prefill });
+  if (!href) return null;
+  return /* @__PURE__ */ jsx4("a", { ...anchorProps, href, target, rel, children });
+}
+function useBookingSlots(trackingConfig) {
+  const booking = useBookingIntegration(trackingConfig);
+  if (!booking?.acceptsBookings || !booking.rules) return [];
+  return bookableSlots(booking.rules, { timeZone: booking.timezone });
+}
+function useBookingSubmit(bookings, options = {}) {
+  registerCapability("booking_integration");
+  const [outcome, setOutcome] = useState4(null);
+  const [submitting, setSubmitting] = useState4(false);
+  const attemptKey = useRef(null);
+  const inFlight = useRef(null);
+  const { formSubmit, simulate } = options;
+  const submit = useCallback3(
+    (input) => {
+      if (inFlight.current) return inFlight.current;
+      attemptKey.current ?? (attemptKey.current = newBookingAttemptKey());
+      setSubmitting(true);
+      const run = bookings.submit(input, { attemptKey: attemptKey.current, formSubmit, simulate }).then((result) => {
+        const unrecorded = result.status === "invalid" || result.status === "stale" || result.status === "failed" && result.id === null;
+        if (!unrecorded) attemptKey.current = null;
+        setOutcome(result);
+        return result;
+      }).finally(() => {
+        inFlight.current = null;
+        setSubmitting(false);
+      });
+      inFlight.current = run;
+      return run;
+    },
+    [bookings, formSubmit, simulate]
+  );
+  const reset = useCallback3(() => {
+    attemptKey.current = null;
+    setOutcome(null);
+  }, []);
+  const status = submitting ? "submitting" : outcome?.status ?? "idle";
+  return { status, outcome, submit, reset };
+}
 export {
   AdPlatformTracking,
+  BookingHandoffLink,
   ConsentBanner,
   GoogleAdsTracking,
   PhoneField,
   createTracking,
+  useBookingHandoffUrl,
+  useBookingIntegration,
+  useBookingSlots,
+  useBookingSubmit,
   useConsent,
   useConsentState,
   useCookiePreferences,