@aranova/tracking-next 0.4.1 → 0.5.0

package/dist/index.mjs

@@ -507,26 +507,21 @@ 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/form-start.ts
 import { z as z3 } from "zod";
-var formSubmitMetadataSchema = z3.object({
+var formStartMetadataSchema = z3.object({
   form: z3.object({
     id: z3.string(),
     action: z3.string().nullable()
@@ -535,32 +530,106 @@ var formSubmitMetadataSchema = z3.object({
     path: z3.string()
   })
 }).strict();
-var formSubmitConfigSchema = z3.object({}).strict();
+var formStartConfigSchema = z3.object({
+  selector: z3.string().optional()
+}).strict();
 
-// ../tracking-core/src/events/phone-click.ts
+// ../tracking-core/src/events/form-submit.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 formSubmitMetadataSchema = z4.object({
+  form: z4.object({
+    id: z4.string(),
+    action: z4.string().nullable(),
+    fields: z4.array(
+      z4.object({
+        name: z4.string(),
+        type: z4.string(),
+        label: z4.string().nullable(),
+        has_value: z4.boolean()
+      })
+    ).optional()
   }),
   page: z4.object({
     path: z4.string()
   })
 }).strict();
-var phoneClickConfigSchema = z4.object({}).strict();
+var formSubmitConfigSchema = z4.object({}).strict();
 
-// ../tracking-core/src/events/time-on-site.ts
+// ../tracking-core/src/events/multi-page-session.ts
 import { z as z5 } from "zod";
-var timeOnSiteMetadataSchema = z5.object({
-  duration_ms: z5.number().int().nonnegative(),
+var multiPageSessionMetadataSchema = z5.object({
+  page_count: z5.number().int().min(2),
   page: z5.object({
     path: z5.string()
   })
 }).strict();
-var timeOnSiteConfigSchema = z5.object({
-  thresholdSeconds: z5.number().int().positive()
+var multiPageSessionConfigSchema = z5.object({
+  pageThreshold: z5.number().int().min(2)
+}).strict();
+
+// ../tracking-core/src/events/phone-click.ts
+import { z as z6 } from "zod";
+var phoneClickMetadataSchema = z6.object({
+  phone_number: z6.string(),
+  page: z6.object({
+    path: z6.string()
+  }),
+  section: z6.string().nullable().optional()
+}).strict();
+var phoneClickConfigSchema = z6.object({}).strict();
+
+// ../tracking-core/src/events/scroll-depth.ts
+import { z as z7 } from "zod";
+var scrollDepthMetadataSchema = z7.object({
+  depth_percent: z7.number().int().min(1).max(100),
+  page: z7.object({
+    path: z7.string()
+  })
+}).strict();
+var scrollDepthConfigSchema = z7.object({
+  thresholds: z7.array(z7.number().int().min(1).max(100)).min(1)
+}).strict();
+
+// ../tracking-core/src/events/specific-page-visit.ts
+import { z as z8 } from "zod";
+var SPECIFIC_PAGE_NAMES = [
+  "contact_page",
+  "about_page",
+  "services_page",
+  "booking_page",
+  "location_page",
+  "pricing_page",
+  "faq_page",
+  "testimonials_page"
+];
+var specificPageNameSchema = z8.enum(SPECIFIC_PAGE_NAMES);
+var specificPageVisitMetadataSchema = z8.object({
+  page_name: specificPageNameSchema,
+  page: z8.object({
+    path: z8.string()
+  })
+}).strict();
+var specificPageVisitConfigSchema = z8.object({
+  pages: z8.array(
+    z8.object({
+      name: specificPageNameSchema,
+      pathPattern: z8.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 z9 } from "zod";
+var timeOnSiteMetadataSchema = z9.object({
+  duration_ms: z9.number().int().nonnegative(),
+  page: z9.object({
+    path: z9.string()
+  })
+}).strict();
+var timeOnSiteConfigSchema = z9.object({
+  thresholdSeconds: z9.number().int().positive()
 }).strict();
 
 // ../tracking-core/src/events/registry.ts
@@ -576,10 +645,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: contactPageVisitMetadataSchema,
-    configSchema: contactPageVisitConfigSchema
+    metadataSchema: multiPageSessionMetadataSchema,
+    configSchema: multiPageSessionConfigSchema
+  },
+  form_start: {
+    kind: "automatic",
+    metadataSchema: formStartMetadataSchema,
+    configSchema: formStartConfigSchema
   },
   // --- manual triggers ---
   form_submit: {
@@ -591,6 +675,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 +770,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";
@@ -778,6 +1005,11 @@ function GoogleAdsTracking({ gtagId }) {
 
 // src/factory.tsx
 import { usePathname, useSearchParams } from "next/navigation";
+
+// package.json
+var version = "0.5.0";
+
+// src/factory.tsx
 import {
   createContext,
   useContext,
@@ -808,7 +1040,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();
@@ -820,6 +1052,7 @@ function createTracking(options) {
           endpoint,
           surface: "next",
           packageName: "@aranova/tracking-next",
+          sdkVersion: version,
           debug
         }),
         triggers,
@@ -837,12 +1070,9 @@ function createTracking(options) {
       });
       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,
@@ -850,12 +1080,18 @@ function createTracking(options) {
         packageName: "@aranova/tracking-next",
         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({
@@ -878,6 +1114,74 @@ function createTracking(options) {
       });
       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();
+        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",
+            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",
+        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() {