@aranova/tracking-react 0.4.2 → 0.5.0

package/dist/index.js

@@ -608,26 +608,21 @@ 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/form-start.ts
 var import_zod3 = require("zod");
-var formSubmitMetadataSchema = import_zod3.z.object({
+var formStartMetadataSchema = import_zod3.z.object({
   form: import_zod3.z.object({
     id: import_zod3.z.string(),
     action: import_zod3.z.string().nullable()
@@ -636,32 +631,106 @@ var formSubmitMetadataSchema = import_zod3.z.object({
     path: import_zod3.z.string()
   })
 }).strict();
-var formSubmitConfigSchema = import_zod3.z.object({}).strict();
+var formStartConfigSchema = import_zod3.z.object({
+  selector: import_zod3.z.string().optional()
+}).strict();
 
-// ../tracking-core/src/events/phone-click.ts
+// ../tracking-core/src/events/form-submit.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 formSubmitMetadataSchema = import_zod4.z.object({
+  form: import_zod4.z.object({
+    id: import_zod4.z.string(),
+    action: import_zod4.z.string().nullable(),
+    fields: import_zod4.z.array(
+      import_zod4.z.object({
+        name: import_zod4.z.string(),
+        type: import_zod4.z.string(),
+        label: import_zod4.z.string().nullable(),
+        has_value: import_zod4.z.boolean()
+      })
+    ).optional()
   }),
   page: import_zod4.z.object({
     path: import_zod4.z.string()
   })
 }).strict();
-var phoneClickConfigSchema = import_zod4.z.object({}).strict();
+var formSubmitConfigSchema = import_zod4.z.object({}).strict();
 
-// ../tracking-core/src/events/time-on-site.ts
+// ../tracking-core/src/events/multi-page-session.ts
 var import_zod5 = require("zod");
-var timeOnSiteMetadataSchema = import_zod5.z.object({
-  duration_ms: import_zod5.z.number().int().nonnegative(),
+var multiPageSessionMetadataSchema = import_zod5.z.object({
+  page_count: import_zod5.z.number().int().min(2),
   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 multiPageSessionConfigSchema = import_zod5.z.object({
+  pageThreshold: import_zod5.z.number().int().min(2)
+}).strict();
+
+// ../tracking-core/src/events/phone-click.ts
+var import_zod6 = require("zod");
+var phoneClickMetadataSchema = import_zod6.z.object({
+  phone_number: import_zod6.z.string(),
+  page: import_zod6.z.object({
+    path: import_zod6.z.string()
+  }),
+  section: import_zod6.z.string().nullable().optional()
+}).strict();
+var phoneClickConfigSchema = import_zod6.z.object({}).strict();
+
+// ../tracking-core/src/events/scroll-depth.ts
+var import_zod7 = require("zod");
+var scrollDepthMetadataSchema = import_zod7.z.object({
+  depth_percent: import_zod7.z.number().int().min(1).max(100),
+  page: import_zod7.z.object({
+    path: import_zod7.z.string()
+  })
+}).strict();
+var scrollDepthConfigSchema = import_zod7.z.object({
+  thresholds: import_zod7.z.array(import_zod7.z.number().int().min(1).max(100)).min(1)
+}).strict();
+
+// ../tracking-core/src/events/specific-page-visit.ts
+var import_zod8 = 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_zod8.z.enum(SPECIFIC_PAGE_NAMES);
+var specificPageVisitMetadataSchema = import_zod8.z.object({
+  page_name: specificPageNameSchema,
+  page: import_zod8.z.object({
+    path: import_zod8.z.string()
+  })
+}).strict();
+var specificPageVisitConfigSchema = import_zod8.z.object({
+  pages: import_zod8.z.array(
+    import_zod8.z.object({
+      name: specificPageNameSchema,
+      pathPattern: import_zod8.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_zod9 = require("zod");
+var timeOnSiteMetadataSchema = import_zod9.z.object({
+  duration_ms: import_zod9.z.number().int().nonnegative(),
+  page: import_zod9.z.object({
+    path: import_zod9.z.string()
+  })
+}).strict();
+var timeOnSiteConfigSchema = import_zod9.z.object({
+  thresholdSeconds: import_zod9.z.number().int().positive()
 }).strict();
 
 // ../tracking-core/src/events/registry.ts
@@ -677,10 +746,25 @@ 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: contactPageVisitMetadataSchema,
-    configSchema: contactPageVisitConfigSchema
+    metadataSchema: formStartMetadataSchema,
+    configSchema: formStartConfigSchema
   },
   // --- manual triggers ---
   form_submit: {
@@ -692,6 +776,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 +871,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();
+    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 +1079,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 +1233,7 @@ function useConsentState() {
 var import_react4 = require("react");
 
 // package.json
-var version = "0.4.2";
+var version = "0.5.0";
 
 // src/factory.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
@@ -974,9 +1295,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--) {