@aranova/tracking-next 0.27.0 → 1.0.0

package/dist/calendar.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/calendar.ts
@@ -74,32 +84,6 @@ var AranovaApiError = class extends Error {
   }
 };
 
-// ../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";
@@ -133,9 +117,9 @@ async function apiRequest(config, method, path, body, extraHeaders) {
     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;
+        const record3 = parsed;
+        if (typeof record3.detail === "string") detail = record3.detail;
+        if (typeof record3.code === "string") code = record3.code;
       }
     } catch {
     }
@@ -155,9 +139,9 @@ async function calendarRequest(config, method, 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;
+function formatDateInTz(iso2, timeZone, opts, locale) {
+  const date = new Date(iso2);
+  if (Number.isNaN(date.getTime())) return iso2;
   return new Intl.DateTimeFormat(locale, {
     year: "numeric",
     month: "short",
@@ -206,8 +190,8 @@ function instantFromWallClock(timeZone, year, month, day, hour = 0, minute = 0)
   const corrected = naive - offsetMinutesAt(firstGuess, timeZone) * 6e4;
   return new Date(corrected);
 }
-function localDateKey(iso, timeZone) {
-  const p = partsInTz(new Date(iso), timeZone);
+function localDateKey(iso2, timeZone) {
+  const p = partsInTz(new Date(iso2), timeZone);
   const pad = (n) => String(n).padStart(2, "0");
   return `${p.year}-${pad(p.month)}-${pad(p.day)}`;
 }
@@ -262,7 +246,167 @@ function isCalendarError(error, code) {
 }
 
 // ../tracking-core/src/resources/calendar/schema.ts
-var import_zod2 = require("zod");
+var z2 = __toESM(require("zod/mini"));
+
+// ../tracking-core/src/resources/calendar/generated/zod.gen.ts
+var z = __toESM(require("zod/mini"));
+var zBookingAttendee = z.strictObject({
+  display_name: z.nullish(z.string().check(z.maxLength(200))),
+  email: z.email().check(z.maxLength(320)),
+  optional: z._default(z.optional(z.boolean()), false)
+});
+var zBookingCancelSchema = z.strictObject({
+  notify_attendees: z._default(z.optional(z.boolean()), true),
+  reason: z.nullish(z.string().check(z.maxLength(500)))
+});
+var zBookingCustomerInput = z.strictObject({
+  email: z.email().check(z.maxLength(320)),
+  name: z.nullish(z.string().check(z.maxLength(200))),
+  phone: z.nullish(z.string().check(z.maxLength(64))),
+  sms_consent: z._default(z.optional(z.boolean()), false)
+});
+var zBookingCustomerOutput = z.strictObject({
+  email: z.email().check(z.maxLength(320)),
+  name: z.nullable(z.string().check(z.maxLength(200))),
+  phone: z.nullable(z.string().check(z.maxLength(64))),
+  sms_consent: z._default(z.boolean(), false)
+});
+var zBookingRescheduleSchema = z.strictObject({
+  duration_minutes: z.nullish(z.int().check(z.gt(0), z.lte(1440))),
+  end_at: z.nullish(z.iso.datetime({ offset: true })),
+  notify_attendees: z._default(z.optional(z.boolean()), true),
+  reason: z.nullish(z.string().check(z.maxLength(500))),
+  start_at: z.iso.datetime({ offset: true }),
+  time_zone: z.string().check(z.minLength(1), z.maxLength(64), z.regex(/^[A-Za-z0-9_+\-\/]+$/))
+});
+var zBookingResponse = z.strictObject({
+  appointment_type: z.nullable(z.string()),
+  calendar_key: z.string(),
+  customer: zBookingCustomerOutput,
+  end_at: z.iso.datetime({ offset: true }),
+  google_html_link: z.nullable(z.string()),
+  google_sync_state: z.string(),
+  id: z.string(),
+  manage_token: z.nullable(z.string()),
+  meet_url: z.nullable(z.string()),
+  start_at: z.iso.datetime({ offset: true }),
+  status: z.string(),
+  time_zone: z.string(),
+  title: z.string()
+});
+var zBookingSource = z.enum(["website", "phone", "walk_in", "import", "operator"]);
+var zBookingMetadata = z.strictObject({
+  custom: z.nullish(
+    z.record(z.string(), z.nullable(z.union([z.string(), z.int(), z.number(), z.boolean()])))
+  ),
+  fbclid: z.nullish(z.string().check(z.maxLength(256))),
+  gclid: z.nullish(z.string().check(z.maxLength(256))),
+  landing_page: z.nullish(z.string().check(z.maxLength(2048))),
+  notes: z.nullish(z.string().check(z.maxLength(2e3))),
+  referrer: z.nullish(z.string().check(z.maxLength(2048))),
+  schema_version: z._default(z.optional(z.int()), 1),
+  service: z.nullish(z.string().check(z.maxLength(64))),
+  session_id: z.nullish(z.string().check(z.maxLength(64))),
+  source: z.nullish(zBookingSource),
+  utm_campaign: z.nullish(z.string().check(z.maxLength(128))),
+  utm_content: z.nullish(z.string().check(z.maxLength(128))),
+  utm_medium: z.nullish(z.string().check(z.maxLength(128))),
+  utm_source: z.nullish(z.string().check(z.maxLength(128))),
+  utm_term: z.nullish(z.string().check(z.maxLength(128))),
+  visitor_id: z.nullish(z.string().check(z.maxLength(64)))
+});
+var zCustomLocation = z.strictObject({
+  kind: z.literal("custom"),
+  text: z.string().check(z.maxLength(1024))
+});
+var zErrorCode = z.enum([
+  "missing_credentials",
+  "invalid_api_key",
+  "not_authenticated",
+  "wrong_key_type",
+  "origin_missing",
+  "origin_not_allowed",
+  "capability_denied",
+  "session_required",
+  "operator_only",
+  "cross_tenant",
+  "business_id_required",
+  "bad_request",
+  "not_found",
+  "conflict",
+  "incompatible_payload",
+  "repeat_confirmation_required",
+  "idempotency_conflict",
+  "validation_error",
+  "unknown_service",
+  "invalid_sale_properties",
+  "invalid_cursor",
+  "rate_limited",
+  "internal_error"
+]);
+var zMeetLocation = z.strictObject({
+  kind: z.literal("google_meet")
+});
+var zPhoneLocation = z.strictObject({
+  kind: z.literal("phone"),
+  phone: z.string().check(z.maxLength(64))
+});
+var zPhysicalLocation = z.strictObject({
+  address: z.string().check(z.maxLength(1024)),
+  kind: z.literal("physical")
+});
+var zReminderMethod = z.enum(["email", "popup"]);
+var zBookingReminder = z.strictObject({
+  method: zReminderMethod,
+  minutes_before: z.int().check(z.gte(0), z.lte(40320))
+});
+var zBookingReminders = z.strictObject({
+  overrides: z.optional(z.array(zBookingReminder).check(z.maxLength(5))),
+  use_calendar_defaults: z._default(z.optional(z.boolean()), true)
+});
+var zBookingCreateSchema = z.strictObject({
+  appointment_type: z.nullish(z.string().check(z.maxLength(64))),
+  attendees: z.optional(z.array(zBookingAttendee).check(z.maxLength(20))),
+  buffer_after_minutes: z._default(z.optional(z.int().check(z.gte(0), z.lte(1440))), 0),
+  buffer_before_minutes: z._default(z.optional(z.int().check(z.gte(0), z.lte(1440))), 0),
+  calendar_key: z.string().check(z.minLength(1), z.maxLength(64)),
+  customer: zBookingCustomerInput,
+  description: z.nullish(z.string().check(z.maxLength(8e3))),
+  duration_minutes: z.nullish(z.int().check(z.gt(0), z.lte(1440))),
+  end_at: z.nullish(z.iso.datetime({ offset: true })),
+  idempotency_key: z.nullish(z.string().check(z.maxLength(128))),
+  location: z.nullish(z.union([zMeetLocation, zPhysicalLocation, zPhoneLocation, zCustomLocation])),
+  metadata: z.nullish(zBookingMetadata),
+  reminders: z.nullish(zBookingReminders),
+  send_invites: z._default(z.optional(z.boolean()), true),
+  start_at: z.iso.datetime({ offset: true }),
+  time_zone: z.string().check(z.minLength(1), z.maxLength(64), z.regex(/^[A-Za-z0-9_+\-\/]+$/)),
+  title: z.nullish(z.string().check(z.maxLength(300)))
+});
+var zValidationError = z.object({
+  ctx: z.optional(z.record(z.string(), z.unknown())),
+  input: z.optional(z.unknown()),
+  loc: z.array(z.union([z.string(), z.int()])),
+  msg: z.string(),
+  type: z.string()
+});
+var zHttpValidationError = z.object({
+  detail: z.optional(z.array(zValidationError))
+});
+var zValidationErrorItem = z.object({
+  loc: z.array(z.union([z.string(), z.int()])),
+  msg: z.string(),
+  type: z.string()
+});
+var zApiErrorSchema = z.object({
+  code: zErrorCode,
+  context: z._default(z.nullish(z.record(z.string(), z.unknown())), null),
+  detail: z.string(),
+  errors: z._default(z.nullish(z.array(zValidationErrorItem)), null),
+  request_id: z._default(z.nullish(z.string()), null)
+});
+
+// ../tracking-core/src/resources/calendar/schema.ts
 var CALENDAR_METADATA_SCHEMA_VERSION = 1;
 var MAX_ATTENDEES = 20;
 var MAX_REMINDER_OVERRIDES = 5;
@@ -288,7 +432,6 @@ var CALENDAR_ERROR_CODES = [
   "rate_limited",
   "google_error"
 ];
-var isoInstant = import_zod2.z.string().datetime({ offset: true });
 function isKnownTimeZone(timeZone) {
   try {
     new Intl.DateTimeFormat(void 0, { timeZone });
@@ -297,107 +440,65 @@ function isKnownTimeZone(timeZone) {
     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 ianaTz = z2.string().check(
+  z2.minLength(1),
+  z2.maxLength(64),
+  z2.regex(/^[A-Za-z0-9_+\-/]+$/),
+  z2.refine(isKnownTimeZone, { error: "unknown IANA time zone" })
+);
+var bookingAttendeeSchema = zBookingAttendee;
+var bookingReminderSchema = zBookingReminder;
+var bookingCustomerSchema = zBookingCustomerInput;
+var bookingMetadataSchema = z2.extend(zBookingMetadata, {
+  custom: z2.nullish(
+    z2.record(z2.string(), z2.union([z2.string(), z2.int(), z2.number(), z2.boolean(), z2.null()]))
+  )
+});
+var bookingLocationSchema = z2.union([
+  zMeetLocation,
+  zPhysicalLocation,
+  zPhoneLocation,
+  zCustomLocation
 ]);
-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();
+var bookingLocationNullableSchema = z2.union([
+  ...bookingLocationSchema.def.options,
+  z2.null()
+]);
+function addIssue(ctx, path, message) {
+  ctx.issues.push({ code: "custom", input: ctx.value, path, message });
+}
 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"]
-    });
+    addIssue(ctx, ["end_at"], "provide exactly one of end_at or duration_minutes");
     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"]
-    });
+    addIssue(ctx, ["end_at"], "end_at must be after start_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(),
+var bookingRemindersSchema = z2.extend(zBookingReminders, {
+  overrides: z2._default(
+    z2.array(bookingReminderSchema).check(z2.maxLength(MAX_REMINDER_OVERRIDES)),
+    []
+  )
+});
+var bookingCreateSchema = z2.extend(zBookingCreateSchema, {
   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();
+  // The generated field is `z.union([...variants]).nullish()`, which nests one
+  // `anyOf` inside another; Pydantic's `BookingLocation | None` flattens to a
+  // single list and the drift snapshot compares structure. Override with the
+  // flattened union.
+  location: z2.optional(bookingLocationNullableSchema),
+  attendees: z2._default(z2.array(bookingAttendeeSchema).check(z2.maxLength(MAX_ATTENDEES)), []),
+  // These reference the un-composed generated schemas; generation can't nest
+  // our compositions into its own output.
+  reminders: z2.nullish(bookingRemindersSchema),
+  metadata: z2.nullish(bookingMetadataSchema)
+}).check((ctx) => refineEndXor(ctx.value, ctx));
+var bookingRescheduleSchema = z2.extend(zBookingRescheduleSchema, { time_zone: ianaTz }).check((ctx) => refineEndXor(ctx.value, ctx));
+var bookingCancelSchema = zBookingCancelSchema;
 
 // ../tracking-core/src/resources/calendar/slots.ts
 function parseHhMm(value) {