@dotcms/analytics 1.2.0 → 1.2.1

package/lib/core/plugin/click/dot-analytics.click-tracker.js

@@ -0,0 +1,144 @@
+import { handleContentletClick as c } from "./dot-analytics.click.utils.js";
+import { DEFAULT_CLICK_THROTTLE_MS as d } from "../../shared/constants/dot-analytics.constants.js";
+import { createPluginLogger as h, isBrowser as l, INITIAL_SCAN_DELAY_MS as g, findContentlets as r, createContentletObserver as u } from "../../shared/utils/dot-analytics.utils.js";
+class C {
+  constructor(t) {
+    this.config = t, this.mutationObserver = null, this.lastClickTime = { value: 0 }, this.subscribers = /* @__PURE__ */ new Set(), this.trackedElements = /* @__PURE__ */ new WeakSet(), this.elementHandlers = /* @__PURE__ */ new WeakMap(), this.logger = h("Click", t);
+  }
+  /**
+   * Subscribe to click events
+   * @param callback - Function called when click is detected
+   * @returns Subscription object with unsubscribe method
+   */
+  onClick(t) {
+    return this.subscribers.add(t), {
+      unsubscribe: () => {
+        this.subscribers.delete(t);
+      }
+    };
+  }
+  /**
+   * Notifies all subscribers of a click event
+   * @param eventName - Name of the event (e.g., 'content_click')
+   * @param payload - Click event payload with content and element data
+   */
+  notifySubscribers(t, e) {
+    this.subscribers.forEach((i) => i(t, e));
+  }
+  /**
+   * Initialize click tracking system
+   *
+   * Performs the following:
+   * - Validates browser environment
+   * - Scans for existing contentlets after a delay (100ms)
+   * - Sets up MutationObserver for dynamic content
+   *
+   * The delay allows React/Next.js to finish initial rendering
+   * before attaching listeners.
+   */
+  initialize() {
+    if (!l()) {
+      this.logger.warn("No document, skipping");
+      return;
+    }
+    this.logger.debug("Plugin initializing"), typeof window < "u" && setTimeout(() => {
+      this.logger.debug("Running initial scan after timeout..."), this.findAndAttachListeners();
+    }, g), this.initializeMutationObserver(), this.logger.info("Plugin initialized");
+  }
+  /**
+   * Attach click listener to a contentlet container
+   *
+   * Skips if element already has a listener attached.
+   * The listener delegates to handleContentletClick which:
+   * - Finds clicked anchor/button elements
+   * - Extracts contentlet and element data
+   * - Applies throttling (300ms)
+   * - Notifies subscribers
+   *
+   * @param element - Contentlet container element to track
+   */
+  attachClickListener(t) {
+    if (this.trackedElements.has(t)) {
+      const n = t.dataset.dotAnalyticsIdentifier || "unknown";
+      this.logger.debug(`Element ${n} already has listener, skipping`);
+      return;
+    }
+    if (!t.dataset.dotAnalyticsDomIndex) {
+      const n = r();
+      t.dataset.dotAnalyticsDomIndex = String(n.indexOf(t));
+    }
+    const e = (n) => {
+      this.logger.debug("Click handler triggered on contentlet"), c(
+        n,
+        t,
+        (a, s) => {
+          const o = Date.now();
+          o - this.lastClickTime.value < d || (this.lastClickTime.value = o, this.notifySubscribers(a, s), this.logger.info(
+            `Fired click event for ${s.content.identifier}`,
+            s
+          ));
+        },
+        this.logger
+      );
+    };
+    t.addEventListener("click", e), this.trackedElements.add(t), this.elementHandlers.set(t, e);
+    const i = t.dataset.dotAnalyticsIdentifier || "unknown";
+    this.logger.log(`Attached listener to contentlet ${i}`, t);
+  }
+  /**
+   * Find and attach listeners to all contentlet elements in the DOM
+   *
+   * Scans the entire document for elements with the
+   * `.dotcms-analytics-contentlet` class and attaches click
+   * listeners if not already tracked.
+   *
+   * Called during initialization and whenever DOM mutations are detected.
+   */
+  findAndAttachListeners() {
+    this.logger.debug("findAndAttachListeners called");
+    const t = r();
+    this.logger.debug(`Scanning... found ${t.length} contentlets`);
+    let e = 0;
+    t.forEach((i) => {
+      const n = !this.trackedElements.has(i);
+      this.attachClickListener(i), n && this.trackedElements.has(i) && e++;
+    }), e > 0 && this.logger.info(`Attached ${e} new click listeners`);
+  }
+  /**
+   * Initialize MutationObserver to detect new contentlet containers
+   * Uses same simple strategy as impression tracker - no complex filtering
+   */
+  initializeMutationObserver() {
+    l() && (this.mutationObserver = u(() => {
+      this.findAndAttachListeners();
+    }), this.logger.info("MutationObserver enabled for click tracking"));
+  }
+  /**
+   * Remove all click listeners from tracked contentlets
+   *
+   * Iterates through all contentlet elements and removes their
+   * click event handlers, cleaning up WeakMap references.
+   */
+  removeAllListeners() {
+    r().forEach((e) => {
+      const i = this.elementHandlers.get(e);
+      i && (e.removeEventListener("click", i), this.elementHandlers.delete(e));
+    });
+  }
+  /**
+   * Cleanup all resources used by the click tracker
+   *
+   * Performs:
+   * - Removes all event listeners from contentlets
+   * - Disconnects MutationObserver
+   * - Clears internal references
+   *
+   * Should be called when the plugin is disabled or on page unload.
+   */
+  cleanup() {
+    this.removeAllListeners(), this.mutationObserver && (this.mutationObserver.disconnect(), this.mutationObserver = null), this.logger.info("Click tracking cleaned up");
+  }
+}
+export {
+  C as DotCMSClickTracker
+};

package/lib/core/plugin/click/dot-analytics.click.plugin.d.ts

@@ -0,0 +1,36 @@
+import { AnalyticsInstance } from 'analytics';
+import { DotCMSAnalyticsConfig } from '../../shared/models';
+/**
+ * Click Plugin for DotAnalytics
+ * Handles automatic tracking of clicks on content elements.
+ *
+ * This plugin initializes the click tracker which:
+ * - Uses MutationObserver to detect contentlet containers
+ * - Attaches click listeners to each .dotcms-analytics-contentlet element
+ * - Filters for clicks on <a> or <button> elements inside tracked contentlets
+ * - Extracts contentlet data and element metadata
+ * - Throttles clicks to prevent duplicates
+ * - Fires 'content_click' events via subscription callback
+ *
+ * Note: This plugin is only registered if config.clicks is enabled.
+ * See getEnhancedTrackingPlugins() for conditional loading logic.
+ *
+ * @param {DotCMSAnalyticsConfig} config - Configuration with clicks settings
+ * @returns {Object} Plugin object with lifecycle methods
+ */
+export declare const dotAnalyticsClickPlugin: (config: DotCMSAnalyticsConfig) => {
+    name: string;
+    /**
+     * Initialize click tracking
+     * Called when Analytics.js initializes the plugin with instance context
+     * @param instance - Analytics.js instance with track method
+     */
+    initialize: ({ instance }: {
+        instance: AnalyticsInstance;
+    }) => Promise<void>;
+    /**
+     * Setup cleanup handlers when plugin is loaded
+     * Called after Analytics.js completes plugin loading
+     */
+    loaded: () => boolean;
+};

package/lib/core/plugin/click/dot-analytics.click.plugin.js

@@ -0,0 +1,27 @@
+import { DotCMSClickTracker as o } from "./dot-analytics.click-tracker.js";
+import { createPluginLogger as u, isBrowser as a, setupPluginCleanup as s } from "../../shared/utils/dot-analytics.utils.js";
+const g = (n) => {
+  let i = null, l = null;
+  const e = u("Click", n);
+  return {
+    name: "dot-analytics-click",
+    /**
+     * Initialize click tracking
+     * Called when Analytics.js initializes the plugin with instance context
+     * @param instance - Analytics.js instance with track method
+     */
+    initialize: ({ instance: r }) => (i = new o(n), l = i.onClick((c, t) => {
+      r.track(c, t);
+    }), i.initialize(), e.info("Click tracking plugin initialized"), Promise.resolve()),
+    /**
+     * Setup cleanup handlers when plugin is loaded
+     * Called after Analytics.js completes plugin loading
+     */
+    loaded: () => (a() && i && s(() => {
+      l && (l.unsubscribe(), l = null), i && (i.cleanup(), i = null, e.info("Click tracking cleaned up on page unload"));
+    }), !0)
+  };
+};
+export {
+  g as dotAnalyticsClickPlugin
+};

package/lib/core/plugin/click/dot-analytics.click.utils.d.ts

@@ -0,0 +1,12 @@
+import { DotCMSContentClickPayload } from '../../shared/models';
+import { createPluginLogger } from '../../shared/utils/dot-analytics.utils';
+/**
+ * Handles click events on elements within a contentlet.
+ * The contentlet element is already known since we attach listeners to contentlets.
+ *
+ * @param event - The mouse event
+ * @param contentletElement - The contentlet container element
+ * @param trackCallback - Callback to execute if the click is valid
+ * @param logger - Logger instance for debug messages
+ */
+export declare const handleContentletClick: (event: MouseEvent, contentletElement: HTMLElement, trackCallback: (eventName: string, payload: DotCMSContentClickPayload) => void, logger: ReturnType<typeof createPluginLogger>) => void;

package/lib/core/plugin/click/dot-analytics.click.utils.js

@@ -0,0 +1,55 @@
+import { CLICKABLE_ELEMENTS_SELECTOR as l, CLICK_EVENT_TYPE as m } from "../../shared/constants/dot-analytics.constants.js";
+import { extractContentletData as p } from "../../shared/utils/dot-analytics.utils.js";
+import { getViewportMetrics as b } from "../impression/dot-analytics.impression.utils.js";
+const _ = (r, o, c, e) => {
+  const a = r.target;
+  e.debug("Click detected on:", a);
+  const t = a.closest(l);
+  if (!t) {
+    e.debug("No <a> or <button> found in click path");
+    return;
+  }
+  if (!o.contains(t)) {
+    e.debug("Click was outside contentlet boundary");
+    return;
+  }
+  e.debug("Found clickable element:", t);
+  const n = p(o);
+  if (!n.identifier) {
+    e.debug("Contentlet has no identifier");
+    return;
+  }
+  e.debug("Contentlet data:", n);
+  const d = b(o), s = [];
+  for (const i of t.attributes)
+    !i.name.startsWith("data-dot-analytics") && i.name !== "class" && i.name !== "id" && i.name !== "href" && s.push(`${i.name}:${i.value}`);
+  const f = parseInt(o.dataset.dotAnalyticsDomIndex || "-1", 10), u = {
+    content: {
+      identifier: n.identifier,
+      inode: n.inode,
+      title: n.title,
+      content_type: n.contentType
+    },
+    position: {
+      viewport_offset_pct: d.offsetPercentage,
+      dom_index: f
+    },
+    element: {
+      text: (t.innerText || t.textContent || "").trim().substring(0, 100),
+      // Limit length
+      type: t.tagName.toLowerCase(),
+      id: t.id || "",
+      // Required by backend, empty string if not present
+      class: t.className || "",
+      // Required by backend, empty string if not present
+      href: t.getAttribute("href") || "",
+      // Path as written in HTML (relative), empty string for buttons
+      attributes: s
+      // Additional attributes (data-*, aria-*, target, etc.)
+    }
+  };
+  c(m, u);
+};
+export {
+  _ as handleContentletClick
+};

package/lib/core/plugin/enricher/dot-analytics.enricher.plugin.d.ts

@@ -1,28 +1,32 @@
-import { AnalyticsBasePayloadWithContext, AnalyticsTrackPayloadWithContext, DotCMSAnalyticsRequestBody } from '../../shared/models';
+import { AnalyticsBasePayloadWithContext, AnalyticsTrackPayloadWithContext, EnrichedAnalyticsPayload, EnrichedTrackPayload } from '../../shared/models';
 /**
- * Plugin that enriches the analytics payload data based on the event type.
- * Uses Analytics.js lifecycle events to inject context before processing.
+ * Plugin that enriches the analytics payload data with page, UTM, and custom data.
+ * Uses Analytics.js lifecycle events to inject enriched data before the main plugin processes it.
+ *
  * The identity plugin runs FIRST to inject context: { session_id, site_auth, user_id, device }
  * This enricher plugin runs SECOND to add page/utm/custom data.
+ * The main plugin runs THIRD to structure events and send to server.
  *
- * Returns the final request body structure ready to send to the server.
+ * This plugin is ONLY responsible for data enrichment - NOT for event structuring or business logic.
  */
 export declare const dotAnalyticsEnricherPlugin: () => {
     name: string;
     /**
      * PAGE VIEW ENRICHMENT - Runs after identity context injection
-     * Returns the complete request body for pageview events
-     * @returns {DotCMSAnalyticsRequestBody} Complete request body ready to send
+     * Returns enriched payload with page, utm, and custom data added
+     * @returns {EnrichedAnalyticsPayload} Enriched payload ready for event creation
      */
     'page:dot-analytics': ({ payload }: {
         payload: AnalyticsBasePayloadWithContext;
-    }) => DotCMSAnalyticsRequestBody;
+    }) => EnrichedAnalyticsPayload;
     /**
      * TRACK EVENT ENRICHMENT - Runs after identity context injection
-     * Returns the complete request body for custom events
-     * @returns {DotCMSAnalyticsRequestBody} Complete request body ready to send
+     * Adds page data and timestamp for predefined content events.
+     * For custom events, only adds timestamp.
+     *
+     * @returns {EnrichedTrackPayload} Enriched payload ready for event structuring
      */
     'track:dot-analytics': ({ payload }: {
         payload: AnalyticsTrackPayloadWithContext;
-    }) => DotCMSAnalyticsRequestBody;
+    }) => EnrichedTrackPayload;
 };

package/lib/core/plugin/enricher/dot-analytics.enricher.plugin.js

@@ -1,56 +1,44 @@
-import { DotCMSPredefinedEventType as i } from "../../shared/constants/dot-content-analytics.constants.js";
-import { getLocalTime as c, enrichPagePayloadOptimized as s } from "../../shared/dot-content-analytics.utils.js";
-const m = () => ({
+import { DotCMSPredefinedEventType as r } from "../../shared/constants/dot-analytics.constants.js";
+import { getLocalTime as i, enrichPagePayloadOptimized as o } from "../../shared/utils/dot-analytics.utils.js";
+const l = () => ({
   name: "enrich-dot-analytics",
   /**
    * PAGE VIEW ENRICHMENT - Runs after identity context injection
-   * Returns the complete request body for pageview events
-   * @returns {DotCMSAnalyticsRequestBody} Complete request body ready to send
+   * Returns enriched payload with page, utm, and custom data added
+   * @returns {EnrichedAnalyticsPayload} Enriched payload ready for event creation
    */
   "page:dot-analytics": ({
-    payload: o
+    payload: e
   }) => {
-    const { context: a, page: t, utm: e, custom: n, local_time: r } = s(o);
-    if (!t)
+    const t = o(e);
+    if (!t.page)
       throw new Error("DotCMS Analytics: Missing required page data");
-    return {
-      context: a,
-      events: [
-        {
-          event_type: i.PAGEVIEW,
-          local_time: r,
-          data: {
-            page: t,
-            ...e && { utm: e },
-            ...n && { custom: n }
-          }
-        }
-      ]
-    };
+    return t;
   },
   /**
    * TRACK EVENT ENRICHMENT - Runs after identity context injection
-   * Returns the complete request body for custom events
-   * @returns {DotCMSAnalyticsRequestBody} Complete request body ready to send
+   * Adds page data and timestamp for predefined content events.
+   * For custom events, only adds timestamp.
+   *
+   * @returns {EnrichedTrackPayload} Enriched payload ready for event structuring
    */
   "track:dot-analytics": ({
-    payload: o
+    payload: e
   }) => {
-    const { event: a, properties: t, context: e } = o, n = c();
-    return {
-      context: e,
-      events: [
-        {
-          event_type: a,
-          local_time: n,
-          data: {
-            custom: t
-          }
-        }
-      ]
+    const { event: t } = e, n = i();
+    return t === r.CONTENT_IMPRESSION || t === r.CONTENT_CLICK || t === r.CONVERSION ? {
+      ...e,
+      page: {
+        title: document.title,
+        url: window.location.href
+      },
+      local_time: n
+    } : {
+      ...e,
+      local_time: n
     };
   }
 });
 export {
-  m as dotAnalyticsEnricherPlugin
+  l as dotAnalyticsEnricherPlugin
 };

package/lib/core/{shared/dot-content-analytics.activity-tracker.d.ts → plugin/identity/dot-analytics.identity.activity-tracker.d.ts}

@@ -1,5 +1,5 @@
-import { ANALYTICS_WINDOWS_ACTIVE_KEY, ANALYTICS_WINDOWS_CLEANUP_KEY } from '../../../../../uve/src/internal.ts';
-import { DotCMSAnalyticsConfig } from './models';
+import { ANALYTICS_WINDOWS_ACTIVE_KEY, ANALYTICS_WINDOWS_CLEANUP_KEY } from '../../../../../../uve/src/internal.ts';
+import { DotCMSAnalyticsConfig } from '../../shared/models';
 declare global {
     interface Window {
         [ANALYTICS_WINDOWS_CLEANUP_KEY]?: () => void;
@@ -10,13 +10,6 @@ declare global {
  * Updates session activity with throttling
  */
 export declare const updateSessionActivity: () => void;
-/**
- * Gets session information for debugging
- */
-export declare const getSessionInfo: () => {
-    lastActivity: number;
-    isActive: boolean;
-};
 /**
  * Initializes activity tracking
  */
@@ -25,11 +18,3 @@ export declare const initializeActivityTracking: (config: DotCMSAnalyticsConfig)
  * Cleans up activity tracking listeners and resets analytics state
  */
 export declare const cleanupActivityTracking: () => void;
-/**
- * Checks if user has been inactive
- */
-export declare const isUserInactive: () => boolean;
-/**
- * Gets last activity time
- */
-export declare const getLastActivity: () => number;

package/lib/core/{shared/dot-content-analytics.activity-tracker.js → plugin/identity/dot-analytics.identity.activity-tracker.js}

@@ -1,6 +1,6 @@
-import { ANALYTICS_WINDOWS_ACTIVE_KEY as o, ANALYTICS_WINDOWS_CLEANUP_KEY as r } from "../../../uve/src/internal/constants.js";
-import { DEFAULT_SESSION_TIMEOUT_MINUTES as c, ACTIVITY_EVENTS as v } from "./constants/dot-content-analytics.constants.js";
-class l {
+import { ANALYTICS_WINDOWS_ACTIVE_KEY as a, ANALYTICS_WINDOWS_CLEANUP_KEY as o } from "../../../../uve/src/internal/constants.js";
+import { DEFAULT_SESSION_TIMEOUT_MINUTES as r, ACTIVITY_EVENTS as l } from "../../shared/constants/dot-analytics.constants.js";
+class v {
   constructor() {
     this.activityListeners = [], this.lastActivityTime = Date.now(), this.inactivityTimer = null, this.isThrottled = !1, this.config = null, this.ACTIVITY_THROTTLE_MS = 1e3;
   }
@@ -12,24 +12,11 @@ class l {
     this.lastActivityTime = Date.now(), this.inactivityTimer && clearTimeout(this.inactivityTimer), this.inactivityTimer = setTimeout(
       () => {
         var i;
-        (i = this.config) != null && i.debug && console.warn("DotCMS Analytics: User became inactive after timeout"), this.inactivityTimer = null;
+        (i = this.config) != null && i.debug && console.warn("DotCMS Analytics [Activity]: User became inactive after timeout"), this.inactivityTimer = null;
       },
-      c * 60 * 1e3
+      r * 60 * 1e3
     );
   }
-  /**
-   * Checks if user has been inactive
-   */
-  isUserInactive() {
-    const i = c * 60 * 1e3;
-    return Date.now() - this.lastActivityTime > i;
-  }
-  /**
-   * Gets last activity time
-   */
-  getLastActivity() {
-    return this.lastActivityTime;
-  }
   /**
    * Updates session activity with throttling
    */
@@ -45,17 +32,19 @@ class l {
     if (this.cleanup(), this.config = i, typeof window > "u")
       return;
     const s = () => this.updateSessionActivity();
-    v.forEach((a) => {
-      window.addEventListener(a, s, { passive: !0 }), this.activityListeners.push(
-        () => window.removeEventListener(a, s)
+    l.forEach((c) => {
+      window.addEventListener(c, s, { passive: !0 }), this.activityListeners.push(
+        () => window.removeEventListener(c, s)
       );
     });
     const n = () => {
-      document.visibilityState === "visible" && (this.updateSessionActivity(), i.debug && console.warn("DotCMS Analytics: User returned to tab, session reactivated"));
+      document.visibilityState === "visible" && (this.updateSessionActivity(), i.debug && console.warn(
+        "DotCMS Analytics [Activity]: User returned to tab, session reactivated"
+      ));
     };
     document.addEventListener("visibilitychange", n), this.activityListeners.push(
       () => document.removeEventListener("visibilitychange", n)
-    ), this.updateActivityTime(), i.debug && console.warn("DotCMS Analytics: Activity tracking initialized");
+    ), this.updateActivityTime(), i.debug && console.warn("DotCMS Analytics [Activity]: Activity tracking initialized");
   }
   /**
    * Cleans up all activity tracking listeners
@@ -63,25 +52,16 @@ class l {
   cleanup() {
     this.activityListeners.forEach((i) => i()), this.activityListeners = [], this.inactivityTimer && (clearTimeout(this.inactivityTimer), this.inactivityTimer = null), this.config = null;
   }
-  /**
-   * Gets session information for debugging
-   */
-  getSessionInfo() {
-    return {
-      lastActivity: this.getLastActivity(),
-      isActive: !this.isUserInactive()
-    };
-  }
 }
-const t = new l(), u = () => {
+const t = new v(), d = () => {
   t.updateSessionActivity();
-}, d = (e) => {
+}, u = (e) => {
   t.initialize(e);
 }, y = () => {
-  t.cleanup(), typeof window < "u" && (window[o] = !1, window[r] = void 0, window.dispatchEvent(new CustomEvent("dotcms:analytics:cleanup")));
+  t.cleanup(), typeof window < "u" && (window[a] = !1, window[o] = void 0, window.dispatchEvent(new CustomEvent("dotcms:analytics:cleanup")));
 };
 export {
   y as cleanupActivityTracking,
-  d as initializeActivityTracking,
-  u as updateSessionActivity
+  u as initializeActivityTracking,
+  d as updateSessionActivity
 };

package/lib/core/plugin/identity/dot-analytics.identity.plugin.d.ts

@@ -26,16 +26,7 @@ export declare const dotAnalyticsIdentityPlugin: (config: DotCMSAnalyticsConfig)
     pageStart: ({ payload }: AnalyticsBaseParams) => {
         context: import('../../shared/models').DotCMSAnalyticsEventContext;
         type: "page" | "track";
-        properties: {
-            title: string;
-            url: string;
-            path: string;
-            hash: string;
-            search: string;
-            width: number;
-            height: number;
-            referrer?: string;
-        };
+        properties: Record<string, unknown>;
         options: Record<string, unknown>;
         userId: string;
         anonymousId: string;
@@ -52,16 +43,7 @@ export declare const dotAnalyticsIdentityPlugin: (config: DotCMSAnalyticsConfig)
     trackStart: ({ payload }: AnalyticsBaseParams) => {
         context: import('../../shared/models').DotCMSAnalyticsEventContext;
         type: "page" | "track";
-        properties: {
-            title: string;
-            url: string;
-            path: string;
-            hash: string;
-            search: string;
-            width: number;
-            height: number;
-            referrer?: string;
-        };
+        properties: Record<string, unknown>;
         options: Record<string, unknown>;
         userId: string;
         anonymousId: string;

package/lib/core/plugin/identity/dot-analytics.identity.plugin.js

@@ -1,5 +1,5 @@
-import { getAnalyticsContext as n } from "../../shared/dot-content-analytics.utils.js";
-import { cleanupActivityTracking as r, updateSessionActivity as o, initializeActivityTracking as a } from "../../shared/dot-content-analytics.activity-tracker.js";
+import { cleanupActivityTracking as n, updateSessionActivity as r, initializeActivityTracking as a } from "./dot-analytics.identity.activity-tracker.js";
+import { getAnalyticsContext as o } from "../../shared/utils/dot-analytics.utils.js";
 const s = (t) => ({
   name: "dot-analytics-identity",
   /**
@@ -12,8 +12,8 @@ const s = (t) => ({
    * This runs BEFORE the enricher plugin
    */
   pageStart: ({ payload: e }) => {
-    o();
-    const i = n(t);
+    r();
+    const i = o(t);
     return {
       ...e,
       context: i
@@ -24,8 +24,8 @@ const s = (t) => ({
    * This runs BEFORE the enricher plugin
    */
   trackStart: ({ payload: e }) => {
-    o();
-    const i = n(t);
+    r();
+    const i = o(t);
     return {
       ...e,
       context: i
@@ -35,7 +35,7 @@ const s = (t) => ({
    * Clean up on plugin unload
    * Sets up cleanup handlers for activity tracking
    */
-  loaded: () => (typeof window < "u" && (window.addEventListener("beforeunload", r), window.addEventListener("pagehide", r)), !0)
+  loaded: () => (typeof window < "u" && (window.addEventListener("beforeunload", n), window.addEventListener("pagehide", n)), !0)
 });
 export {
   s as dotAnalyticsIdentityPlugin

package/lib/core/plugin/identity/dot-analytics.identity.utils.d.ts

@@ -1,20 +1,4 @@
 import { DotCMSEventUtmData } from '../../shared/models';
-/**
- * Updates activity timestamp
- */
-export declare const updateActivityTime: () => void;
-/**
- * Checks if user has been inactive
- */
-export declare const isUserInactive: () => boolean;
-/**
- * Checks if a new day has started since session creation
- */
-export declare const hasPassedMidnight: (sessionStartTime: number) => boolean;
-/**
- * Gets the last activity time
- */
-export declare const getLastActivityTime: () => number;
 /**
  * Compares UTM parameters to detect campaign changes.
  * Only checks significant parameters: source, medium, and campaign.