@aranova/tracking-react 0.5.0 → 0.6.0

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
@@ -295,7 +295,7 @@ var pageViewMetadataSchema = import_zod.z.object({
     path: import_zod.z.string(),
     search: import_zod.z.string(),
     hash: import_zod.z.string()
-  }),
+  }).strict(),
   referrer: import_zod.z.string().nullable(),
   // `.nullable().optional()` — absent (undefined) OR explicit null OR a
   // real viewport object. Mirrors Pydantic's `_Viewport | None = None`
@@ -303,7 +303,7 @@ var pageViewMetadataSchema = import_zod.z.object({
   viewport: import_zod.z.object({
     w: import_zod.z.number(),
     h: import_zod.z.number()
-  }).nullable().optional()
+  }).strict().nullable().optional()
 }).strict();
 var pageViewConfigSchema = import_zod.z.object({}).strict();
 
@@ -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 {
@@ -614,85 +686,110 @@ var ctaClickMetadataSchema = import_zod2.z.object({
   cta_name: import_zod2.z.string(),
   page: import_zod2.z.object({
     path: import_zod2.z.string()
-  }),
+  }).strict(),
   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-start.ts
+// ../tracking-core/src/events/sdk-heartbeat.ts
 var import_zod3 = require("zod");
-var formStartMetadataSchema = 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 formStartConfigSchema = import_zod3.z.object({
-  selector: import_zod3.z.string().optional()
+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 sdkHeartbeatConfigSchema = import_zod3.z.object({}).strict();
 
-// ../tracking-core/src/events/form-submit.ts
+// ../tracking-core/src/events/form-start.ts
 var import_zod4 = require("zod");
-var formSubmitMetadataSchema = import_zod4.z.object({
+var formStartMetadataSchema = 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()
-  }),
+    action: import_zod4.z.string().nullable()
+  }).strict(),
   page: import_zod4.z.object({
     path: import_zod4.z.string()
-  })
+  }).strict()
+}).strict();
+var formStartConfigSchema = import_zod4.z.object({
+  selector: import_zod4.z.string().optional()
 }).strict();
-var formSubmitConfigSchema = import_zod4.z.object({}).strict();
 
-// ../tracking-core/src/events/multi-page-session.ts
+// ../tracking-core/src/events/form-submit.ts
 var import_zod5 = require("zod");
-var multiPageSessionMetadataSchema = import_zod5.z.object({
-  page_count: import_zod5.z.number().int().min(2),
+var jsonValueSchema = import_zod5.z.lazy(
+  () => import_zod5.z.union([
+    import_zod5.z.string(),
+    import_zod5.z.number().finite(),
+    import_zod5.z.boolean(),
+    import_zod5.z.null(),
+    import_zod5.z.array(jsonValueSchema),
+    import_zod5.z.record(jsonValueSchema)
+  ])
+);
+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(),
+        value: jsonValueSchema
+      }).strict()
+    ).optional()
+  }).strict(),
   page: import_zod5.z.object({
     path: import_zod5.z.string()
-  })
-}).strict();
-var multiPageSessionConfigSchema = import_zod5.z.object({
-  pageThreshold: import_zod5.z.number().int().min(2)
+  }).strict()
 }).strict();
+var formSubmitConfigSchema = import_zod5.z.object({}).strict();
 
-// ../tracking-core/src/events/phone-click.ts
+// ../tracking-core/src/events/multi-page-session.ts
 var import_zod6 = require("zod");
-var phoneClickMetadataSchema = import_zod6.z.object({
-  phone_number: import_zod6.z.string(),
+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()
-  }),
-  section: import_zod6.z.string().nullable().optional()
+  }).strict()
+}).strict();
+var multiPageSessionConfigSchema = import_zod6.z.object({
+  pageThreshold: import_zod6.z.number().int().min(2)
 }).strict();
-var phoneClickConfigSchema = import_zod6.z.object({}).strict();
 
-// ../tracking-core/src/events/scroll-depth.ts
+// ../tracking-core/src/events/phone-click.ts
 var import_zod7 = require("zod");
-var scrollDepthMetadataSchema = import_zod7.z.object({
-  depth_percent: import_zod7.z.number().int().min(1).max(100),
+var phoneClickMetadataSchema = import_zod7.z.object({
+  phone_number: import_zod7.z.string(),
   page: import_zod7.z.object({
     path: import_zod7.z.string()
-  })
+  }).strict(),
+  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()
 }).strict();
-var scrollDepthConfigSchema = import_zod7.z.object({
-  thresholds: import_zod7.z.array(import_zod7.z.number().int().min(1).max(100)).min(1)
+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_zod8 = require("zod");
+var import_zod9 = require("zod");
 var SPECIFIC_PAGE_NAMES = [
   "contact_page",
   "about_page",
@@ -703,34 +800,34 @@ var SPECIFIC_PAGE_NAMES = [
   "faq_page",
   "testimonials_page"
 ];
-var specificPageNameSchema = import_zod8.z.enum(SPECIFIC_PAGE_NAMES);
-var specificPageVisitMetadataSchema = import_zod8.z.object({
+var specificPageNameSchema = import_zod9.z.enum(SPECIFIC_PAGE_NAMES);
+var specificPageVisitMetadataSchema = import_zod9.z.object({
   page_name: specificPageNameSchema,
-  page: import_zod8.z.object({
-    path: import_zod8.z.string()
-  })
+  page: import_zod9.z.object({
+    path: import_zod9.z.string()
+  }).strict()
 }).strict();
-var specificPageVisitConfigSchema = import_zod8.z.object({
-  pages: import_zod8.z.array(
-    import_zod8.z.object({
+var specificPageVisitConfigSchema = import_zod9.z.object({
+  pages: import_zod9.z.array(
+    import_zod9.z.object({
       name: specificPageNameSchema,
-      pathPattern: import_zod8.z.custom((value) => value instanceof RegExp, {
+      pathPattern: import_zod9.z.custom((value) => value instanceof RegExp, {
         message: "pathPattern must be a RegExp"
       })
-    })
+    }).strict()
   ).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()
-  })
+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()
 }).strict();
-var timeOnSiteConfigSchema = import_zod9.z.object({
-  thresholdSeconds: import_zod9.z.number().int().positive()
+var timeOnSiteConfigSchema = import_zod10.z.object({
+  thresholdSeconds: import_zod10.z.number().int().positive()
 }).strict();
 
 // ../tracking-core/src/events/registry.ts
@@ -766,6 +863,12 @@ var EVENT_REGISTRY = {
     metadataSchema: formStartMetadataSchema,
     configSchema: formStartConfigSchema
   },
+  // --- SDK-internal automatic (not consumer-configurable) ---
+  sdk_heartbeat: {
+    kind: "automatic",
+    metadataSchema: sdkHeartbeatMetadataSchema,
+    configSchema: sdkHeartbeatConfigSchema
+  },
   // --- manual triggers ---
   form_submit: {
     kind: "manual",
@@ -1025,7 +1128,7 @@ function attachMultiPageSession(client, config) {
     }
   }
   function resetIfSessionChanged() {
-    const currentSession = getOrRotateSessionId();
+    const currentSession = getOrRotateSessionId().id;
     const storedSession = storage.getItem(SESSION_KEY);
     if (storedSession !== currentSession) {
       storage.setItem(SESSION_KEY, currentSession);
@@ -1233,7 +1336,7 @@ function useConsentState() {
 var import_react4 = require("react");
 
 // package.json
-var version = "0.5.0";
+var version = "0.6.0";
 
 // src/factory.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
@@ -1269,6 +1372,7 @@ function createTracking(options) {
           surface: "react",
           packageName: "@aranova/tracking-react",
           sdkVersion: version,
+          triggers,
           debug
         }),
         triggers,
@@ -1287,6 +1391,7 @@ function createTracking(options) {
         endpoint,
         surface: "react",
         packageName: "@aranova/tracking-react",
+        triggers,
         debug
       });
       detachers.push(attachAutoPageView(rawClient));