@aranova/tracking-react 1.2.2 → 1.2.3

package/dist/client.mjs

@@ -1701,6 +1701,12 @@ var EVENT_SEMANTICS = {
     outcomeRole: "diagnostic",
     clientVisibility: "detailed"
   },
+  form_step: {
+    label: "Form step",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "detailed"
+  },
   form_submit: {
     label: "Form submitted",
     category: "lead",
@@ -2364,7 +2370,7 @@ function createTrackingClient(config) {
 }
 
 // ../tracking-core/src/ingest-typed.ts
-import { parse as parse2 } from "zod/mini";
+import { parse as parse2, safeParse } from "zod/mini";
 
 // ../tracking-core/src/events/cta-click.ts
 import * as z3 from "zod/mini";
@@ -2421,58 +2427,79 @@ var formStartConfigSchema = z5.strictObject({
   selector: z5.optional(z5.string())
 });
 
-// ../tracking-core/src/events/form-submit.ts
+// ../tracking-core/src/events/form-step.ts
 import * as z6 from "zod/mini";
-var jsonValueSchema = z6.lazy(
-  () => z6.union([
-    z6.string(),
-    z6.number(),
-    z6.boolean(),
-    z6.null(),
-    z6.array(jsonValueSchema),
-    z6.record(z6.string(), jsonValueSchema)
-  ])
-).register(z6.globalRegistry, { id: "JsonSerializableValue" });
-var formSubmitMetadataSchema = z6.strictObject({
+var formStepMetadataSchema = z6.strictObject({
   form: z6.strictObject({
     id: z6.string(),
-    action: z6.nullable(z6.string()),
-    fields: z6.optional(
-      z6.array(
-        z6.strictObject({
-          name: z6.string(),
-          type: z6.string(),
-          label: z6.nullable(z6.string()),
-          value: jsonValueSchema
-        })
-      )
-    )
+    action: z6.nullable(z6.string())
+  }),
+  step: z6.strictObject({
+    id: z6.string().check(z6.minLength(1), z6.maxLength(64), z6.regex(/^[A-Za-z0-9_-]+$/)),
+    // 1-based position in the flow the visitor is on right now.
+    index: z6.int().check(z6.gte(1), z6.lte(50)),
+    // Null when the number of steps depends on earlier answers.
+    total: z6.nullable(z6.int().check(z6.gte(1), z6.lte(50)))
   }),
+  direction: z6.enum(["forward", "back"]),
   page: z6.strictObject({
     path: z6.string()
   })
 });
-var formSubmitConfigSchema = z6.strictObject({});
+var formStepConfigSchema = z6.strictObject({});
 
-// ../tracking-core/src/events/multi-page-session.ts
+// ../tracking-core/src/events/form-submit.ts
 import * as z7 from "zod/mini";
-var multiPageSessionMetadataSchema = z7.strictObject({
-  page_count: z7.int().check(z7.gte(2)),
+var jsonValueSchema = z7.lazy(
+  () => z7.union([
+    z7.string(),
+    z7.number(),
+    z7.boolean(),
+    z7.null(),
+    z7.array(jsonValueSchema),
+    z7.record(z7.string(), jsonValueSchema)
+  ])
+).register(z7.globalRegistry, { id: "JsonSerializableValue" });
+var formSubmitMetadataSchema = z7.strictObject({
+  form: z7.strictObject({
+    id: z7.string(),
+    action: z7.nullable(z7.string()),
+    fields: z7.optional(
+      z7.array(
+        z7.strictObject({
+          name: z7.string(),
+          type: z7.string(),
+          label: z7.nullable(z7.string()),
+          value: jsonValueSchema
+        })
+      )
+    )
+  }),
   page: z7.strictObject({
     path: z7.string()
   })
 });
-var multiPageSessionConfigSchema = z7.strictObject({
-  pageThreshold: z7.int().check(z7.gte(2))
+var formSubmitConfigSchema = z7.strictObject({});
+
+// ../tracking-core/src/events/multi-page-session.ts
+import * as z8 from "zod/mini";
+var multiPageSessionMetadataSchema = z8.strictObject({
+  page_count: z8.int().check(z8.gte(2)),
+  page: z8.strictObject({
+    path: z8.string()
+  })
+});
+var multiPageSessionConfigSchema = z8.strictObject({
+  pageThreshold: z8.int().check(z8.gte(2))
 });
 
 // ../tracking-core/src/events/page-exit.ts
-import * as z8 from "zod/mini";
-var pageExitMetadataSchema = z8.strictObject({
-  dwell_ms: z8.int().check(z8.gte(0)),
+import * as z9 from "zod/mini";
+var pageExitMetadataSchema = z9.strictObject({
+  dwell_ms: z9.int().check(z9.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: z8.nullable(z8.int().check(z8.gte(0), z8.lte(100))),
+  max_scroll_percent: z9.nullable(z9.int().check(z9.gte(0), z9.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
@@ -2480,104 +2507,104 @@ var pageExitMetadataSchema = z8.strictObject({
   // 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: z8.optional(z8.nullable(z8.int().check(z8.gte(0), z8.lte(100)))),
-  page: z8.strictObject({
-    path: z8.string()
+  scroll_baseline_percent: z9.optional(z9.nullable(z9.int().check(z9.gte(0), z9.lte(100)))),
+  page: z9.strictObject({
+    path: z9.string()
   })
 });
-var pageExitConfigSchema = z8.strictObject({});
+var pageExitConfigSchema = z9.strictObject({});
 
 // ../tracking-core/src/events/phone-click.ts
-import * as z9 from "zod/mini";
-var phoneClickMetadataSchema = z9.strictObject({
-  phone_number: z9.string(),
-  page: z9.strictObject({
-    path: z9.string()
+import * as z10 from "zod/mini";
+var phoneClickMetadataSchema = z10.strictObject({
+  phone_number: z10.string(),
+  page: z10.strictObject({
+    path: z10.string()
   }),
-  section: z9.optional(z9.nullable(z9.string()))
+  section: z10.optional(z10.nullable(z10.string()))
 });
-var phoneClickConfigSchema = z9.strictObject({
-  autoCapture: z9.optional(
-    z9.strictObject({
-      selector: z9.optional(z9.string())
+var phoneClickConfigSchema = z10.strictObject({
+  autoCapture: z10.optional(
+    z10.strictObject({
+      selector: z10.optional(z10.string())
     })
   )
 });
 
 // ../tracking-core/src/events/scroll-depth.ts
-import * as z10 from "zod/mini";
-var scrollDepthMetadataSchema = z10.strictObject({
-  depth_percent: z10.int().check(z10.gte(1), z10.lte(100)),
-  page: z10.strictObject({
-    path: z10.string()
+import * as z11 from "zod/mini";
+var scrollDepthMetadataSchema = z11.strictObject({
+  depth_percent: z11.int().check(z11.gte(1), z11.lte(100)),
+  page: z11.strictObject({
+    path: z11.string()
   })
 });
-var scrollDepthConfigSchema = z10.strictObject({
-  thresholds: z10.array(z10.int().check(z10.gte(1), z10.lte(100))).check(z10.minLength(1))
+var scrollDepthConfigSchema = z11.strictObject({
+  thresholds: z11.array(z11.int().check(z11.gte(1), z11.lte(100))).check(z11.minLength(1))
 });
 
 // ../tracking-core/src/events/specific-page-visit.ts
-import * as z11 from "zod/mini";
+import * as z12 from "zod/mini";
 var PAGE_IDENTITY_MAX_LENGTH = 64;
 var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-var pageIdentitySchema = z11.string().check(
-  z11.maxLength(PAGE_IDENTITY_MAX_LENGTH),
-  z11.regex(PAGE_IDENTITY_PATTERN, {
+var pageIdentitySchema = z12.string().check(
+  z12.maxLength(PAGE_IDENTITY_MAX_LENGTH),
+  z12.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 = z11.strictObject({
+var specificPageVisitMetadataSchema = z12.strictObject({
   page_name: specificPageNameSchema,
-  page: z11.strictObject({
-    path: z11.string()
+  page: z12.strictObject({
+    path: z12.string()
   })
 });
-var specificPageVisitConfigSchema = z11.strictObject({
-  pages: z11.array(
-    z11.strictObject({
+var specificPageVisitConfigSchema = z12.strictObject({
+  pages: z12.array(
+    z12.strictObject({
       name: specificPageNameSchema,
-      pathPattern: z11.custom((value) => value instanceof RegExp, {
+      pathPattern: z12.custom((value) => value instanceof RegExp, {
         message: "pathPattern must be a RegExp"
       })
     })
-  ).check(z11.minLength(1))
+  ).check(z12.minLength(1))
 });
 
 // ../tracking-core/src/events/site-link.ts
-import * as z12 from "zod/mini";
-var siteLinkClickMetadataSchema = z12.strictObject({
-  destination_host: z12.string(),
-  destination_url: z12.string(),
-  page: z12.strictObject({
-    path: z12.string()
+import * as z13 from "zod/mini";
+var siteLinkClickMetadataSchema = z13.strictObject({
+  destination_host: z13.string(),
+  destination_url: z13.string(),
+  page: z13.strictObject({
+    path: z13.string()
   })
 });
-var siteLinkClickConfigSchema = z12.strictObject({});
-var siteLinkArrivalMetadataSchema = z12.strictObject({
-  outcome: z12.enum(["linked", "stale", "invalid"]),
-  origin_session_id: z12.optional(z12.nullable(z12.string())),
-  origin_visitor_id: z12.optional(z12.nullable(z12.string())),
+var siteLinkClickConfigSchema = z13.strictObject({});
+var siteLinkArrivalMetadataSchema = z13.strictObject({
+  outcome: z13.enum(["linked", "stale", "invalid"]),
+  origin_session_id: z13.optional(z13.nullable(z13.string())),
+  origin_visitor_id: z13.optional(z13.nullable(z13.string())),
   // Milliseconds between the origin click and this page load.
-  transit_ms: z12.optional(z12.nullable(z12.number())),
+  transit_ms: z13.optional(z13.nullable(z13.number())),
   // True when this browser had no visitor id and took the origin's.
-  adopted_visitor: z12.boolean(),
-  page: z12.strictObject({
-    path: z12.string()
+  adopted_visitor: z13.boolean(),
+  page: z13.strictObject({
+    path: z13.string()
   })
 });
-var siteLinkArrivalConfigSchema = z12.strictObject({});
+var siteLinkArrivalConfigSchema = z13.strictObject({});
 
 // ../tracking-core/src/events/time-on-site.ts
-import * as z13 from "zod/mini";
-var timeOnSiteMetadataSchema = z13.strictObject({
-  duration_ms: z13.int().check(z13.nonnegative()),
-  page: z13.strictObject({
-    path: z13.string()
+import * as z14 from "zod/mini";
+var timeOnSiteMetadataSchema = z14.strictObject({
+  duration_ms: z14.int().check(z14.nonnegative()),
+  page: z14.strictObject({
+    path: z14.string()
   })
 });
-var timeOnSiteConfigSchema = z13.strictObject({
-  thresholdSeconds: z13.int().check(z13.positive())
+var timeOnSiteConfigSchema = z14.strictObject({
+  thresholdSeconds: z14.int().check(z14.positive())
 });
 
 // ../tracking-core/src/events/registry.ts
@@ -2653,6 +2680,12 @@ var EVENT_REGISTRY = {
     metadataSchema: formSubmitMetadataSchema,
     configSchema: formSubmitConfigSchema
   },
+  form_step: {
+    kind: "manual",
+    semantics: EVENT_SEMANTICS.form_step,
+    metadataSchema: formStepMetadataSchema,
+    configSchema: formStepConfigSchema
+  },
   phone_click: {
     kind: "manual",
     semantics: EVENT_SEMANTICS.phone_click,
@@ -2679,9 +2712,14 @@ function createTypedClient(raw, registry, options = {}) {
   if (registry.manual?.form_submit) registerCapability("form_capture");
   return {
     trackEvent(eventType, metadata, opts) {
+      const def = getEventDefinition(eventType);
       if (debug) {
-        const def = getEventDefinition(eventType);
         parse2(def.metadataSchema, metadata);
+      } else if (!safeParse(def.metadataSchema, metadata).success) {
+        console.warn(
+          `[AranovaTracking] trackEvent: metadata for "${eventType}" failed schema validation; event dropped`
+        );
+        return;
       }
       raw.trackEvent({
         eventType,
@@ -3056,8 +3094,14 @@ function attachFormStart(client, config) {
     return `index:${forms.indexOf(form)}`;
   }
   function onFocusIn(event) {
-    const target = event.target;
-    if (!(target instanceof HTMLElement)) return;
+    startFrom(event.target);
+  }
+  function onPointerDown(event) {
+    if (event.button !== 0) return;
+    startFrom(event.target);
+  }
+  function startFrom(target) {
+    if (!(target instanceof Element)) return;
     const form = target.closest(selector);
     if (!form || form.tagName !== "FORM") return;
     const key = getFormKey(form);
@@ -3096,11 +3140,13 @@ function attachFormStart(client, config) {
   history.replaceState = patchedReplaceState;
   window.addEventListener("popstate", resetIfPathChanged);
   document.addEventListener("focusin", onFocusIn);
+  document.addEventListener("pointerdown", onPointerDown, { capture: true, passive: true });
   return () => {
     history.pushState = originalPushState;
     history.replaceState = originalReplaceState;
     window.removeEventListener("popstate", resetIfPathChanged);
     document.removeEventListener("focusin", onFocusIn);
+    document.removeEventListener("pointerdown", onPointerDown, { capture: true });
   };
 }
 
@@ -3687,7 +3733,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.2";
+var version = "1.2.3";
 
 // ../tracking-core/src/phone-react.tsx
 import {