@aranova/tracking-next 0.4.1 → 0.5.0

package/dist/index.js

@@ -555,26 +555,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()
@@ -583,32 +578,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
@@ -624,10 +693,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: {
@@ -639,6 +723,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);
@@ -729,6 +818,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
 var import_react = require("react");
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -826,6 +1053,11 @@ function GoogleAdsTracking({ gtagId }) {
 
 // src/factory.tsx
 var import_navigation = require("next/navigation");
+
+// package.json
+var version = "0.5.0";
+
+// src/factory.tsx
 var import_react3 = require("react");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 function createTracking(options) {
@@ -850,7 +1082,7 @@ function createTracking(options) {
     };
   }
   const TrackingContext = (0, import_react3.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 = (0, import_navigation.usePathname)();
@@ -862,6 +1094,7 @@ function createTracking(options) {
           endpoint,
           surface: "next",
           packageName: "@aranova/tracking-next",
+          sdkVersion: version,
           debug
         }),
         triggers,
@@ -879,12 +1112,9 @@ function createTracking(options) {
       });
       fireManualPageView(rawClient);
     }, [pathname, searchParams]);
-    const lastContactPathRef = (0, import_react3.useRef)(null);
+    const firedPagesRef = (0, import_react3.useRef)(/* @__PURE__ */ new Set());
     (0, import_react3.useEffect)(() => {
-      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,
@@ -892,12 +1122,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]);
     (0, import_react3.useEffect)(() => {
       const rawClient = getOrCreateTrackingClient({
@@ -920,6 +1156,74 @@ function createTracking(options) {
       });
       return attachTimeOnSite(rawClient, timeOnSiteConfig);
     }, []);
+    const multiPageSessionConfig = triggers.automatic.multi_page_session ?? null;
+    const mpsLastPathRef = (0, import_react3.useRef)(null);
+    (0, import_react3.useEffect)(() => {
+      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]);
+    (0, import_react3.useEffect)(() => {
+      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__ */ (0, import_jsx_runtime3.jsx)(TrackingContext.Provider, { value: client, children });
   }
   function useTracking() {