@active-reach/web-sdk 1.10.0 → 1.11.1

package/dist/index.js

@@ -1,5 +1,5 @@
-import { S as Storage, l as logger, A as Aegis } from "./analytics-Cc4-QQBf.mjs";
-import { B, E, N, R, m } from "./analytics-Cc4-QQBf.mjs";
+import { S as Storage, l as logger, A as Aegis } from "./analytics-6PR9ERDS.mjs";
+import { B, E, N, R, m } from "./analytics-6PR9ERDS.mjs";
 import { AegisWebPush } from "./push/AegisWebPush.js";
 function debounce(func, wait) {
   let timeoutId = null;
@@ -1024,10 +1024,10 @@ const _AegisInAppManager = class _AegisInAppManager {
         this.log(`Error parsing SSE event: ${error}`, "error");
       }
     });
-    this.eventSource.addEventListener("heartbeat", (event) => {
+    this.eventSource.addEventListener("heartbeat", () => {
       this.log("SSE heartbeat received");
     });
-    this.eventSource.addEventListener("error", (error) => {
+    this.eventSource.addEventListener("error", () => {
       var _a;
       this.log("SSE connection error", "error");
       if (((_a = this.eventSource) == null ? void 0 : _a.readyState) === EventSource.CLOSED) {
@@ -3216,7 +3216,7 @@ class AegisPlacementManager {
     wrapper.innerHTML = this.sanitizeHTML(html);
     const links = wrapper.querySelectorAll("a");
     links.forEach((link) => {
-      link.addEventListener("click", (e) => {
+      link.addEventListener("click", () => {
         this.trackEvent(content.placement_id, content.variant_id, "click");
       });
     });
@@ -3349,10 +3349,10 @@ class AegisPlacementManager {
         this.log(`Error parsing SSE event: ${error}`, true);
       }
     });
-    this.eventSource.addEventListener("heartbeat", (event) => {
+    this.eventSource.addEventListener("heartbeat", () => {
       this.log("SSE heartbeat received");
     });
-    this.eventSource.addEventListener("error", (error) => {
+    this.eventSource.addEventListener("error", () => {
       var _a;
       this.log("SSE connection error", true);
       if (((_a = this.eventSource) == null ? void 0 : _a.readyState) === EventSource.CLOSED) {
@@ -3519,6 +3519,28 @@ class TriggerEngine {
     this.visibilityChangeEnabled = false;
     this.backButtonEnabled = false;
     this.backButtonFired = false;
+    this.rageClickEnabled = false;
+    this.rageClickConfig = { threshold: 3, windowMs: 1e3 };
+    this.rageClickBuffer = /* @__PURE__ */ new Map();
+    this.rageClickFiredInBurst = /* @__PURE__ */ new Set();
+    this.hoverEnabled = false;
+    this.hoverStartAt = /* @__PURE__ */ new Map();
+    this.hoverLastMs = /* @__PURE__ */ new Map();
+    this.hoverThresholds = /* @__PURE__ */ new Map([
+      ["price", [1500]],
+      ["cta", [1500]]
+    ]);
+    this.hoverThresholdsFired = /* @__PURE__ */ new Map();
+    this.hoverThresholdTimers = /* @__PURE__ */ new Map();
+    this.mouseVelEnabled = false;
+    this.mouseVelConfig = {
+      threshold: 1.5,
+      windowMs: 400,
+      cooldownMs: 5e3
+    };
+    this.mouseSamples = [];
+    this.mouseVelLast = 0;
+    this.mouseVelLastFiredAt = 0;
     this.handleScroll = () => {
       const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
       const scrollHeight = document.documentElement.scrollHeight - window.innerHeight;
@@ -3663,6 +3685,204 @@ class TriggerEngine {
   registerBackButton() {
     this.backButtonEnabled = true;
   }
+  /**
+   * Enable rage-click detection (P2 Task 1).
+   *
+   * After calling this, feed click events via `noteClick(intent)`.
+   * SelectorBinder (P1 Task 5) is the upstream source; the wiring lives
+   * in IntentSnapshotCollector (P2 Task 5). Calling `noteClick` without
+   * a prior `registerRageClick()` is a no-op so legacy callers don't
+   * accidentally enable the feature.
+   */
+  registerRageClick(config) {
+    this.rageClickEnabled = true;
+    if (config) {
+      this.rageClickConfig = {
+        threshold: config.threshold ?? this.rageClickConfig.threshold,
+        windowMs: config.windowMs ?? this.rageClickConfig.windowMs
+      };
+    }
+  }
+  /**
+   * Feed a click event for rage-click detection. Returns the current
+   * count within-window for the intent — useful for the snapshot
+   * collector (P2 Task 5) which updates IntentRuleEvaluator with
+   * `rage_click_count` continuously, not just at the burst threshold.
+   *
+   * Idempotent w.r.t. `registerRageClick` — when not enabled, this
+   * returns 0 without buffering.
+   */
+  noteClick(intent, timestamp = Date.now()) {
+    if (!this.rageClickEnabled) return 0;
+    const buf = this.rageClickBuffer.get(intent) ?? [];
+    const cutoff = timestamp - this.rageClickConfig.windowMs;
+    let trimStart = 0;
+    while (trimStart < buf.length && buf[trimStart] < cutoff) trimStart++;
+    const recent = trimStart === 0 ? buf : buf.slice(trimStart);
+    recent.push(timestamp);
+    this.rageClickBuffer.set(intent, recent);
+    if (recent.length < this.rageClickConfig.threshold) {
+      this.rageClickFiredInBurst.delete(intent);
+    }
+    if (recent.length >= this.rageClickConfig.threshold && !this.rageClickFiredInBurst.has(intent)) {
+      this.rageClickFiredInBurst.add(intent);
+      this.emit("rage_click", {
+        intent,
+        count: recent.length,
+        window_ms: this.rageClickConfig.windowMs
+      });
+    }
+    return recent.length;
+  }
+  /** Snapshot the current rage_click count for an intent. The
+   *  IntentSnapshotCollector (P2 Task 5) calls this when building the
+   *  `rage_click_count` signal value for the IntentRuleEvaluator. */
+  getRageClickCount(intent) {
+    if (!this.rageClickEnabled) return 0;
+    const buf = this.rageClickBuffer.get(intent);
+    if (!buf) return 0;
+    const cutoff = Date.now() - this.rageClickConfig.windowMs;
+    let live = 0;
+    for (const ts of buf) {
+      if (ts >= cutoff) live++;
+    }
+    return live;
+  }
+  /**
+   * Enable hover-dwell tracking (P2 Task 2). After registration, feed
+   * hover events via `noteHoverStart(intent, ts)` / `noteHoverEnd`.
+   * SelectorBinder (P1 Task 5) is the upstream source; wiring lands in
+   * P2 Task 5.
+   */
+  registerHoverDwell(config) {
+    this.hoverEnabled = true;
+    if (config == null ? void 0 : config.thresholdsByIntent) {
+      for (const [intent, thresholds] of Object.entries(config.thresholdsByIntent)) {
+        if (thresholds) this.hoverThresholds.set(intent, thresholds);
+      }
+    }
+  }
+  /** Record the start of a hover on the named intent. Schedules
+   *  per-threshold timers that emit `<intent>_hover_dwell_<ms>` when
+   *  the active hover passes each registered threshold. */
+  noteHoverStart(intent, timestamp = Date.now()) {
+    if (!this.hoverEnabled) return;
+    if (this.hoverStartAt.has(intent)) {
+      this.noteHoverEnd(intent, timestamp);
+    }
+    this.hoverStartAt.set(intent, timestamp);
+    this.hoverThresholdsFired.set(intent, /* @__PURE__ */ new Set());
+    const thresholds = this.hoverThresholds.get(intent);
+    if (thresholds) {
+      const timers = [];
+      for (const ms of thresholds) {
+        const timerId = setTimeout(() => {
+          if (!this.hoverStartAt.has(intent)) return;
+          const firedSet = this.hoverThresholdsFired.get(intent);
+          if (firedSet == null ? void 0 : firedSet.has(ms)) return;
+          firedSet == null ? void 0 : firedSet.add(ms);
+          this.emit(`${intent}_hover_dwell_${ms}`, {
+            intent,
+            threshold_ms: ms,
+            actual_ms: Date.now() - timestamp
+          });
+        }, ms);
+        timers.push(timerId);
+      }
+      this.hoverThresholdTimers.set(intent, timers);
+    }
+  }
+  /** Record the end of a hover on the named intent. Updates the sticky
+   *  `lastHoverMs` so `getHoverMs` keeps returning the last-known
+   *  duration until the next hover_start. */
+  noteHoverEnd(intent, timestamp = Date.now()) {
+    if (!this.hoverEnabled) return;
+    const startAt = this.hoverStartAt.get(intent);
+    if (startAt === void 0) return;
+    const dwell = Math.max(0, timestamp - startAt);
+    this.hoverLastMs.set(intent, dwell);
+    this.hoverStartAt.delete(intent);
+    const pending = this.hoverThresholdTimers.get(intent);
+    if (pending) {
+      for (const id of pending) clearTimeout(id);
+      this.hoverThresholdTimers.delete(intent);
+    }
+    this.hoverThresholdsFired.delete(intent);
+  }
+  /**
+   * Enable mouse-velocity-to-top tracking (P2 Task 3). After
+   * registration, feed positions via `noteMousePosition(x, y, ts?)`.
+   * IntentSnapshotCollector (P2 Task 5) wires window 'mousemove' to
+   * this method, with throttling to ~100ms per the plan.
+   */
+  registerMouseVelocityToTop(config) {
+    this.mouseVelEnabled = true;
+    if (config) {
+      this.mouseVelConfig = {
+        threshold: config.threshold ?? this.mouseVelConfig.threshold,
+        windowMs: config.windowMs ?? this.mouseVelConfig.windowMs,
+        cooldownMs: config.cooldownMs ?? this.mouseVelConfig.cooldownMs
+      };
+    }
+  }
+  /** Feed a mouse-position sample. Recomputes the rolling-window
+   *  velocity-to-top and fires `mouse_velocity_to_top` when the value
+   *  crosses the configured threshold (subject to cooldown). */
+  noteMousePosition(x, y, timestamp = Date.now()) {
+    if (!this.mouseVelEnabled) return 0;
+    const cutoff = timestamp - this.mouseVelConfig.windowMs;
+    let trimStart = 0;
+    while (trimStart < this.mouseSamples.length && this.mouseSamples[trimStart].ts < cutoff) {
+      trimStart++;
+    }
+    if (trimStart > 0) this.mouseSamples = this.mouseSamples.slice(trimStart);
+    this.mouseSamples.push({ x, y, ts: timestamp });
+    if (this.mouseSamples.length < 2) {
+      this.mouseVelLast = 0;
+      return 0;
+    }
+    const oldest = this.mouseSamples[0];
+    const newest = this.mouseSamples[this.mouseSamples.length - 1];
+    const dt = newest.ts - oldest.ts;
+    if (dt <= 0) {
+      this.mouseVelLast = 0;
+      return 0;
+    }
+    const velocity = -(newest.y - oldest.y) / dt;
+    this.mouseVelLast = velocity;
+    const cooldownOk = this.mouseVelLastFiredAt === 0 || timestamp - this.mouseVelLastFiredAt >= this.mouseVelConfig.cooldownMs;
+    if (velocity >= this.mouseVelConfig.threshold && cooldownOk) {
+      this.mouseVelLastFiredAt = timestamp;
+      this.emit("mouse_velocity_to_top", {
+        velocity,
+        threshold: this.mouseVelConfig.threshold,
+        window_ms: this.mouseVelConfig.windowMs,
+        samples: this.mouseSamples.length
+      });
+    }
+    return velocity;
+  }
+  /** Snapshot the current velocity-to-top in px/ms (positive = up).
+   *  Returns 0 when not enabled or insufficient samples. */
+  getMouseVelocityToTop() {
+    return this.mouseVelEnabled ? this.mouseVelLast : 0;
+  }
+  /**
+   * Snapshot the hover dwell for an intent.
+   * - Currently hovering: returns `Date.now() - hover_start_at`.
+   * - Hovered before, not currently: returns the most recent hover's
+   *   duration (sticky — the rule evaluator queries this AFTER
+   *   mouseleave to see "did Priya hover the price ≥ 1.5s?").
+   * - Never hovered: returns 0.
+   */
+  getHoverMs(intent) {
+    if (!this.hoverEnabled) return 0;
+    const startAt = this.hoverStartAt.get(intent);
+    if (startAt !== void 0) {
+      return Math.max(0, Date.now() - startAt);
+    }
+    return this.hoverLastMs.get(intent) ?? 0;
+  }
   start() {
     if (this.isStarted) {
       return;
@@ -4543,7 +4763,14 @@ class AegisWidgetManager {
     this.widgets = [];
     this.isInitialized = false;
     this.log("AegisWidgets destroyed");
+    this.emitEvent("destroyed", {});
   }
+  /**
+   * Fire a lifecycle event to the consumer-supplied callback. Public-API
+   * hook configured via `AegisWidgetConfig.onEvent`. Currently only used
+   * by external callers passing their own logger; internal widget lifecycle
+   * events get wired through here as they're added.
+   */
   emitEvent(eventType, data) {
     if (this.onEvent) {
       try {
@@ -6395,10 +6622,8 @@ class AegisWidgetManager {
 class AegisMessageRuntime {
   constructor(config) {
     this.initialized = false;
-    this.ownedTriggerEngine = null;
     const triggerEngine = config.triggerEngine ?? new TriggerEngine();
     const ownsTriggerEngine = !config.triggerEngine;
-    if (ownsTriggerEngine) this.ownedTriggerEngine = triggerEngine;
     this.widgets = new AegisWidgetManager({
       writeKey: config.writeKey,
       apiHost: config.apiHost,
@@ -6495,7 +6720,6 @@ class AegisMessageRuntime {
     var _a, _b;
     (_b = (_a = this.inApp).destroy) == null ? void 0 : _b.call(_a);
     this.widgets.destroy();
-    this.ownedTriggerEngine = null;
     this.initialized = false;
   }
   /**