@aranova/tracking-next 0.20.2 → 0.21.0

package/dist/calendar.js

@@ -0,0 +1,517 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/calendar.ts
+var calendar_exports = {};
+__export(calendar_exports, {
+  AranovaApiError: () => AranovaApiError,
+  BOOKING_SOURCES: () => BOOKING_SOURCES,
+  BOOKING_STATUSES: () => BOOKING_STATUSES,
+  CALENDAR_ERROR_CODES: () => CALENDAR_ERROR_CODES,
+  CALENDAR_METADATA_SCHEMA_VERSION: () => CALENDAR_METADATA_SCHEMA_VERSION,
+  CALENDAR_SYNC_STATUSES: () => CALENDAR_SYNC_STATUSES,
+  GOOGLE_SYNC_STATES: () => GOOGLE_SYNC_STATES,
+  MAX_ATTENDEES: () => MAX_ATTENDEES,
+  MAX_BOOKING_MINUTES: () => MAX_BOOKING_MINUTES,
+  MAX_REMINDER_MINUTES: () => MAX_REMINDER_MINUTES,
+  MAX_REMINDER_OVERRIDES: () => MAX_REMINDER_OVERRIDES,
+  bookingAttendeeSchema: () => bookingAttendeeSchema,
+  bookingCancelSchema: () => bookingCancelSchema,
+  bookingCreateSchema: () => bookingCreateSchema,
+  bookingCustomerSchema: () => bookingCustomerSchema,
+  bookingLocationNullableSchema: () => bookingLocationNullableSchema,
+  bookingLocationSchema: () => bookingLocationSchema,
+  bookingMetadataSchema: () => bookingMetadataSchema,
+  bookingReminderSchema: () => bookingReminderSchema,
+  bookingRemindersSchema: () => bookingRemindersSchema,
+  bookingRescheduleSchema: () => bookingRescheduleSchema,
+  computeSlots: () => computeSlots,
+  createCalendarReadClient: () => createCalendarReadClient,
+  durationMinutes: () => durationMinutes,
+  endOfDayInTz: () => endOfDayInTz,
+  formatDateInTz: () => formatDateInTz,
+  formatSlotRange: () => formatSlotRange,
+  groupSlotsByDay: () => groupSlotsByDay,
+  instantFromWallClock: () => instantFromWallClock,
+  isCalendarError: () => isCalendarError,
+  localDateKey: () => localDateKey,
+  offsetMinutesAt: () => offsetMinutesAt,
+  resolveBrowserTimeZone: () => resolveBrowserTimeZone,
+  startOfDayInTz: () => startOfDayInTz
+});
+module.exports = __toCommonJS(calendar_exports);
+
+// ../tracking-core/src/resources/http/errors.ts
+var AranovaApiError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "AranovaApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.requestId = options.requestId;
+  }
+};
+
+// ../tracking-core/src/phone.ts
+var import_libphonenumber_js = require("libphonenumber-js");
+
+// ../tracking-core/src/events/page-view.ts
+var import_zod = require("zod");
+var pageViewMetadataSchema = import_zod.z.object({
+  page: import_zod.z.object({
+    title: import_zod.z.string().nullable(),
+    path: import_zod.z.string(),
+    search: import_zod.z.string(),
+    hash: import_zod.z.string()
+  }).strict(),
+  referrer: import_zod.z.string().nullable(),
+  // `.nullable().optional()` — absent (undefined) OR explicit null OR a
+  // real viewport object. Mirrors Pydantic's `_Viewport | None = None`
+  // on the backend side so the drift test stays clean.
+  viewport: import_zod.z.object({
+    w: import_zod.z.number(),
+    h: import_zod.z.number()
+  }).strict().nullable().optional()
+}).strict();
+var pageViewConfigSchema = import_zod.z.object({}).strict();
+
+// ../tracking-core/src/session.ts
+var SESSION_IDLE_MS = 30 * 60 * 1e3;
+
+// ../tracking-core/src/ingest.ts
+var API_KEY_HEADER = "X-Aranova-Api-Key";
+var SDK_VERSION_HEADER = "X-Aranova-Sdk-Version";
+var SDK_PACKAGE_HEADER = "X-Aranova-Sdk-Package";
+var SDK_SURFACE_HEADER = "X-Aranova-Sdk-Surface";
+var SDK_ENVIRONMENT_HEADER = "X-Aranova-Sdk-Environment";
+
+// ../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;
+  if (config.packageName) headers[SDK_PACKAGE_HEADER] = config.packageName;
+  if (config.surface) headers[SDK_SURFACE_HEADER] = config.surface;
+  if (config.environment) headers[SDK_ENVIRONMENT_HEADER] = config.environment;
+  return headers;
+}
+function joinUrl(endpoint, path) {
+  return `${endpoint.replace(/\/$/, "")}${path}`;
+}
+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,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  if (!response.ok) {
+    let detail;
+    let code;
+    try {
+      const parsed = await response.json();
+      if (parsed && typeof parsed === "object") {
+        const record = parsed;
+        if (typeof record.detail === "string") detail = record.detail;
+        if (typeof record.code === "string") code = record.code;
+      }
+    } catch {
+    }
+    throw new AranovaApiError(detail ?? response.statusText ?? "Request failed", {
+      status: response.status,
+      code,
+      requestId: response.headers.get("x-request-id") ?? void 0
+    });
+  }
+  if (response.status === 204) return void 0;
+  return await response.json();
+}
+
+// ../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/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/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
+var import_zod2 = require("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 = import_zod2.z.string().datetime({ offset: true });
+function isKnownTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat(void 0, { timeZone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ianaTz = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9_+\-/]+$/).refine(isKnownTimeZone, { message: "unknown IANA time zone" });
+var bookingAttendeeSchema = import_zod2.z.object({
+  email: import_zod2.z.string().max(320).email(),
+  display_name: import_zod2.z.string().max(200).nullable().optional(),
+  optional: import_zod2.z.boolean().default(false)
+}).strict();
+var bookingReminderSchema = import_zod2.z.object({
+  method: import_zod2.z.enum(["email", "popup"]),
+  minutes_before: import_zod2.z.number().int().min(0).max(MAX_REMINDER_MINUTES)
+}).strict();
+var bookingRemindersSchema = import_zod2.z.object({
+  use_calendar_defaults: import_zod2.z.boolean().default(true),
+  overrides: import_zod2.z.array(bookingReminderSchema).max(MAX_REMINDER_OVERRIDES).default([])
+}).strict();
+var bookingLocationSchema = import_zod2.z.union([
+  import_zod2.z.object({ kind: import_zod2.z.literal("google_meet") }).strict(),
+  import_zod2.z.object({ kind: import_zod2.z.literal("physical"), address: import_zod2.z.string().max(1024) }).strict(),
+  import_zod2.z.object({ kind: import_zod2.z.literal("phone"), phone: import_zod2.z.string().max(64) }).strict(),
+  import_zod2.z.object({ kind: import_zod2.z.literal("custom"), text: import_zod2.z.string().max(1024) }).strict()
+]);
+var bookingLocationNullableSchema = import_zod2.z.union([...bookingLocationSchema.options, import_zod2.z.null()]);
+var bookingCustomerSchema = import_zod2.z.object({
+  // Required: Google needs an address to send the invite that confirms the
+  // booking, and that invite is the whole confirmation mechanism.
+  email: import_zod2.z.string().max(320).email(),
+  name: import_zod2.z.string().max(200).nullable().optional(),
+  phone: import_zod2.z.string().max(64).nullable().optional(),
+  sms_consent: import_zod2.z.boolean().default(false)
+}).strict();
+var jsonScalar = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean(), import_zod2.z.null()]);
+var bookingMetadataSchema = import_zod2.z.object({
+  schema_version: import_zod2.z.number().int().default(CALENDAR_METADATA_SCHEMA_VERSION),
+  source: import_zod2.z.enum(BOOKING_SOURCES).nullable().optional(),
+  service: import_zod2.z.string().max(64).nullable().optional(),
+  visitor_id: import_zod2.z.string().max(64).nullable().optional(),
+  session_id: import_zod2.z.string().max(64).nullable().optional(),
+  gclid: import_zod2.z.string().max(256).nullable().optional(),
+  fbclid: import_zod2.z.string().max(256).nullable().optional(),
+  utm_source: import_zod2.z.string().max(128).nullable().optional(),
+  utm_medium: import_zod2.z.string().max(128).nullable().optional(),
+  utm_campaign: import_zod2.z.string().max(128).nullable().optional(),
+  utm_term: import_zod2.z.string().max(128).nullable().optional(),
+  utm_content: import_zod2.z.string().max(128).nullable().optional(),
+  landing_page: import_zod2.z.string().max(2048).nullable().optional(),
+  referrer: import_zod2.z.string().max(2048).nullable().optional(),
+  notes: import_zod2.z.string().max(2e3).nullable().optional(),
+  custom: import_zod2.z.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: import_zod2.z.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: import_zod2.z.ZodIssueCode.custom,
+      message: "end_at must be after start_at",
+      path: ["end_at"]
+    });
+  }
+}
+var bookingCreateSchema = import_zod2.z.object({
+  calendar_key: import_zod2.z.string().min(1).max(64),
+  // Free-form: appointment types are the client site's own vocabulary, not
+  // configuration the dashboard holds.
+  appointment_type: import_zod2.z.string().max(64).nullable().optional(),
+  start_at: isoInstant,
+  end_at: isoInstant.nullable().optional(),
+  duration_minutes: import_zod2.z.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: import_zod2.z.string().max(300).nullable().optional(),
+  description: import_zod2.z.string().max(8e3).nullable().optional(),
+  location: bookingLocationNullableSchema.optional(),
+  customer: bookingCustomerSchema,
+  attendees: import_zod2.z.array(bookingAttendeeSchema).max(MAX_ATTENDEES).default([]),
+  send_invites: import_zod2.z.boolean().default(true),
+  reminders: bookingRemindersSchema.nullable().optional(),
+  metadata: bookingMetadataSchema.nullable().optional(),
+  idempotency_key: import_zod2.z.string().max(128).nullable().optional(),
+  buffer_before_minutes: import_zod2.z.number().int().min(0).max(MAX_BOOKING_MINUTES).default(0),
+  buffer_after_minutes: import_zod2.z.number().int().min(0).max(MAX_BOOKING_MINUTES).default(0)
+}).strict().superRefine(refineEndXor);
+var bookingRescheduleSchema = import_zod2.z.object({
+  start_at: isoInstant,
+  end_at: isoInstant.nullable().optional(),
+  duration_minutes: import_zod2.z.number().int().positive().max(MAX_BOOKING_MINUTES).nullable().optional(),
+  time_zone: ianaTz,
+  notify_attendees: import_zod2.z.boolean().default(true),
+  reason: import_zod2.z.string().max(500).nullable().optional()
+}).strict().superRefine(refineEndXor);
+var bookingCancelSchema = import_zod2.z.object({
+  reason: import_zod2.z.string().max(500).nullable().optional(),
+  notify_attendees: import_zod2.z.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));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AranovaApiError,
+  BOOKING_SOURCES,
+  BOOKING_STATUSES,
+  CALENDAR_ERROR_CODES,
+  CALENDAR_METADATA_SCHEMA_VERSION,
+  CALENDAR_SYNC_STATUSES,
+  GOOGLE_SYNC_STATES,
+  MAX_ATTENDEES,
+  MAX_BOOKING_MINUTES,
+  MAX_REMINDER_MINUTES,
+  MAX_REMINDER_OVERRIDES,
+  bookingAttendeeSchema,
+  bookingCancelSchema,
+  bookingCreateSchema,
+  bookingCustomerSchema,
+  bookingLocationNullableSchema,
+  bookingLocationSchema,
+  bookingMetadataSchema,
+  bookingReminderSchema,
+  bookingRemindersSchema,
+  bookingRescheduleSchema,
+  computeSlots,
+  createCalendarReadClient,
+  durationMinutes,
+  endOfDayInTz,
+  formatDateInTz,
+  formatSlotRange,
+  groupSlotsByDay,
+  instantFromWallClock,
+  isCalendarError,
+  localDateKey,
+  offsetMinutesAt,
+  resolveBrowserTimeZone,
+  startOfDayInTz
+});
+//# sourceMappingURL=calendar.js.map