@aranova/tracking-next 0.20.1 → 0.21.0

package/dist/index.mjs

@@ -946,6 +946,21 @@ function automaticThresholdMet(goal, eventType, metadata) {
   }
 }
 
+// ../tracking-core/src/resources/intl/date.ts
+function formatDateInTz(iso, timeZone, opts, locale) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return iso;
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "short",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    ...opts,
+    timeZone
+  }).format(date);
+}
+
 // ../tracking-core/src/resources/sales/money.ts
 var MINOR_UNIT_EXPONENT = {
   USD: 2,
@@ -965,19 +980,6 @@ function formatMoney(cents, currency, locale) {
     fromMinor(cents, currency)
   );
 }
-function formatDateInTz(iso, timeZone, opts, locale) {
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return iso;
-  return new Intl.DateTimeFormat(locale, {
-    year: "numeric",
-    month: "short",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    ...opts,
-    timeZone
-  }).format(date);
-}
 
 // ../tracking-core/src/resources/tracking-config-runtime.ts
 var CACHE_PREFIX2 = "_aranova_cfg_runtime_";
@@ -2680,7 +2682,7 @@ function attachPhoneClickCapture(client, config) {
   };
 }
 
-// ../tracking-core/src/resources/sales/errors.ts
+// ../tracking-core/src/resources/http/errors.ts
 var AranovaApiError = class extends Error {
   constructor(message, options) {
     super(message);
@@ -2691,7 +2693,7 @@ var AranovaApiError = class extends Error {
   }
 };
 
-// ../tracking-core/src/resources/sales/transport.ts
+// ../tracking-core/src/resources/http/request.ts
 function identityHeaders(config) {
   const headers = { [API_KEY_HEADER]: config.apiKey };
   if (config.sdkVersion) headers[SDK_VERSION_HEADER] = config.sdkVersion;
@@ -2703,8 +2705,8 @@ function identityHeaders(config) {
 function joinUrl(endpoint, path) {
   return `${endpoint.replace(/\/$/, "")}${path}`;
 }
-async function salesRequest(config, method, path, body) {
-  const headers = identityHeaders(config);
+async function apiRequest(config, method, path, body, extraHeaders) {
+  const headers = { ...identityHeaders(config), ...extraHeaders };
   if (body !== void 0) headers["Content-Type"] = "application/json";
   const response = await fetch(joinUrl(config.endpoint, path), {
     method,
@@ -2733,6 +2735,9 @@ async function salesRequest(config, method, path, body) {
   return await response.json();
 }
 
+// ../tracking-core/src/resources/sales/transport.ts
+var salesRequest = apiRequest;
+
 // ../tracking-core/src/resources/sales/client.ts
 function fireRecordedConversions(firing, input, recorded, sale, currency) {
   if (!firing) return;
@@ -3378,7 +3383,7 @@ function GoogleAdsTracking(props) {
 import { usePathname, useSearchParams } from "next/navigation";
 
 // package.json
-var version = "0.20.1";
+var version = "0.21.0";
 
 // src/factory.tsx
 import {
@@ -3674,42 +3679,488 @@ function createTracking(options) {
   }
   return { TrackingProvider, useTracking };
 }
+
+// ../tracking-core/src/resources/calendar/transport.ts
+async function calendarRequest(config, method, path, body) {
+  return apiRequest(config, method, `/calendar${path}`, body);
+}
+
+// ../tracking-core/src/resources/calendar/time.ts
+function resolveBrowserTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function partsInTz(date, timeZone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const out = {};
+  for (const part of formatter.formatToParts(date)) {
+    if (part.type !== "literal") out[part.type] = Number(part.value);
+  }
+  if (out.hour === 24) out.hour = 0;
+  return out;
+}
+function offsetMinutesAt(date, timeZone) {
+  const p = partsInTz(date, timeZone);
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return (asUtc - Math.floor(date.getTime() / 1e3) * 1e3) / 6e4;
+}
+function instantFromWallClock(timeZone, year, month, day, hour = 0, minute = 0) {
+  const naive = Date.UTC(year, month - 1, day, hour, minute);
+  const firstGuess = new Date(naive - offsetMinutesAt(new Date(naive), timeZone) * 6e4);
+  const corrected = naive - offsetMinutesAt(firstGuess, timeZone) * 6e4;
+  return new Date(corrected);
+}
+function localDateKey(iso, timeZone) {
+  const p = partsInTz(new Date(iso), timeZone);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${p.year}-${pad(p.month)}-${pad(p.day)}`;
+}
+function startOfDayInTz(dateKey, timeZone) {
+  const [year, month, day] = dateKey.split("-").map(Number);
+  return instantFromWallClock(timeZone, year, month, day, 0, 0);
+}
+function endOfDayInTz(dateKey, timeZone) {
+  const start = startOfDayInTz(dateKey, timeZone);
+  const p = partsInTz(start, timeZone);
+  return instantFromWallClock(timeZone, p.year, p.month, p.day + 1, 0, 0);
+}
+function durationMinutes(startIso, endIso) {
+  return Math.round((new Date(endIso).getTime() - new Date(startIso).getTime()) / 6e4);
+}
+function formatSlotRange(startIso, endIso, timeZone, locale) {
+  const opts = { hour: "2-digit", minute: "2-digit", timeZone };
+  const fmt = new Intl.DateTimeFormat(locale, opts);
+  return `${fmt.format(new Date(startIso))} \u2013 ${fmt.format(new Date(endIso))}`;
+}
+
+// ../tracking-core/src/resources/calendar/read-client.ts
+function withBusiness(config, path) {
+  if (!config.businessId) return path;
+  const separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}business_id=${encodeURIComponent(config.businessId)}`;
+}
+function createCalendarReadClient(config) {
+  return {
+    async listCalendars() {
+      return calendarRequest(config, "GET", withBusiness(config, "/calendars"));
+    },
+    async busy(calendarKey, query) {
+      const params = new URLSearchParams({
+        since: query.since,
+        until: query.until
+      });
+      const timeZone = query.timeZone ?? config.defaultTimeZone ?? resolveBrowserTimeZone();
+      params.set("time_zone", timeZone);
+      return calendarRequest(
+        config,
+        "GET",
+        withBusiness(config, `/${encodeURIComponent(calendarKey)}/busy?${params.toString()}`)
+      );
+    }
+  };
+}
+function isCalendarError(error, code) {
+  if (!(error instanceof AranovaApiError)) return false;
+  return code === void 0 || error.code === code;
+}
+
+// ../tracking-core/src/resources/calendar/schema.ts
+import { z as z13 } from "zod";
+var CALENDAR_METADATA_SCHEMA_VERSION = 1;
+var MAX_ATTENDEES = 20;
+var MAX_REMINDER_OVERRIDES = 5;
+var MAX_REMINDER_MINUTES = 40320;
+var MAX_BOOKING_MINUTES = 1440;
+var BOOKING_SOURCES = ["website", "phone", "walk_in", "import", "operator"];
+var BOOKING_STATUSES = ["pending", "confirmed", "cancelled", "no_show"];
+var GOOGLE_SYNC_STATES = ["queued", "synced", "uncertain", "failed", "drifted"];
+var CALENDAR_SYNC_STATUSES = [
+  "pending_invite",
+  "awaiting_calendar_selection",
+  "connected",
+  "needs_reconnect",
+  "revoked",
+  "disabled"
+];
+var CALENDAR_ERROR_CODES = [
+  "slot_unavailable",
+  "calendar_not_connected",
+  "calendar_disconnected",
+  "booking_not_found",
+  "outside_booking_window",
+  "rate_limited",
+  "google_error"
+];
+var isoInstant = z13.string().datetime({ offset: true });
+function isKnownTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat(void 0, { timeZone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ianaTz = z13.string().min(1).max(64).regex(/^[A-Za-z0-9_+\-/]+$/).refine(isKnownTimeZone, { message: "unknown IANA time zone" });
+var bookingAttendeeSchema = z13.object({
+  email: z13.string().max(320).email(),
+  display_name: z13.string().max(200).nullable().optional(),
+  optional: z13.boolean().default(false)
+}).strict();
+var bookingReminderSchema = z13.object({
+  method: z13.enum(["email", "popup"]),
+  minutes_before: z13.number().int().min(0).max(MAX_REMINDER_MINUTES)
+}).strict();
+var bookingRemindersSchema = z13.object({
+  use_calendar_defaults: z13.boolean().default(true),
+  overrides: z13.array(bookingReminderSchema).max(MAX_REMINDER_OVERRIDES).default([])
+}).strict();
+var bookingLocationSchema = z13.union([
+  z13.object({ kind: z13.literal("google_meet") }).strict(),
+  z13.object({ kind: z13.literal("physical"), address: z13.string().max(1024) }).strict(),
+  z13.object({ kind: z13.literal("phone"), phone: z13.string().max(64) }).strict(),
+  z13.object({ kind: z13.literal("custom"), text: z13.string().max(1024) }).strict()
+]);
+var bookingLocationNullableSchema = z13.union([...bookingLocationSchema.options, z13.null()]);
+var bookingCustomerSchema = z13.object({
+  // Required: Google needs an address to send the invite that confirms the
+  // booking, and that invite is the whole confirmation mechanism.
+  email: z13.string().max(320).email(),
+  name: z13.string().max(200).nullable().optional(),
+  phone: z13.string().max(64).nullable().optional(),
+  sms_consent: z13.boolean().default(false)
+}).strict();
+var jsonScalar = z13.union([z13.string(), z13.number(), z13.boolean(), z13.null()]);
+var bookingMetadataSchema = z13.object({
+  schema_version: z13.number().int().default(CALENDAR_METADATA_SCHEMA_VERSION),
+  source: z13.enum(BOOKING_SOURCES).nullable().optional(),
+  service: z13.string().max(64).nullable().optional(),
+  visitor_id: z13.string().max(64).nullable().optional(),
+  session_id: z13.string().max(64).nullable().optional(),
+  gclid: z13.string().max(256).nullable().optional(),
+  fbclid: z13.string().max(256).nullable().optional(),
+  utm_source: z13.string().max(128).nullable().optional(),
+  utm_medium: z13.string().max(128).nullable().optional(),
+  utm_campaign: z13.string().max(128).nullable().optional(),
+  utm_term: z13.string().max(128).nullable().optional(),
+  utm_content: z13.string().max(128).nullable().optional(),
+  landing_page: z13.string().max(2048).nullable().optional(),
+  referrer: z13.string().max(2048).nullable().optional(),
+  notes: z13.string().max(2e3).nullable().optional(),
+  custom: z13.record(jsonScalar).nullable().optional()
+}).strict();
+function refineEndXor(value, ctx) {
+  const hasEnd = value.end_at !== void 0 && value.end_at !== null;
+  const hasDuration = value.duration_minutes !== void 0 && value.duration_minutes !== null;
+  if (hasEnd === hasDuration) {
+    ctx.addIssue({
+      code: z13.ZodIssueCode.custom,
+      message: "provide exactly one of end_at or duration_minutes",
+      path: ["end_at"]
+    });
+    return;
+  }
+  if (hasEnd && new Date(value.end_at) <= new Date(value.start_at)) {
+    ctx.addIssue({
+      code: z13.ZodIssueCode.custom,
+      message: "end_at must be after start_at",
+      path: ["end_at"]
+    });
+  }
+}
+var bookingCreateSchema = z13.object({
+  calendar_key: z13.string().min(1).max(64),
+  // Free-form: appointment types are the client site's own vocabulary, not
+  // configuration the dashboard holds.
+  appointment_type: z13.string().max(64).nullable().optional(),
+  start_at: isoInstant,
+  end_at: isoInstant.nullable().optional(),
+  duration_minutes: z13.number().int().positive().max(MAX_BOOKING_MINUTES).nullable().optional(),
+  /** The booker's zone — distinct from the business's and the calendar's. */
+  time_zone: ianaTz,
+  title: z13.string().max(300).nullable().optional(),
+  description: z13.string().max(8e3).nullable().optional(),
+  location: bookingLocationNullableSchema.optional(),
+  customer: bookingCustomerSchema,
+  attendees: z13.array(bookingAttendeeSchema).max(MAX_ATTENDEES).default([]),
+  send_invites: z13.boolean().default(true),
+  reminders: bookingRemindersSchema.nullable().optional(),
+  metadata: bookingMetadataSchema.nullable().optional(),
+  idempotency_key: z13.string().max(128).nullable().optional(),
+  buffer_before_minutes: z13.number().int().min(0).max(MAX_BOOKING_MINUTES).default(0),
+  buffer_after_minutes: z13.number().int().min(0).max(MAX_BOOKING_MINUTES).default(0)
+}).strict().superRefine(refineEndXor);
+var bookingRescheduleSchema = z13.object({
+  start_at: isoInstant,
+  end_at: isoInstant.nullable().optional(),
+  duration_minutes: z13.number().int().positive().max(MAX_BOOKING_MINUTES).nullable().optional(),
+  time_zone: ianaTz,
+  notify_attendees: z13.boolean().default(true),
+  reason: z13.string().max(500).nullable().optional()
+}).strict().superRefine(refineEndXor);
+var bookingCancelSchema = z13.object({
+  reason: z13.string().max(500).nullable().optional(),
+  notify_attendees: z13.boolean().default(true)
+}).strict();
+
+// ../tracking-core/src/resources/calendar/slots.ts
+function parseHhMm(value) {
+  const [hour, minute] = value.split(":").map(Number);
+  return [hour || 0, minute || 0];
+}
+function dateKeyOf(date, timeZone) {
+  const fmt = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  return fmt.format(date);
+}
+function weekdayFromDateKey(dateKey) {
+  const [year, month, day] = dateKey.split("-").map(Number);
+  return new Date(Date.UTC(year, month - 1, day, 12)).getUTCDay();
+}
+function startOfLocalDay(at, timeZone) {
+  const [year, month, day] = dateKeyOf(at, timeZone).split("-").map(Number);
+  return instantFromWallClock(timeZone, year, month, day, 12, 0);
+}
+function overlaps(aStart, aEnd, bStart, bEnd) {
+  return aStart < bEnd && aEnd > bStart;
+}
+function computeSlots(options) {
+  const {
+    busy,
+    openingHours,
+    timeZone,
+    durationMinutes: durationMinutes2,
+    granularityMinutes = 15,
+    minNoticeMinutes = 0,
+    bufferBeforeMinutes = 0,
+    bufferAfterMinutes = 0,
+    windowDays = 30,
+    now = /* @__PURE__ */ new Date()
+  } = options;
+  const earliest = now.getTime() + minNoticeMinutes * 6e4;
+  const busyRanges = busy.map((interval) => [
+    new Date(interval.start_at).getTime(),
+    new Date(interval.end_at).getTime()
+  ]);
+  const slots = [];
+  let cursor = startOfLocalDay(now, timeZone);
+  for (let dayOffset = 0; dayOffset < windowDays; dayOffset += 1) {
+    const dateKey = dateKeyOf(cursor, timeZone);
+    const [year, month, day] = dateKey.split("-").map(Number);
+    cursor = instantFromWallClock(timeZone, year, month, day + 1, 12, 0);
+    if (openingHours.closedDates?.includes(dateKey)) continue;
+    const intervals = openingHours.overrides?.[dateKey] ?? openingHours.weekly[weekdayFromDateKey(dateKey)] ?? [];
+    for (const interval of intervals) {
+      const [openHour, openMinute] = parseHhMm(interval.start);
+      const [closeHour, closeMinute] = parseHhMm(interval.end);
+      const opensAt = instantFromWallClock(timeZone, year, month, day, openHour, openMinute);
+      const closesAt = instantFromWallClock(timeZone, year, month, day, closeHour, closeMinute);
+      for (let start = opensAt.getTime(); start + durationMinutes2 * 6e4 <= closesAt.getTime(); start += granularityMinutes * 6e4) {
+        const end = start + durationMinutes2 * 6e4;
+        if (start < earliest) continue;
+        const blockedStart = start - bufferBeforeMinutes * 6e4;
+        const blockedEnd = end + bufferAfterMinutes * 6e4;
+        const taken = busyRanges.some(
+          ([busyStart, busyEnd]) => overlaps(blockedStart, blockedEnd, busyStart, busyEnd)
+        );
+        if (taken) continue;
+        slots.push({
+          start_at: new Date(start).toISOString(),
+          end_at: new Date(end).toISOString()
+        });
+      }
+    }
+  }
+  slots.sort((a, b) => a.start_at.localeCompare(b.start_at));
+  return { slots, nextAvailableAt: slots[0]?.start_at ?? null };
+}
+function groupSlotsByDay(slots, timeZone) {
+  const byDay = /* @__PURE__ */ new Map();
+  for (const slot of slots) {
+    const key = dateKeyOf(new Date(slot.start_at), timeZone);
+    const bucket = byDay.get(key);
+    if (bucket) bucket.push(slot);
+    else byDay.set(key, [slot]);
+  }
+  return [...byDay.entries()].map(([date, daySlots]) => ({ date, slots: daySlots })).sort((a, b) => a.date.localeCompare(b.date));
+}
+
+// ../tracking-core/src/calendar-react.tsx
+import { createContext as createContext3, useCallback as useCallback4, useContext as useContext3, useEffect as useEffect5, useMemo as useMemo3, useState as useState4 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var _calendarClientContext;
+function calendarClientContext() {
+  return _calendarClientContext ?? (_calendarClientContext = createContext3(null));
+}
+function CalendarClientProvider({
+  value,
+  children
+}) {
+  const Ctx = calendarClientContext();
+  return /* @__PURE__ */ jsx6(Ctx.Provider, { value, children });
+}
+function useCalendarClient() {
+  const client = useContext3(calendarClientContext());
+  if (!client) {
+    throw new Error(
+      "useCalendarClient requires <CalendarClientProvider>. Wire it via createTracking({ calendar })."
+    );
+  }
+  return client;
+}
+function useCalendarBusy(calendarKey, window2) {
+  const client = useCalendarClient();
+  const [busy, setBusy] = useState4([]);
+  const [timeZone, setTimeZone] = useState4(resolveBrowserTimeZone());
+  const [isLoading, setIsLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const [nonce, setNonce] = useState4(0);
+  useEffect5(() => {
+    const controller = new AbortController();
+    setIsLoading(true);
+    client.busy(calendarKey, { since: window2.since, until: window2.until }).then((response) => {
+      if (controller.signal.aborted) return;
+      setBusy(response.busy);
+      setTimeZone(response.time_zone);
+      setError(null);
+    }).catch((cause) => {
+      if (controller.signal.aborted) return;
+      setError(cause instanceof Error ? cause : new Error(String(cause)));
+    }).finally(() => {
+      if (!controller.signal.aborted) setIsLoading(false);
+    });
+    return () => controller.abort();
+  }, [client, calendarKey, window2.since, window2.until, nonce]);
+  const refetch = useCallback4(() => setNonce((value) => value + 1), []);
+  return { busy, timeZone, isLoading, error, refetch };
+}
+function useSlots(busy, timeZone, options) {
+  const zone = options.timeZone ?? timeZone;
+  return useMemo3(() => {
+    const { slots, nextAvailableAt } = computeSlots({ ...options, busy, timeZone: zone });
+    return { slots, days: groupSlotsByDay(slots, zone), nextAvailableAt };
+  }, [busy, zone, options]);
+}
+function useBookingForm(options = {}) {
+  const endpoint = options.endpoint ?? "/api/aranova/calendar/bookings";
+  const [status, setStatus] = useState4("idle");
+  const [error, setError] = useState4(null);
+  const [booking, setBooking] = useState4(null);
+  const submit = useCallback4(
+    async (input) => {
+      setStatus("submitting");
+      setError(null);
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        const body = await response.json().catch(() => null);
+        if (!response.ok) {
+          const detail = body && typeof body === "object" && typeof body.detail === "string" ? body.detail : "Booking failed";
+          throw new Error(detail);
+        }
+        setBooking(body);
+        setStatus("confirmed");
+        options.onConfirmed?.(body);
+      } catch (cause) {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setStatus("failed");
+      }
+    },
+    [endpoint, options]
+  );
+  const reset = useCallback4(() => {
+    setStatus("idle");
+    setError(null);
+    setBooking(null);
+  }, []);
+  return { status, error, booking, submit, reset };
+}
 export {
   AdPlatformTracking,
   AranovaApiError,
+  BOOKING_SOURCES,
+  BOOKING_STATUSES,
+  CALENDAR_ERROR_CODES,
+  CALENDAR_METADATA_SCHEMA_VERSION,
+  CALENDAR_SYNC_STATUSES,
+  CalendarClientProvider,
   ConsentBanner,
   DEFAULT_DECLINE_TTL_DAYS,
   DEFAULT_PHONE_COUNTRY,
   EVENT_SEMANTICS,
+  GOOGLE_SYNC_STATES,
   GoogleAdsTracking,
+  MAX_ATTENDEES,
+  MAX_BOOKING_MINUTES,
+  MAX_REMINDER_MINUTES,
+  MAX_REMINDER_OVERRIDES,
   NAMED_RANGES,
   PhoneField,
   SUPPORTED_CURRENCIES,
   TRACKING_PARAM_KEYS,
   TRACKING_RANGES,
+  bookingAttendeeSchema,
+  bookingCancelSchema,
+  bookingCreateSchema,
+  bookingCustomerSchema,
+  bookingLocationNullableSchema,
+  bookingLocationSchema,
+  bookingMetadataSchema,
+  bookingReminderSchema,
+  bookingRemindersSchema,
+  bookingRescheduleSchema,
   captureTrackingParamsFromLocation,
   clearStashedUserData,
+  computeSlots,
+  createCalendarReadClient,
   createSalesClient,
   createTracking,
   createTrackingClientContext,
   createTrackingEventCreatePayload,
   createTrackingSessionUpsertPayload,
+  durationMinutes,
+  endOfDayInTz,
   fetchServices,
   formatDateInTz,
   formatMoney,
   formatPhone,
   formatPhoneAsTyped,
+  formatSlotRange,
   fromMinor,
   getConsentChoice,
   getConsentState,
   getEventSemantics,
   getTrackingConfigRuntime,
+  groupSlotsByDay,
+  instantFromWallClock,
+  isCalendarError,
+  localDateKey,
+  offsetMinutesAt,
   onConsentChange,
   optIn,
   optOut,
   parsePhone,
   phoneField,
   resetConsent,
+  resolveBrowserTimeZone,
   resolveConversionConfig,
   saleCreateSchema,
   saleItemSchema,
@@ -3717,15 +4168,20 @@ export {
   saleUpdateSchema,
   salesRequest,
   setConsentState,
+  startOfDayInTz,
   stashUserData,
   toE164,
   toMinor,
+  useBookingForm,
+  useCalendarBusy,
+  useCalendarClient,
   useConsent,
   useConsentState,
   useCookiePreferences,
   useGclid,
   usePhoneConfig,
   usePhoneField,
+  useSlots,
   useTrackingParams
 };
 //# sourceMappingURL=index.mjs.map