@aranova/tracking-next 0.4.2 → 0.5.1

package/dist/index.mjs

@@ -206,7 +206,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 {
@@ -215,7 +215,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 {
@@ -223,7 +223,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
@@ -323,6 +323,56 @@ function attachBfcacheRestore(client) {
   };
 }
 
+// ../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;
@@ -402,11 +452,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 {
@@ -507,60 +579,144 @@ function createTrackingClient(config) {
   };
 }
 
-// ../tracking-core/src/events/contact-page-visit.ts
+// ../tracking-core/src/events/cta-click.ts
 import { z as z2 } from "zod";
-var contactPageVisitMetadataSchema = z2.object({
+var ctaClickMetadataSchema = z2.object({
+  cta_name: z2.string(),
   page: z2.object({
     path: z2.string()
-  })
-}).strict();
-var contactPageVisitConfigSchema = z2.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: z2.custom(
-    (value) => value instanceof RegExp,
-    { message: "pathPattern must be a RegExp" }
-  )
+  }),
+  section: z2.string().nullable().optional(),
+  destination_url: z2.string().nullable().optional()
 }).strict();
+var ctaClickConfigSchema = z2.object({}).strict();
 
-// ../tracking-core/src/events/form-submit.ts
+// ../tracking-core/src/events/sdk-heartbeat.ts
 import { z as z3 } from "zod";
-var formSubmitMetadataSchema = z3.object({
-  form: z3.object({
-    id: z3.string(),
-    action: z3.string().nullable()
-  }),
-  page: z3.object({
-    path: z3.string()
-  })
+var sdkHeartbeatTriggersSchema = z3.object({
+  automatic: z3.array(z3.string()),
+  manual: z3.array(z3.string())
 }).strict();
-var formSubmitConfigSchema = z3.object({}).strict();
+var sdkHeartbeatMetadataSchema = z3.object({
+  sdk_version: z3.string(),
+  package_name: z3.string().nullable(),
+  surface: z3.enum(["next", "react", "script"]),
+  triggers: sdkHeartbeatTriggersSchema,
+  trigger_config: z3.record(z3.string(), z3.record(z3.string(), z3.unknown())).nullable().optional()
+}).strict();
+var sdkHeartbeatConfigSchema = z3.object({}).strict();
 
-// ../tracking-core/src/events/phone-click.ts
+// ../tracking-core/src/events/form-start.ts
 import { z as z4 } from "zod";
-var phoneClickMetadataSchema = z4.object({
-  element: z4.object({
-    tag: z4.string(),
-    text: z4.string().nullable(),
-    href: z4.string()
+var formStartMetadataSchema = z4.object({
+  form: z4.object({
+    id: z4.string(),
+    action: z4.string().nullable()
   }),
   page: z4.object({
     path: z4.string()
   })
 }).strict();
-var phoneClickConfigSchema = z4.object({}).strict();
+var formStartConfigSchema = z4.object({
+  selector: z4.string().optional()
+}).strict();
 
-// ../tracking-core/src/events/time-on-site.ts
+// ../tracking-core/src/events/form-submit.ts
 import { z as z5 } from "zod";
-var timeOnSiteMetadataSchema = z5.object({
-  duration_ms: z5.number().int().nonnegative(),
+var formSubmitMetadataSchema = z5.object({
+  form: z5.object({
+    id: z5.string(),
+    action: z5.string().nullable(),
+    fields: z5.array(
+      z5.object({
+        name: z5.string(),
+        type: z5.string(),
+        label: z5.string().nullable(),
+        has_value: z5.boolean()
+      })
+    ).optional()
+  }),
   page: z5.object({
     path: z5.string()
   })
 }).strict();
-var timeOnSiteConfigSchema = z5.object({
-  thresholdSeconds: z5.number().int().positive()
+var formSubmitConfigSchema = z5.object({}).strict();
+
+// ../tracking-core/src/events/multi-page-session.ts
+import { z as z6 } from "zod";
+var multiPageSessionMetadataSchema = z6.object({
+  page_count: z6.number().int().min(2),
+  page: z6.object({
+    path: z6.string()
+  })
+}).strict();
+var multiPageSessionConfigSchema = z6.object({
+  pageThreshold: z6.number().int().min(2)
+}).strict();
+
+// ../tracking-core/src/events/phone-click.ts
+import { z as z7 } from "zod";
+var phoneClickMetadataSchema = z7.object({
+  phone_number: z7.string(),
+  page: z7.object({
+    path: z7.string()
+  }),
+  section: z7.string().nullable().optional()
+}).strict();
+var phoneClickConfigSchema = z7.object({}).strict();
+
+// ../tracking-core/src/events/scroll-depth.ts
+import { z as z8 } from "zod";
+var scrollDepthMetadataSchema = z8.object({
+  depth_percent: z8.number().int().min(1).max(100),
+  page: z8.object({
+    path: z8.string()
+  })
+}).strict();
+var scrollDepthConfigSchema = z8.object({
+  thresholds: z8.array(z8.number().int().min(1).max(100)).min(1)
+}).strict();
+
+// ../tracking-core/src/events/specific-page-visit.ts
+import { z as z9 } from "zod";
+var SPECIFIC_PAGE_NAMES = [
+  "contact_page",
+  "about_page",
+  "services_page",
+  "booking_page",
+  "location_page",
+  "pricing_page",
+  "faq_page",
+  "testimonials_page"
+];
+var specificPageNameSchema = z9.enum(SPECIFIC_PAGE_NAMES);
+var specificPageVisitMetadataSchema = z9.object({
+  page_name: specificPageNameSchema,
+  page: z9.object({
+    path: z9.string()
+  })
+}).strict();
+var specificPageVisitConfigSchema = z9.object({
+  pages: z9.array(
+    z9.object({
+      name: specificPageNameSchema,
+      pathPattern: z9.custom((value) => value instanceof RegExp, {
+        message: "pathPattern must be a RegExp"
+      })
+    })
+  ).min(1)
+}).strict();
+
+// ../tracking-core/src/events/time-on-site.ts
+import { z as z10 } from "zod";
+var timeOnSiteMetadataSchema = z10.object({
+  duration_ms: z10.number().int().nonnegative(),
+  page: z10.object({
+    path: z10.string()
+  })
+}).strict();
+var timeOnSiteConfigSchema = z10.object({
+  thresholdSeconds: z10.number().int().positive()
 }).strict();
 
 // ../tracking-core/src/events/registry.ts
@@ -576,10 +732,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: 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: contactPageVisitMetadataSchema,
-    configSchema: contactPageVisitConfigSchema
+    metadataSchema: sdkHeartbeatMetadataSchema,
+    configSchema: sdkHeartbeatConfigSchema
   },
   // --- manual triggers ---
   form_submit: {
@@ -591,6 +768,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);
@@ -681,6 +863,144 @@ function attachTimeOnSite(client, config) {
   };
 }
 
+// ../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/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
 import { useEffect, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -780,7 +1100,7 @@ function GoogleAdsTracking({ gtagId }) {
 import { usePathname, useSearchParams } from "next/navigation";
 
 // package.json
-var version = "0.4.2";
+var version = "0.5.1";
 
 // src/factory.tsx
 import {
@@ -813,7 +1133,7 @@ function createTracking(options) {
     };
   }
   const TrackingContext = createContext(null);
-  const contactPageVisitConfig = triggers.automatic.contact_page_visit ?? null;
+  const specificPageVisitConfig = triggers.automatic.specific_page_visit ?? null;
   const timeOnSiteConfig = triggers.automatic.time_on_site ?? null;
   function TrackingProvider({ children }) {
     const pathname = usePathname();
@@ -826,6 +1146,7 @@ function createTracking(options) {
           surface: "next",
           packageName: "@aranova/tracking-next",
           sdkVersion: version,
+          triggers,
           debug
         }),
         triggers,
@@ -839,29 +1160,34 @@ function createTracking(options) {
         endpoint,
         surface: "next",
         packageName: "@aranova/tracking-next",
+        triggers,
         debug
       });
       fireManualPageView(rawClient);
     }, [pathname, searchParams]);
-    const lastContactPathRef = useRef(null);
+    const firedPagesRef = useRef(/* @__PURE__ */ new Set());
     useEffect3(() => {
-      if (!contactPageVisitConfig || pathname === null) return;
-      if (!contactPageVisitConfig.pathPattern.test(pathname)) return;
-      if (lastContactPathRef.current === pathname) return;
-      lastContactPathRef.current = pathname;
+      if (!specificPageVisitConfig || pathname === null) return;
       const rawClient = getOrCreateTrackingClient({
         apiKey,
         endpoint,
         surface: "next",
         packageName: "@aranova/tracking-next",
+        triggers,
         debug
       });
-      rawClient.trackEvent({
-        eventType: "contact_page_visit",
-        metadata: { page: { path: pathname } },
-        pageUrl: null,
-        occurredAt: null
-      });
+      for (const { name, pathPattern } of specificPageVisitConfig.pages) {
+        if (!pathPattern.test(pathname)) continue;
+        const key = `${name}:${pathname}`;
+        if (firedPagesRef.current.has(key)) continue;
+        firedPagesRef.current.add(key);
+        rawClient.trackEvent({
+          eventType: "specific_page_visit",
+          metadata: { page_name: name, page: { path: pathname } },
+          pageUrl: null,
+          occurredAt: null
+        });
+      }
     }, [pathname]);
     useEffect3(() => {
       const rawClient = getOrCreateTrackingClient({
@@ -869,6 +1195,7 @@ function createTracking(options) {
         endpoint,
         surface: "next",
         packageName: "@aranova/tracking-next",
+        triggers,
         debug
       });
       return attachBfcacheRestore(rawClient);
@@ -880,10 +1207,81 @@ function createTracking(options) {
         endpoint,
         surface: "next",
         packageName: "@aranova/tracking-next",
+        triggers,
         debug
       });
       return attachTimeOnSite(rawClient, timeOnSiteConfig);
     }, []);
+    const multiPageSessionConfig = triggers.automatic.multi_page_session ?? null;
+    const mpsLastPathRef = useRef(null);
+    useEffect3(() => {
+      if (!multiPageSessionConfig || pathname === null) return;
+      if (pathname === mpsLastPathRef.current) return;
+      mpsLastPathRef.current = pathname;
+      const MPS_PATHS_KEY = "aranova_tracking_mps_paths";
+      const MPS_SESSION_KEY = "aranova_tracking_mps_session";
+      const MPS_FIRED_KEY = "aranova_tracking_mps_fired";
+      try {
+        const store = window.sessionStorage;
+        const currentSession = getOrRotateSessionId().id;
+        const storedSession = store.getItem(MPS_SESSION_KEY);
+        if (storedSession !== currentSession) {
+          store.setItem(MPS_SESSION_KEY, currentSession);
+          store.removeItem(MPS_PATHS_KEY);
+          store.removeItem(MPS_FIRED_KEY);
+        }
+        if (store.getItem(MPS_FIRED_KEY) === "1") return;
+        const raw = store.getItem(MPS_PATHS_KEY);
+        const paths = raw ? new Set(JSON.parse(raw)) : /* @__PURE__ */ new Set();
+        paths.add(pathname);
+        store.setItem(MPS_PATHS_KEY, JSON.stringify([...paths]));
+        if (paths.size >= multiPageSessionConfig.pageThreshold) {
+          store.setItem(MPS_FIRED_KEY, "1");
+          const rawClient = getOrCreateTrackingClient({
+            apiKey,
+            endpoint,
+            surface: "next",
+            packageName: "@aranova/tracking-next",
+            triggers,
+            debug
+          });
+          rawClient.trackEvent({
+            eventType: "multi_page_session",
+            metadata: {
+              page_count: paths.size,
+              page: { path: pathname }
+            },
+            pageUrl: null,
+            occurredAt: null
+          });
+        }
+      } catch {
+      }
+    }, [pathname]);
+    useEffect3(() => {
+      const detachers = [];
+      const rawClient = getOrCreateTrackingClient({
+        apiKey,
+        endpoint,
+        surface: "next",
+        packageName: "@aranova/tracking-next",
+        triggers,
+        debug
+      });
+      const scrollDepth = triggers.automatic.scroll_depth;
+      if (scrollDepth) {
+        detachers.push(attachScrollDepth(rawClient, scrollDepth));
+      }
+      const formStart = triggers.automatic.form_start;
+      if (formStart) {
+        detachers.push(attachFormStart(rawClient, formStart));
+      }
+      return () => {
+        for (let i = detachers.length - 1; i >= 0; i--) {
+          detachers[i]();
+        }
+      };
+    }, []);
     return /* @__PURE__ */ jsx3(TrackingContext.Provider, { value: client, children });
   }
   function useTracking() {