@aranova/tracking-react 0.4.2 → 0.5.1

package/dist/index.js

@@ -267,7 +267,7 @@ function getVisitorId() {
 }
 function getOrRotateSessionId(now = Date.now()) {
   if (typeof window === "undefined")
-    return safeUuid();
+    return { id: safeUuid(), isNew: true };
   const raw = readLocalStorage(SESSION_STORAGE_KEY);
   if (raw) {
     try {
@@ -276,7 +276,7 @@ function getOrRotateSessionId(now = Date.now()) {
         if (now - parsed.last_event_at <= SESSION_IDLE_MS) {
           const refreshed = { id: parsed.id, last_event_at: now };
           writeLocalStorage(SESSION_STORAGE_KEY, JSON.stringify(refreshed));
-          return parsed.id;
+          return { id: parsed.id, isNew: false };
         }
       }
     } catch {
@@ -284,7 +284,7 @@ function getOrRotateSessionId(now = Date.now()) {
   }
   const fresh = { id: safeUuid(), last_event_at: now };
   writeLocalStorage(SESSION_STORAGE_KEY, JSON.stringify(fresh));
-  return fresh.id;
+  return { id: fresh.id, isNew: true };
 }
 
 // ../tracking-core/src/events/page-view.ts
@@ -424,6 +424,56 @@ function attachAutoPageView(client, options = {}) {
   };
 }
 
+// ../tracking-core/src/heartbeat.ts
+function serializeValue(value) {
+  if (value instanceof RegExp) return value.source;
+  if (Array.isArray(value)) return value.map(serializeValue);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = serializeValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+function buildHeartbeatMetadata(surface, sdkVersion, packageName, triggers) {
+  const automaticNames = triggers ? Object.keys(triggers.automatic) : [];
+  const manualNames = triggers?.manual ? Object.keys(triggers.manual) : [];
+  let triggerConfig = null;
+  if (triggers) {
+    const cfg = {};
+    for (const [name, config] of Object.entries(triggers.automatic)) {
+      const serialized = serializeValue(config);
+      if (Object.keys(serialized).length > 0) {
+        cfg[name] = serialized;
+      }
+    }
+    if (triggers.manual) {
+      for (const [name, config] of Object.entries(triggers.manual)) {
+        if (config === void 0) continue;
+        const serialized = serializeValue(config);
+        if (Object.keys(serialized).length > 0) {
+          cfg[name] = serialized;
+        }
+      }
+    }
+    if (Object.keys(cfg).length > 0) {
+      triggerConfig = cfg;
+    }
+  }
+  return {
+    sdk_version: sdkVersion ?? "unknown",
+    package_name: packageName,
+    surface,
+    triggers: {
+      automatic: automaticNames,
+      manual: manualNames
+    },
+    trigger_config: triggerConfig
+  };
+}
+
 // ../tracking-core/src/ingest.ts
 var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
 var DEFAULT_MAX_QUEUE_SIZE = 10;
@@ -503,11 +553,33 @@ function createTrackingClient(config) {
   let firstPage = null;
   let destroyed = false;
   const visitorId = getVisitorId();
-  let sessionId = getOrRotateSessionId();
+  const initialSession = getOrRotateSessionId();
+  let sessionId = initialSession.id;
   if (typeof window !== "undefined")
     firstPage = window.location.href;
+  function enqueueHeartbeat() {
+    const metadata = buildHeartbeatMetadata(
+      config.surface,
+      sdkVersion,
+      packageName,
+      config.triggers ?? null
+    );
+    queue.push({
+      event_type: "sdk_heartbeat",
+      page_url: typeof window === "undefined" ? null : window.location.href,
+      metadata,
+      occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (initialSession.isNew) {
+    enqueueHeartbeat();
+  }
   function buildSessionPayload() {
-    sessionId = getOrRotateSessionId();
+    const rotated = getOrRotateSessionId();
+    if (rotated.isNew && rotated.id !== sessionId) {
+      enqueueHeartbeat();
+    }
+    sessionId = rotated.id;
     const params = readTrackingParams();
     const context = buildContext(config.surface, sdkVersion, packageName);
     return {
@@ -608,60 +680,144 @@ function createTrackingClient(config) {
   };
 }
 
-// ../tracking-core/src/events/contact-page-visit.ts
+// ../tracking-core/src/events/cta-click.ts
 var import_zod2 = require("zod");
-var contactPageVisitMetadataSchema = import_zod2.z.object({
+var ctaClickMetadataSchema = import_zod2.z.object({
+  cta_name: import_zod2.z.string(),
   page: import_zod2.z.object({
     path: import_zod2.z.string()
-  })
-}).strict();
-var contactPageVisitConfigSchema = import_zod2.z.object({
-  // RegExp is runtime-only so we wrap it via z.custom. Consumers pass a
-  // real regex at createTracking() time; the factory validates with this
-  // schema and then keeps the live RegExp reference for runtime matching.
-  pathPattern: import_zod2.z.custom(
-    (value) => value instanceof RegExp,
-    { message: "pathPattern must be a RegExp" }
-  )
+  }),
+  section: import_zod2.z.string().nullable().optional(),
+  destination_url: import_zod2.z.string().nullable().optional()
 }).strict();
+var ctaClickConfigSchema = import_zod2.z.object({}).strict();
 
-// ../tracking-core/src/events/form-submit.ts
+// ../tracking-core/src/events/sdk-heartbeat.ts
 var import_zod3 = require("zod");
-var formSubmitMetadataSchema = import_zod3.z.object({
-  form: import_zod3.z.object({
-    id: import_zod3.z.string(),
-    action: import_zod3.z.string().nullable()
-  }),
-  page: import_zod3.z.object({
-    path: import_zod3.z.string()
-  })
+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"]),
+  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()
 }).strict();
-var formSubmitConfigSchema = import_zod3.z.object({}).strict();
+var sdkHeartbeatConfigSchema = import_zod3.z.object({}).strict();
 
-// ../tracking-core/src/events/phone-click.ts
+// ../tracking-core/src/events/form-start.ts
 var import_zod4 = require("zod");
-var phoneClickMetadataSchema = import_zod4.z.object({
-  element: import_zod4.z.object({
-    tag: import_zod4.z.string(),
-    text: import_zod4.z.string().nullable(),
-    href: import_zod4.z.string()
+var formStartMetadataSchema = import_zod4.z.object({
+  form: import_zod4.z.object({
+    id: import_zod4.z.string(),
+    action: import_zod4.z.string().nullable()
   }),
   page: import_zod4.z.object({
     path: import_zod4.z.string()
   })
 }).strict();
-var phoneClickConfigSchema = import_zod4.z.object({}).strict();
+var formStartConfigSchema = import_zod4.z.object({
+  selector: import_zod4.z.string().optional()
+}).strict();
 
-// ../tracking-core/src/events/time-on-site.ts
+// ../tracking-core/src/events/form-submit.ts
 var import_zod5 = require("zod");
-var timeOnSiteMetadataSchema = import_zod5.z.object({
-  duration_ms: import_zod5.z.number().int().nonnegative(),
+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(),
+        has_value: import_zod5.z.boolean()
+      })
+    ).optional()
+  }),
   page: import_zod5.z.object({
     path: import_zod5.z.string()
   })
 }).strict();
-var timeOnSiteConfigSchema = import_zod5.z.object({
-  thresholdSeconds: import_zod5.z.number().int().positive()
+var formSubmitConfigSchema = import_zod5.z.object({}).strict();
+
+// ../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();
+var multiPageSessionConfigSchema = import_zod6.z.object({
+  pageThreshold: import_zod6.z.number().int().min(2)
+}).strict();
+
+// ../tracking-core/src/events/phone-click.ts
+var import_zod7 = require("zod");
+var phoneClickMetadataSchema = import_zod7.z.object({
+  phone_number: import_zod7.z.string(),
+  page: import_zod7.z.object({
+    path: import_zod7.z.string()
+  }),
+  section: import_zod7.z.string().nullable().optional()
+}).strict();
+var phoneClickConfigSchema = import_zod7.z.object({}).strict();
+
+// ../tracking-core/src/events/scroll-depth.ts
+var import_zod8 = require("zod");
+var scrollDepthMetadataSchema = import_zod8.z.object({
+  depth_percent: import_zod8.z.number().int().min(1).max(100),
+  page: import_zod8.z.object({
+    path: import_zod8.z.string()
+  })
+}).strict();
+var scrollDepthConfigSchema = import_zod8.z.object({
+  thresholds: import_zod8.z.array(import_zod8.z.number().int().min(1).max(100)).min(1)
+}).strict();
+
+// ../tracking-core/src/events/specific-page-visit.ts
+var import_zod9 = require("zod");
+var SPECIFIC_PAGE_NAMES = [
+  "contact_page",
+  "about_page",
+  "services_page",
+  "booking_page",
+  "location_page",
+  "pricing_page",
+  "faq_page",
+  "testimonials_page"
+];
+var specificPageNameSchema = import_zod9.z.enum(SPECIFIC_PAGE_NAMES);
+var specificPageVisitMetadataSchema = import_zod9.z.object({
+  page_name: specificPageNameSchema,
+  page: import_zod9.z.object({
+    path: import_zod9.z.string()
+  })
+}).strict();
+var specificPageVisitConfigSchema = import_zod9.z.object({
+  pages: import_zod9.z.array(
+    import_zod9.z.object({
+      name: specificPageNameSchema,
+      pathPattern: import_zod9.z.custom((value) => value instanceof RegExp, {
+        message: "pathPattern must be a RegExp"
+      })
+    })
+  ).min(1)
+}).strict();
+
+// ../tracking-core/src/events/time-on-site.ts
+var import_zod10 = require("zod");
+var timeOnSiteMetadataSchema = import_zod10.z.object({
+  duration_ms: import_zod10.z.number().int().nonnegative(),
+  page: import_zod10.z.object({
+    path: import_zod10.z.string()
+  })
+}).strict();
+var timeOnSiteConfigSchema = import_zod10.z.object({
+  thresholdSeconds: import_zod10.z.number().int().positive()
 }).strict();
 
 // ../tracking-core/src/events/registry.ts
@@ -677,10 +833,31 @@ var EVENT_REGISTRY = {
     metadataSchema: timeOnSiteMetadataSchema,
     configSchema: timeOnSiteConfigSchema
   },
-  contact_page_visit: {
+  specific_page_visit: {
+    kind: "automatic",
+    metadataSchema: specificPageVisitMetadataSchema,
+    configSchema: specificPageVisitConfigSchema
+  },
+  scroll_depth: {
     kind: "automatic",
-    metadataSchema: contactPageVisitMetadataSchema,
-    configSchema: contactPageVisitConfigSchema
+    metadataSchema: scrollDepthMetadataSchema,
+    configSchema: scrollDepthConfigSchema
+  },
+  multi_page_session: {
+    kind: "automatic",
+    metadataSchema: multiPageSessionMetadataSchema,
+    configSchema: multiPageSessionConfigSchema
+  },
+  form_start: {
+    kind: "automatic",
+    metadataSchema: formStartMetadataSchema,
+    configSchema: formStartConfigSchema
+  },
+  // --- SDK-internal automatic (not consumer-configurable) ---
+  sdk_heartbeat: {
+    kind: "automatic",
+    metadataSchema: sdkHeartbeatMetadataSchema,
+    configSchema: sdkHeartbeatConfigSchema
   },
   // --- manual triggers ---
   form_submit: {
@@ -692,6 +869,11 @@ var EVENT_REGISTRY = {
     kind: "manual",
     metadataSchema: phoneClickMetadataSchema,
     configSchema: phoneClickConfigSchema
+  },
+  cta_click: {
+    kind: "manual",
+    metadataSchema: ctaClickMetadataSchema,
+    configSchema: ctaClickConfigSchema
   }
 };
 var ALL_AUTOMATIC_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "automatic").map(([name]) => name);
@@ -782,26 +964,193 @@ function attachTimeOnSite(client, config) {
   };
 }
 
-// ../tracking-core/src/triggers/contact-page-visit.ts
-function attachContactPageVisit(client, config) {
+// ../tracking-core/src/triggers/specific-page-visit.ts
+function attachSpecificPageVisit(client, config) {
   if (typeof window === "undefined" || typeof history === "undefined") {
     return () => {
     };
   }
-  const { pathPattern } = config;
-  let lastFiredPath = null;
+  const { pages } = config;
+  const firedSet = /* @__PURE__ */ new Set();
   function check() {
     const path = window.location.pathname;
-    if (!pathPattern.test(path)) return;
-    if (lastFiredPath === path) return;
-    lastFiredPath = path;
-    client.trackEvent({
-      eventType: "contact_page_visit",
-      metadata: { page: { path } },
-      pageUrl: window.location.href,
-      occurredAt: null
+    for (const { name, pathPattern } of pages) {
+      pathPattern.lastIndex = 0;
+      if (!pathPattern.test(path)) continue;
+      const key = `${name}:${path}`;
+      if (firedSet.has(key)) continue;
+      firedSet.add(key);
+      client.trackEvent({
+        eventType: "specific_page_visit",
+        metadata: { page_name: name, page: { path } },
+        pageUrl: window.location.href,
+        occurredAt: null
+      });
+    }
+  }
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  function patchedPushState(...args) {
+    originalPushState(...args);
+    setTimeout(check, 0);
+  }
+  function patchedReplaceState(...args) {
+    originalReplaceState(...args);
+    setTimeout(check, 0);
+  }
+  history.pushState = patchedPushState;
+  history.replaceState = patchedReplaceState;
+  window.addEventListener("popstate", check);
+  check();
+  return () => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", check);
+  };
+}
+
+// ../tracking-core/src/triggers/scroll-depth.ts
+function attachScrollDepth(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const thresholds = new Set(config.thresholds);
+  let firedForPath = /* @__PURE__ */ new Set();
+  let currentPath = window.location.pathname;
+  let rafId = null;
+  function getScrollPercent() {
+    const doc = document.documentElement;
+    const scrollTop = window.scrollY || doc.scrollTop;
+    const scrollHeight = doc.scrollHeight;
+    const clientHeight = doc.clientHeight;
+    if (scrollHeight <= clientHeight) return 100;
+    return Math.round((scrollTop + clientHeight) / scrollHeight * 100);
+  }
+  function checkThresholds() {
+    const percent = getScrollPercent();
+    for (const threshold of thresholds) {
+      if (percent >= threshold && !firedForPath.has(threshold)) {
+        firedForPath.add(threshold);
+        client.trackEvent({
+          eventType: "scroll_depth",
+          metadata: {
+            depth_percent: threshold,
+            page: { path: currentPath }
+          },
+          pageUrl: window.location.href,
+          occurredAt: null
+        });
+      }
+    }
+  }
+  function onScroll() {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      checkThresholds();
     });
   }
+  function resetIfPathChanged() {
+    const newPath = window.location.pathname;
+    if (newPath === currentPath) return;
+    currentPath = newPath;
+    firedForPath = /* @__PURE__ */ new Set();
+    setTimeout(checkThresholds, 0);
+  }
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  function patchedPushState(...args) {
+    originalPushState(...args);
+    setTimeout(resetIfPathChanged, 0);
+  }
+  function patchedReplaceState(...args) {
+    originalReplaceState(...args);
+    setTimeout(resetIfPathChanged, 0);
+  }
+  history.pushState = patchedPushState;
+  history.replaceState = patchedReplaceState;
+  window.addEventListener("popstate", resetIfPathChanged);
+  window.addEventListener("scroll", onScroll, { passive: true });
+  setTimeout(checkThresholds, 0);
+  return () => {
+    if (rafId !== null) cancelAnimationFrame(rafId);
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", resetIfPathChanged);
+    window.removeEventListener("scroll", onScroll);
+  };
+}
+
+// ../tracking-core/src/triggers/multi-page-session.ts
+var STORAGE_KEY = "aranova_tracking_mps_paths";
+var SESSION_KEY = "aranova_tracking_mps_session";
+var FIRED_KEY = "aranova_tracking_mps_fired";
+function getSessionStorage() {
+  try {
+    return typeof window !== "undefined" ? window.sessionStorage : null;
+  } catch {
+    return null;
+  }
+}
+function attachMultiPageSession(client, config) {
+  if (typeof window === "undefined" || typeof history === "undefined") {
+    return () => {
+    };
+  }
+  const storage = getSessionStorage();
+  if (!storage) return () => {
+  };
+  const { pageThreshold } = config;
+  let lastCheckedPath = "";
+  function getDistinctPaths() {
+    try {
+      const raw = storage.getItem(STORAGE_KEY);
+      return raw ? new Set(JSON.parse(raw)) : /* @__PURE__ */ new Set();
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  function saveDistinctPaths(paths) {
+    try {
+      storage.setItem(STORAGE_KEY, JSON.stringify([...paths]));
+    } catch {
+    }
+  }
+  function resetIfSessionChanged() {
+    const currentSession = getOrRotateSessionId().id;
+    const storedSession = storage.getItem(SESSION_KEY);
+    if (storedSession !== currentSession) {
+      storage.setItem(SESSION_KEY, currentSession);
+      storage.removeItem(STORAGE_KEY);
+      storage.removeItem(FIRED_KEY);
+    }
+  }
+  function hasFired() {
+    return storage.getItem(FIRED_KEY) === "1";
+  }
+  function check() {
+    const currentPath = window.location.pathname;
+    if (currentPath === lastCheckedPath) return;
+    lastCheckedPath = currentPath;
+    resetIfSessionChanged();
+    if (hasFired()) return;
+    const paths = getDistinctPaths();
+    paths.add(currentPath);
+    saveDistinctPaths(paths);
+    if (paths.size >= pageThreshold) {
+      storage.setItem(FIRED_KEY, "1");
+      client.trackEvent({
+        eventType: "multi_page_session",
+        metadata: {
+          page_count: paths.size,
+          page: { path: window.location.pathname }
+        },
+        pageUrl: window.location.href,
+        occurredAt: null
+      });
+    }
+  }
   const originalPushState = history.pushState.bind(history);
   const originalReplaceState = history.replaceState.bind(history);
   function patchedPushState(...args) {
@@ -823,6 +1172,71 @@ function attachContactPageVisit(client, config) {
   };
 }
 
+// ../tracking-core/src/triggers/form-start.ts
+function attachFormStart(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const selector = config.selector ?? "form";
+  let firedForms = /* @__PURE__ */ new Set();
+  let currentPath = window.location.pathname;
+  function getFormKey(form) {
+    if (form.id) return `id:${form.id}`;
+    const explicitAction = form.getAttribute("action");
+    if (explicitAction) return `action:${explicitAction}`;
+    const forms = Array.from(document.querySelectorAll(selector));
+    return `index:${forms.indexOf(form)}`;
+  }
+  function onFocusIn(event) {
+    const target = event.target;
+    if (!(target instanceof HTMLElement)) return;
+    const form = target.closest(selector);
+    if (!form || form.tagName !== "FORM") return;
+    const key = getFormKey(form);
+    if (firedForms.has(key)) return;
+    firedForms.add(key);
+    client.trackEvent({
+      eventType: "form_start",
+      metadata: {
+        form: {
+          id: form.id || "",
+          action: form.getAttribute("action") ?? null
+        },
+        page: { path: window.location.pathname }
+      },
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+  }
+  function resetIfPathChanged() {
+    const newPath = window.location.pathname;
+    if (newPath === currentPath) return;
+    currentPath = newPath;
+    firedForms = /* @__PURE__ */ new Set();
+  }
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  function patchedPushState(...args) {
+    originalPushState(...args);
+    setTimeout(resetIfPathChanged, 0);
+  }
+  function patchedReplaceState(...args) {
+    originalReplaceState(...args);
+    setTimeout(resetIfPathChanged, 0);
+  }
+  history.pushState = patchedPushState;
+  history.replaceState = patchedReplaceState;
+  window.addEventListener("popstate", resetIfPathChanged);
+  document.addEventListener("focusin", onFocusIn);
+  return () => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", resetIfPathChanged);
+    document.removeEventListener("focusin", onFocusIn);
+  };
+}
+
 // src/ConsentBanner.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function ConsentBanner() {
@@ -912,7 +1326,7 @@ function useConsentState() {
 var import_react4 = require("react");
 
 // package.json
-var version = "0.4.2";
+var version = "0.5.1";
 
 // src/factory.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
@@ -948,6 +1362,7 @@ function createTracking(options) {
           surface: "react",
           packageName: "@aranova/tracking-react",
           sdkVersion: version,
+          triggers,
           debug
         }),
         triggers,
@@ -966,6 +1381,7 @@ function createTracking(options) {
         endpoint,
         surface: "react",
         packageName: "@aranova/tracking-react",
+        triggers,
         debug
       });
       detachers.push(attachAutoPageView(rawClient));
@@ -974,9 +1390,21 @@ function createTracking(options) {
       if (timeOnSite) {
         detachers.push(attachTimeOnSite(rawClient, timeOnSite));
       }
-      const contactPageVisit = triggers.automatic.contact_page_visit;
-      if (contactPageVisit) {
-        detachers.push(attachContactPageVisit(rawClient, contactPageVisit));
+      const specificPageVisit = triggers.automatic.specific_page_visit;
+      if (specificPageVisit) {
+        detachers.push(attachSpecificPageVisit(rawClient, specificPageVisit));
+      }
+      const scrollDepth = triggers.automatic.scroll_depth;
+      if (scrollDepth) {
+        detachers.push(attachScrollDepth(rawClient, scrollDepth));
+      }
+      const multiPageSession = triggers.automatic.multi_page_session;
+      if (multiPageSession) {
+        detachers.push(attachMultiPageSession(rawClient, multiPageSession));
+      }
+      const formStart = triggers.automatic.form_start;
+      if (formStart) {
+        detachers.push(attachFormStart(rawClient, formStart));
       }
       return () => {
         for (let i = detachers.length - 1; i >= 0; i--) {