@aranova/tracking-next 0.27.0 → 1.0.0

package/dist/client.js

@@ -626,10 +626,10 @@ function readStoredRecord() {
     return null;
   }
 }
-function writeRecord(record) {
-  memoryRecord = record;
+function writeRecord(record3) {
+  memoryRecord = record3;
   try {
-    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record));
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record3));
   } catch {
   }
 }
@@ -651,9 +651,9 @@ function getOrCaptureLandingParams(sessionId, url) {
   if (memoryRecord && memoryRecord.session_id === sessionId) {
     return memoryRecord.params;
   }
-  const record = { session_id: sessionId, params: captureFromUrl(url) };
-  writeRecord(record);
-  return record.params;
+  const record3 = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record3);
+  return record3.params;
 }
 function buildLandingPayloadFields(sessionId, override) {
   const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
@@ -1485,25 +1485,32 @@ function getOrRotateSessionId(now = Date.now()) {
   return { id: fresh.id, isNew: true };
 }
 
+// ../tracking-core/src/page-view.ts
+var import_mini = require("zod/mini");
+
 // ../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
+var z = __toESM(require("zod/mini"));
+var pageViewMetadataSchema = z.strictObject({
+  page: z.strictObject({
+    title: z.nullable(z.string()),
+    path: z.string(),
+    search: z.string(),
+    hash: z.string()
+  }),
+  referrer: z.nullable(z.string()),
+  // Optional + nullable — 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();
+  viewport: z.optional(
+    z.nullable(
+      z.strictObject({
+        w: z.number(),
+        h: z.number()
+      })
+    )
+  )
+});
+var pageViewConfigSchema = z.strictObject({});
 
 // ../tracking-core/src/page-view.ts
 var LAST_FIRED_URL_STORAGE_KEY = "aranova_tracking_last_fired_url";
@@ -1539,7 +1546,7 @@ function setLastFiredUrl(url) {
 }
 function buildPageViewMetadata(referrerOverride) {
   if (typeof window === "undefined" || typeof document === "undefined") return null;
-  return pageViewMetadataSchema.parse({
+  return (0, import_mini.parse)(pageViewMetadataSchema, {
     page: {
       title: document.title || null,
       path: window.location.pathname,
@@ -1997,186 +2004,198 @@ function createTrackingClient(config) {
   };
 }
 
+// ../tracking-core/src/ingest-typed.ts
+var import_mini2 = require("zod/mini");
+
 // ../tracking-core/src/events/cta-click.ts
-var import_zod2 = require("zod");
-var ctaClickMetadataSchema = import_zod2.z.object({
-  cta_name: import_zod2.z.string(),
-  page: import_zod2.z.object({
-    path: import_zod2.z.string()
-  }).strict(),
-  section: import_zod2.z.string().nullable().optional(),
-  destination_url: import_zod2.z.string().nullable().optional(),
+var z2 = __toESM(require("zod/mini"));
+var ctaClickMetadataSchema = z2.strictObject({
+  cta_name: z2.string(),
+  page: z2.strictObject({
+    path: z2.string()
+  }),
+  section: z2.optional(z2.nullable(z2.string())),
+  destination_url: z2.optional(z2.nullable(z2.string())),
   // Set by auto-capture (and available to manual callers): the link target
   // and a short element descriptor (tag#id) for tying clicks to specific UI.
-  href: import_zod2.z.string().nullable().optional(),
-  element: import_zod2.z.string().nullable().optional()
-}).strict();
-var ctaClickConfigSchema = import_zod2.z.object({
-  autoCapture: import_zod2.z.object({
-    selector: import_zod2.z.string().optional()
-  }).strict().optional()
-}).strict();
+  href: z2.optional(z2.nullable(z2.string())),
+  element: z2.optional(z2.nullable(z2.string()))
+});
+var ctaClickConfigSchema = z2.strictObject({
+  autoCapture: z2.optional(
+    z2.strictObject({
+      selector: z2.optional(z2.string())
+    })
+  )
+});
 
 // ../tracking-core/src/events/sdk-heartbeat.ts
-var import_zod3 = require("zod");
-var sdkHeartbeatTriggersSchema = import_zod3.z.object({
-  automatic: import_zod3.z.array(import_zod3.z.string()),
-  manual: import_zod3.z.array(import_zod3.z.string())
-}).strict();
-var sdkHeartbeatMetadataSchema = import_zod3.z.object({
-  sdk_version: import_zod3.z.string(),
-  package_name: import_zod3.z.string().nullable(),
-  surface: import_zod3.z.enum(["next", "react", "script"]),
+var z3 = __toESM(require("zod/mini"));
+var sdkHeartbeatTriggersSchema = z3.strictObject({
+  automatic: z3.array(z3.string()),
+  manual: z3.array(z3.string())
+});
+var sdkHeartbeatMetadataSchema = z3.strictObject({
+  sdk_version: z3.string(),
+  package_name: z3.nullable(z3.string()),
+  surface: z3.enum(["next", "react", "script"]),
   triggers: sdkHeartbeatTriggersSchema,
-  trigger_config: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())).nullable().optional(),
-  configured_gtag_ids: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).nullable().optional(),
+  trigger_config: z3.optional(z3.nullable(z3.record(z3.string(), z3.record(z3.string(), z3.unknown())))),
+  configured_gtag_ids: z3.optional(z3.nullable(z3.record(z3.string(), z3.string()))),
   // Site whose config object the SDK resolves; null on a legacy business ref.
-  config_site_id: import_zod3.z.string().uuid().nullable().optional()
-}).strict();
-var sdkHeartbeatConfigSchema = import_zod3.z.object({}).strict();
+  config_site_id: z3.optional(z3.nullable(z3.uuid()))
+});
+var sdkHeartbeatConfigSchema = z3.strictObject({});
 
 // ../tracking-core/src/events/form-start.ts
-var import_zod4 = require("zod");
-var formStartMetadataSchema = import_zod4.z.object({
-  form: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    action: import_zod4.z.string().nullable()
-  }).strict(),
-  page: import_zod4.z.object({
-    path: import_zod4.z.string()
-  }).strict()
-}).strict();
-var formStartConfigSchema = import_zod4.z.object({
-  selector: import_zod4.z.string().optional()
-}).strict();
+var z4 = __toESM(require("zod/mini"));
+var formStartMetadataSchema = z4.strictObject({
+  form: z4.strictObject({
+    id: z4.string(),
+    action: z4.nullable(z4.string())
+  }),
+  page: z4.strictObject({
+    path: z4.string()
+  })
+});
+var formStartConfigSchema = z4.strictObject({
+  selector: z4.optional(z4.string())
+});
 
 // ../tracking-core/src/events/form-submit.ts
-var import_zod5 = require("zod");
-var jsonValueSchema = import_zod5.z.lazy(
-  () => import_zod5.z.union([
-    import_zod5.z.string(),
-    import_zod5.z.number().finite(),
-    import_zod5.z.boolean(),
-    import_zod5.z.null(),
-    import_zod5.z.array(jsonValueSchema),
-    import_zod5.z.record(jsonValueSchema)
+var z5 = __toESM(require("zod/mini"));
+var jsonValueSchema = z5.lazy(
+  () => z5.union([
+    z5.string(),
+    z5.number(),
+    z5.boolean(),
+    z5.null(),
+    z5.array(jsonValueSchema),
+    z5.record(z5.string(), jsonValueSchema)
   ])
-);
-var formSubmitMetadataSchema = import_zod5.z.object({
-  form: import_zod5.z.object({
-    id: import_zod5.z.string(),
-    action: import_zod5.z.string().nullable(),
-    fields: import_zod5.z.array(
-      import_zod5.z.object({
-        name: import_zod5.z.string(),
-        type: import_zod5.z.string(),
-        label: import_zod5.z.string().nullable(),
-        value: jsonValueSchema
-      }).strict()
-    ).optional()
-  }).strict(),
-  page: import_zod5.z.object({
-    path: import_zod5.z.string()
-  }).strict()
-}).strict();
-var formSubmitConfigSchema = import_zod5.z.object({}).strict();
+).register(z5.globalRegistry, { id: "JsonSerializableValue" });
+var formSubmitMetadataSchema = z5.strictObject({
+  form: z5.strictObject({
+    id: z5.string(),
+    action: z5.nullable(z5.string()),
+    fields: z5.optional(
+      z5.array(
+        z5.strictObject({
+          name: z5.string(),
+          type: z5.string(),
+          label: z5.nullable(z5.string()),
+          value: jsonValueSchema
+        })
+      )
+    )
+  }),
+  page: z5.strictObject({
+    path: z5.string()
+  })
+});
+var formSubmitConfigSchema = z5.strictObject({});
 
 // ../tracking-core/src/events/multi-page-session.ts
-var import_zod6 = require("zod");
-var multiPageSessionMetadataSchema = import_zod6.z.object({
-  page_count: import_zod6.z.number().int().min(2),
-  page: import_zod6.z.object({
-    path: import_zod6.z.string()
-  }).strict()
-}).strict();
-var multiPageSessionConfigSchema = import_zod6.z.object({
-  pageThreshold: import_zod6.z.number().int().min(2)
-}).strict();
+var z6 = __toESM(require("zod/mini"));
+var multiPageSessionMetadataSchema = z6.strictObject({
+  page_count: z6.int().check(z6.gte(2)),
+  page: z6.strictObject({
+    path: z6.string()
+  })
+});
+var multiPageSessionConfigSchema = z6.strictObject({
+  pageThreshold: z6.int().check(z6.gte(2))
+});
 
 // ../tracking-core/src/events/page-exit.ts
-var import_zod7 = require("zod");
-var pageExitMetadataSchema = import_zod7.z.object({
-  dwell_ms: import_zod7.z.number().int().min(0),
+var z7 = __toESM(require("zod/mini"));
+var pageExitMetadataSchema = z7.strictObject({
+  dwell_ms: z7.int().check(z7.gte(0)),
   // null = left without any scroll signal; floor is 0 so a valid 0% is never
   // rejected (a single bad field 422s the whole keepalive beacon batch).
-  max_scroll_percent: import_zod7.z.number().int().min(0).max(100).nullable(),
+  max_scroll_percent: z7.nullable(z7.int().check(z7.gte(0), z7.lte(100))),
   // The gating baseline: the fraction of the page visible at load with
   // zero scrolling — or, for pages that grew after the post-paint snapshot
   // (skeleton/streaming renders), the first-scroll position that
   // established it. null = page had no scrollable range, or the segment
-  // ended before the snapshot. `.optional()` is load-bearing: SDK builds
+  // ended before the snapshot. Optionality is load-bearing: SDK builds
   // predating this field keep POSTing page_exit without the key —
   // requiring it would 422 whole keepalive beacon batches.
-  scroll_baseline_percent: import_zod7.z.number().int().min(0).max(100).nullable().optional(),
-  page: import_zod7.z.object({
-    path: import_zod7.z.string()
-  }).strict()
-}).strict();
-var pageExitConfigSchema = import_zod7.z.object({}).strict();
+  scroll_baseline_percent: z7.optional(z7.nullable(z7.int().check(z7.gte(0), z7.lte(100)))),
+  page: z7.strictObject({
+    path: z7.string()
+  })
+});
+var pageExitConfigSchema = z7.strictObject({});
 
 // ../tracking-core/src/events/phone-click.ts
-var import_zod8 = require("zod");
-var phoneClickMetadataSchema = import_zod8.z.object({
-  phone_number: import_zod8.z.string(),
-  page: import_zod8.z.object({
-    path: import_zod8.z.string()
-  }).strict(),
-  section: import_zod8.z.string().nullable().optional()
-}).strict();
-var phoneClickConfigSchema = import_zod8.z.object({
-  autoCapture: import_zod8.z.object({
-    selector: import_zod8.z.string().optional()
-  }).strict().optional()
-}).strict();
+var z8 = __toESM(require("zod/mini"));
+var phoneClickMetadataSchema = z8.strictObject({
+  phone_number: z8.string(),
+  page: z8.strictObject({
+    path: z8.string()
+  }),
+  section: z8.optional(z8.nullable(z8.string()))
+});
+var phoneClickConfigSchema = z8.strictObject({
+  autoCapture: z8.optional(
+    z8.strictObject({
+      selector: z8.optional(z8.string())
+    })
+  )
+});
 
 // ../tracking-core/src/events/scroll-depth.ts
-var import_zod9 = require("zod");
-var scrollDepthMetadataSchema = import_zod9.z.object({
-  depth_percent: import_zod9.z.number().int().min(1).max(100),
-  page: import_zod9.z.object({
-    path: import_zod9.z.string()
-  }).strict()
-}).strict();
-var scrollDepthConfigSchema = import_zod9.z.object({
-  thresholds: import_zod9.z.array(import_zod9.z.number().int().min(1).max(100)).min(1)
-}).strict();
+var z9 = __toESM(require("zod/mini"));
+var scrollDepthMetadataSchema = z9.strictObject({
+  depth_percent: z9.int().check(z9.gte(1), z9.lte(100)),
+  page: z9.strictObject({
+    path: z9.string()
+  })
+});
+var scrollDepthConfigSchema = z9.strictObject({
+  thresholds: z9.array(z9.int().check(z9.gte(1), z9.lte(100))).check(z9.minLength(1))
+});
 
 // ../tracking-core/src/events/specific-page-visit.ts
-var import_zod10 = require("zod");
+var z10 = __toESM(require("zod/mini"));
 var PAGE_IDENTITY_MAX_LENGTH = 64;
 var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-var pageIdentitySchema = import_zod10.z.string().max(PAGE_IDENTITY_MAX_LENGTH).regex(PAGE_IDENTITY_PATTERN, {
-  message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
-});
+var pageIdentitySchema = z10.string().check(
+  z10.maxLength(PAGE_IDENTITY_MAX_LENGTH),
+  z10.regex(PAGE_IDENTITY_PATTERN, {
+    message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
+  })
+);
 var specificPageNameSchema = pageIdentitySchema;
-var specificPageVisitMetadataSchema = import_zod10.z.object({
+var specificPageVisitMetadataSchema = z10.strictObject({
   page_name: specificPageNameSchema,
-  page: import_zod10.z.object({
-    path: import_zod10.z.string()
-  }).strict()
-}).strict();
-var specificPageVisitConfigSchema = import_zod10.z.object({
-  pages: import_zod10.z.array(
-    import_zod10.z.object({
+  page: z10.strictObject({
+    path: z10.string()
+  })
+});
+var specificPageVisitConfigSchema = z10.strictObject({
+  pages: z10.array(
+    z10.strictObject({
       name: specificPageNameSchema,
-      pathPattern: import_zod10.z.custom((value) => value instanceof RegExp, {
+      pathPattern: z10.custom((value) => value instanceof RegExp, {
         message: "pathPattern must be a RegExp"
       })
-    }).strict()
-  ).min(1)
-}).strict();
+    })
+  ).check(z10.minLength(1))
+});
 
 // ../tracking-core/src/events/time-on-site.ts
-var import_zod11 = require("zod");
-var timeOnSiteMetadataSchema = import_zod11.z.object({
-  duration_ms: import_zod11.z.number().int().nonnegative(),
-  page: import_zod11.z.object({
-    path: import_zod11.z.string()
-  }).strict()
-}).strict();
-var timeOnSiteConfigSchema = import_zod11.z.object({
-  thresholdSeconds: import_zod11.z.number().int().positive()
-}).strict();
+var z11 = __toESM(require("zod/mini"));
+var timeOnSiteMetadataSchema = z11.strictObject({
+  duration_ms: z11.int().check(z11.nonnegative()),
+  page: z11.strictObject({
+    path: z11.string()
+  })
+});
+var timeOnSiteConfigSchema = z11.strictObject({
+  thresholdSeconds: z11.int().check(z11.positive())
+});
 
 // ../tracking-core/src/events/semantics.ts
 var EVENT_SEMANTICS = {
@@ -2335,7 +2354,7 @@ function createTypedClient(raw, registry, options = {}) {
     trackEvent(eventType, metadata, opts) {
       if (debug) {
         const def = getEventDefinition(eventType);
-        def.metadataSchema.parse(metadata);
+        (0, import_mini2.parse)(def.metadataSchema, metadata);
       }
       raw.trackEvent({
         eventType,
@@ -2824,117 +2843,6 @@ function attachPhoneClickCapture(client, config) {
   };
 }
 
-// ../tracking-core/src/resources/sales/schema.ts
-var import_zod12 = require("zod");
-var SUPPORTED_CURRENCIES = ["USD", "CAD"];
-var TRACKING_ENVIRONMENTS = ["production", "development"];
-var currencySchema = import_zod12.z.enum(SUPPORTED_CURRENCIES);
-var centsSchema = import_zod12.z.number().int().nonnegative();
-var quantitySchema = import_zod12.z.string().regex(/^\d+(\.\d{1,3})?$/);
-var metadataSchema = import_zod12.z.record(import_zod12.z.unknown());
-var saleItemSchema = import_zod12.z.object({
-  external_item_id: import_zod12.z.string().nullable().optional(),
-  name: import_zod12.z.string().nullable().optional(),
-  category: import_zod12.z.string().nullable().optional(),
-  quantity: quantitySchema,
-  unit_price_cents: centsSchema,
-  // Non-negativity validated on the wire — same contract as the other cents
-  // fields — and backstopped by the DB CHECK.
-  unit_cost_cents: centsSchema.nullable().optional()
-}).strict();
-var saleServiceSchema = import_zod12.z.object({
-  service: import_zod12.z.string(),
-  amount_cents: centsSchema
-}).strict();
-var customerNameSchema = import_zod12.z.string().max(200);
-var customerPhoneSchema = import_zod12.z.string().max(64);
-var customerEmailSchema = import_zod12.z.string().max(320).email();
-function refineServiceXor(val, ctx, { requireAmount }) {
-  if (val.services != null) {
-    if (val.service != null) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "pass either `service` or `services`, not both",
-        path: ["services"]
-      });
-    }
-    if (val.services.length === 0) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "`services` must not be empty",
-        path: ["services"]
-      });
-    }
-    const keys = val.services.map((s) => s.service);
-    if (new Set(keys).size !== keys.length) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "`services` must not list the same service more than once",
-        path: ["services"]
-      });
-    }
-    if (val.amount_total_cents != null) {
-      const sum = val.services.reduce((acc, s) => acc + s.amount_cents, 0);
-      if (val.amount_total_cents !== sum) {
-        ctx.addIssue({
-          code: import_zod12.z.ZodIssueCode.custom,
-          message: "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)",
-          path: ["amount_total_cents"]
-        });
-      }
-    }
-  } else if (requireAmount && val.amount_total_cents == null) {
-    ctx.addIssue({
-      code: import_zod12.z.ZodIssueCode.custom,
-      message: "amount_total_cents is required unless `services` is provided",
-      path: ["amount_total_cents"]
-    });
-  }
-}
-var saleCreateSchema = import_zod12.z.object({
-  external_id: import_zod12.z.string().nullable().optional(),
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema,
-  // Optional only because the plural `services` form derives it from the sum
-  // (see refineServiceXor); the singular/serviceless path still requires it.
-  amount_total_cents: centsSchema.nullable().optional(),
-  occurred_at: import_zod12.z.string().datetime(),
-  environment: import_zod12.z.enum(TRACKING_ENVIRONMENTS).default("production"),
-  items: import_zod12.z.array(saleItemSchema).default([]),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
-  // CASL consent attestation: the customer agreed to receive SMS. Recorded
-  // with a timestamp server-side; every SMS send path gates on it.
-  //
-  // Tri-state: omit it (or send null) to let the server apply the business's
-  // configured default-opt-in policy, honouring a returning customer's
-  // remembered preference. Send an explicit boolean to assert consent state
-  // yourself — `false` records a deliberate opt-out.
-  sms_consent: import_zod12.z.boolean().nullable().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
-var saleUpdateSchema = import_zod12.z.object({
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema.optional(),
-  amount_total_cents: centsSchema.optional(),
-  occurred_at: import_zod12.z.string().datetime().optional(),
-  items: import_zod12.z.array(saleItemSchema).optional(),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
-  // Re-attest when changing a filler-looking name; the server clears the
-  // prior attestation whenever `customer_name` changes.
-  customer_name_placeholder_confirmed: import_zod12.z.boolean().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
-  // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
-  sms_consent: import_zod12.z.boolean().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: false }));
-
 // src/hooks.ts
 function useGclid() {
   const [gclid, setGclid] = (0, import_react.useState)(null);
@@ -3275,7 +3183,7 @@ function GoogleAdsTracking(props) {
 var import_navigation3 = require("next/navigation");
 
 // package.json
-var version = "0.27.0";
+var version = "1.0.0";
 
 // src/factory.tsx
 var import_react5 = require("react");