@dotcms/analytics 1.2.0-next.4 → 1.2.0-next.5

package/README.md

@@ -115,6 +115,7 @@ track(eventName: string, properties?: Record<string, unknown>): void
 | `debug` | `boolean` | ❌ | `false` | Enable verbose logging |
 | `autoPageView` | `boolean` | ❌ | React: `true` / Standalone: `false` | Auto track page views on route changes |
 | `queueConfig` | `QueueConfig` | ❌ | See below | Event batching configuration |
+| `impressions` | `ImpressionConfig\|boolean` | ❌ | `false` | Content impression tracking (disabled by default) |
 
 ### Queue Configuration
 
@@ -168,6 +169,64 @@ const analytics = initializeContentAnalytics({
 });
 ```
 
+### Impression Tracking Configuration
+
+The `impressions` option controls automatic tracking of content visibility:
+
+-   **`false` or `undefined` (default)**: Impression tracking disabled
+-   **`true`**: Enable tracking with default settings
+-   **`ImpressionConfig` object**: Enable tracking with custom settings
+
+| Option                | Type     | Default | Description                                      |
+| --------------------- | -------- | ------- | ------------------------------------------------ |
+| `visibilityThreshold` | `number` | `0.5`   | Min percentage visible (0.0 to 1.0)              |
+| `dwellMs`             | `number` | `750`   | Min time visible in milliseconds                 |
+| `maxNodes`            | `number` | `1000`  | Max elements to track (performance limit)        |
+
+**How it works:**
+
+-   ✅ Tracks contentlets marked with `dotcms-analytics-contentlet` class and `data-dot-analytics-*` attributes
+-   ✅ Uses Intersection Observer API for high performance and battery efficiency
+-   ✅ Only fires when element is ≥50% visible for ≥750ms (configurable)
+-   ✅ Only tracks during active tab (respects page visibility)
+-   ✅ One impression per contentlet per session (no duplicates)
+-   ✅ Respects user consent settings
+-   ✅ Automatically disabled in dotCMS editor mode
+
+**Example: Enable with defaults**
+
+```javascript
+const analytics = initializeContentAnalytics({
+    siteAuth: 'abc123',
+    server: 'https://your-dotcms.com',
+    impressions: true // 50% visible, 750ms dwell, 1000 max nodes
+});
+```
+
+**Example: Custom thresholds**
+
+```javascript
+const analytics = initializeContentAnalytics({
+    siteAuth: 'abc123',
+    server: 'https://your-dotcms.com',
+    impressions: {
+        visibilityThreshold: 0.7, // Require 70% visible
+        dwellMs: 1000, // Must be visible for 1 second
+        maxNodes: 500 // Track max 500 elements
+    }
+});
+```
+
+**Example: Disable tracking**
+
+```javascript
+const analytics = initializeContentAnalytics({
+    siteAuth: 'abc123',
+    server: 'https://your-dotcms.com',
+    impressions: false // Explicitly disabled (also default if omitted)
+});
+```
+
 ## 🛠️ Usage Examples
 
 ### Vanilla JavaScript

package/lib/core/dot-content-analytics.js

@@ -1,46 +1,56 @@
-import { Analytics as a } from "analytics";
-import { ANALYTICS_WINDOWS_ACTIVE_KEY as r, ANALYTICS_WINDOWS_CLEANUP_KEY as s } from "../../uve/src/internal/constants.js";
-import { dotAnalytics as l } from "./plugin/dot-analytics.plugin.js";
-import { dotAnalyticsEnricherPlugin as c } from "./plugin/enricher/dot-analytics.enricher.plugin.js";
-import { dotAnalyticsIdentityPlugin as p } from "./plugin/identity/dot-analytics.identity.plugin.js";
-import { validateAnalyticsConfig as m } from "./shared/dot-content-analytics.utils.js";
-import { cleanupActivityTracking as u } from "./shared/dot-content-analytics.activity-tracker.js";
-const I = (n) => {
-  const o = m(n);
+import { Analytics as s } from "analytics";
+import { ANALYTICS_WINDOWS_ACTIVE_KEY as a, ANALYTICS_WINDOWS_CLEANUP_KEY as l } from "../../uve/src/internal/constants.js";
+import { dotAnalytics as c } from "./plugin/dot-analytics.plugin.js";
+import { dotAnalyticsEnricherPlugin as d } from "./plugin/enricher/dot-analytics.enricher.plugin.js";
+import { dotAnalyticsIdentityPlugin as m } from "./plugin/identity/dot-analytics.identity.plugin.js";
+import { dotAnalyticsImpressionPlugin as p } from "./plugin/impression/dot-analytics.impression.plugin.js";
+import { validateAnalyticsConfig as y } from "./shared/dot-content-analytics.utils.js";
+import { cleanupActivityTracking as A } from "./shared/dot-content-analytics.activity-tracker.js";
+const _ = (n) => {
+  const o = y(n);
   if (o)
-    return console.error(`DotCMS Analytics: Missing ${o.join(" and ")} in configuration`), typeof window < "u" && (window[r] = !1), null;
-  const i = a({
+    return console.error(`DotCMS Analytics: Missing ${o.join(" and ")} in configuration`), typeof window < "u" && (window[a] = !1), null;
+  const i = s({
     app: "dotAnalytics",
     debug: n.debug,
     plugins: [
+      m(n),
+      // Inject identity context
       p(n),
-      // Inject identity context (user_id, session_id, local_tz)
-      c(),
+      // Track content impressions
+      d(),
       // Enrich and clean payload with page, device, utm data and custom data
-      l(n)
+      c(n)
       // Send events to server
     ]
-  }), e = () => u();
-  return typeof window < "u" && (window.addEventListener("beforeunload", e), window[s] = e, window[r] = !0, window.dispatchEvent(new CustomEvent("dotcms:analytics:ready"))), {
+  }), e = () => A();
+  return typeof window < "u" && (window.addEventListener("beforeunload", e), window[l] = e, window[a] = !0, window.dispatchEvent(new CustomEvent("dotcms:analytics:ready"))), {
     /**
      * Track a page view.
      * Session activity is automatically updated by the identity plugin.
      * @param payload - Optional custom data to include with the page view (any valid JSON object)
      */
     pageView: (t = {}) => {
-      i == null || i.page(t);
+      if (!i) {
+        console.warn("DotCMS Analytics: Analytics instance not initialized");
+        return;
+      }
+      i.page(t);
     },
     /**
      * Track a custom event.
-     * Session activity is automatically updated by the identity plugin.
      * @param eventName - The name of the event to track
      * @param payload - Custom data to include with the event (any valid JSON object)
      */
-    track: (t, d = {}) => {
-      i == null || i.track(t, d);
+    track: (t, r = {}) => {
+      if (!i) {
+        console.warn("DotCMS Analytics: Analytics instance not initialized");
+        return;
+      }
+      i.track(t, r);
     }
   };
 };
 export {
-  I as initializeContentAnalytics
+  _ as initializeContentAnalytics
 };

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

@@ -1,9 +1,14 @@
-import { DotCMSAnalyticsConfig, DotCMSAnalyticsParams } from '../shared/models';
+import { DotCMSAnalyticsConfig, EnrichedAnalyticsPayload, EnrichedTrackPayload } from '../shared/models';
 /**
  * Analytics plugin for tracking page views and custom events in DotCMS applications.
- * This plugin handles sending analytics data to the DotCMS server, managing initialization,
- * and processing both automatic and manual tracking events.
- * Supports optional queue management for batching events before sending.
+ * This plugin handles:
+ * 1. Event structuring (deciding between predefined and custom events)
+ * 2. Building complete request bodies
+ * 3. Sending analytics data to the DotCMS server
+ * 4. Managing initialization and queue management
+ *
+ * The enricher plugin runs BEFORE this plugin and adds page/utm/custom data.
+ * This plugin receives enriched payloads and structures them into proper events.
  *
  * @param {DotCMSAnalyticsConfig} config - Configuration object containing API key, server URL,
  *                                     debug mode, auto page view settings, and queue config
@@ -18,14 +23,21 @@ export declare const dotAnalytics: (config: DotCMSAnalyticsConfig) => {
     initialize: () => Promise<void>;
     /**
      * Track a page view event
-     * The enricher plugin has already built the complete request body
+     * Receives enriched payload from the enricher plugin and structures it into a pageview event
      */
-    page: (params: DotCMSAnalyticsParams) => void;
+    page: ({ payload }: {
+        payload: EnrichedAnalyticsPayload;
+    }) => void;
     /**
-     * Track a custom event
-     * The enricher plugin has already built the complete request body
+     * Track a custom or predefined event
+     * Receives enriched payload from enricher plugin and structures it into proper event format.
+     *
+     * - content_impression → extracts from properties, combines with enriched page data
+     * - custom events → wraps properties in custom object
      */
-    track: (params: DotCMSAnalyticsParams) => void;
+    track: ({ payload }: {
+        payload: EnrichedTrackPayload;
+    }) => void;
     /**
      * Check if the plugin is loaded
      */

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

@@ -1,42 +1,97 @@
-import { sendAnalyticsEvent as u } from "../shared/dot-content-analytics.http.js";
-import { createAnalyticsQueue as d } from "../shared/queue/dot-analytics.queue.utils.js";
-const v = (t) => {
-  let n = !1;
-  const i = t.queue !== !1;
-  let e = null;
-  const o = (r) => {
-    const { config: c, payload: l } = r;
-    if (!n)
-      throw new Error("DotCMS Analytics: Plugin not initialized");
-    const a = l.events[0], s = l.context;
-    i && e ? e.enqueue(a, s) : u({
-      context: s,
-      events: [a]
-    }, c);
+import { DotCMSPredefinedEventType as l } from "../shared/constants/dot-content-analytics.constants.js";
+import { sendAnalyticsEvent as f } from "../shared/dot-content-analytics.http.js";
+import { createAnalyticsQueue as w } from "../shared/queue/dot-analytics.queue.utils.js";
+const P = (s) => {
+  let a = !1;
+  const u = s.queue !== !1;
+  let r = null;
+  const d = (e) => {
+    const n = e.events[0], t = e.context;
+    u && r ? r.enqueue(n, t) : f(e, s);
   };
   return {
     name: "dot-analytics",
-    config: t,
+    config: s,
     /**
      * Initialize the plugin with optional queue management
      */
-    initialize: () => (n = !0, i && (e = d(t), e.initialize()), Promise.resolve()),
+    initialize: () => (a = !0, u && (r = w(s), r.initialize()), Promise.resolve()),
     /**
      * Track a page view event
-     * The enricher plugin has already built the complete request body
+     * Receives enriched payload from the enricher plugin and structures it into a pageview event
      */
-    page: o,
+    page: ({ payload: e }) => {
+      if (!a)
+        throw new Error("DotCMS Analytics: Plugin not initialized");
+      const { context: n, page: t, utm: c, custom: i, local_time: o } = e;
+      if (!t)
+        throw new Error("DotCMS Analytics: Missing required page data");
+      const p = {
+        context: n,
+        events: [
+          {
+            event_type: l.PAGEVIEW,
+            local_time: o,
+            data: {
+              page: t,
+              ...c && { utm: c },
+              ...i && { custom: i }
+            }
+          }
+        ]
+      };
+      d(p);
+    },
     /**
-     * Track a custom event
-     * The enricher plugin has already built the complete request body
+     * Track a custom or predefined event
+     * Receives enriched payload from enricher plugin and structures it into proper event format.
+     *
+     * - content_impression → extracts from properties, combines with enriched page data
+     * - custom events → wraps properties in custom object
      */
-    track: o,
+    track: ({ payload: e }) => {
+      if (!a)
+        throw new Error("DotCMS Analytics: Plugin not initialized");
+      const { event: n, properties: t, context: c, local_time: i } = e;
+      let o;
+      switch (n) {
+        case l.CONTENT_IMPRESSION: {
+          const v = t, { content: m, position: y } = v, { page: E } = e;
+          if (!m || !y || !E)
+            throw new Error("DotCMS Analytics: Missing required impression data");
+          o = {
+            event_type: l.CONTENT_IMPRESSION,
+            local_time: i,
+            data: {
+              content: m,
+              position: y,
+              page: E
+            }
+          };
+          break;
+        }
+        default: {
+          o = {
+            event_type: n,
+            local_time: i,
+            data: {
+              custom: t
+            }
+          };
+          break;
+        }
+      }
+      d({
+        context: c,
+        events: [o]
+      });
+    },
     /**
      * Check if the plugin is loaded
      */
-    loaded: () => n
+    loaded: () => a
   };
 };
 export {
-  v as dotAnalytics
+  P as dotAnalytics
 };

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 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 n } from "../../shared/constants/dot-content-analytics.constants.js";
+import { getLocalTime as i, enrichPagePayloadOptimized as o } from "../../shared/dot-content-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: t
   }) => {
-    const { context: a, page: t, utm: e, custom: n, local_time: r } = s(o);
-    if (!t)
+    const e = o(t);
+    if (!e.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 e;
   },
   /**
    * 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 events.
+   * For custom events, only adds timestamp.
+   *
+   * @returns {EnrichedTrackPayload} Enriched payload ready for event structuring
    */
   "track:dot-analytics": ({
-    payload: o
+    payload: t
   }) => {
-    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: e } = t, r = i();
+    return e === n.CONTENT_IMPRESSION ? {
+      ...t,
+      page: {
+        title: document.title,
+        url: window.location.href
+      },
+      local_time: r
+    } : {
+      ...t,
+      local_time: r
     };
   }
 });
 export {
-  m as dotAnalyticsEnricherPlugin
+  l as dotAnalyticsEnricherPlugin
 };

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/impression/dot-analytics.impression.plugin.d.ts

@@ -0,0 +1,38 @@
+import { AnalyticsInstance } from 'analytics';
+import { DotCMSAnalyticsConfig } from '../../shared/models';
+/**
+ * Impression Plugin for DotAnalytics
+ * Handles automatic tracking of content visibility and impressions.
+ * Only activates when config.impressions is enabled (true or config object).
+ *
+ * This plugin initializes the impression tracker which:
+ * - Uses IntersectionObserver to detect when contentlets are visible
+ * - Tracks dwell time (how long elements are visible)
+ * - Fires 'content-impression' events via instance.track()
+ * - Deduplicates impressions per session
+ *
+ * Plugin execution in Analytics.js pipeline:
+ * 1. Identity Plugin - Injects context
+ * 2. Enricher Plugin - Enriches event data
+ * 3. Main Plugin - Sends to queue/server
+ * 4. Impression Plugin - Runs independently, fires events via instance.track()
+ *
+ * @param {DotCMSAnalyticsConfig} config - Configuration with impressions settings
+ * @returns {Object} Plugin object with lifecycle methods
+ */
+export declare const dotAnalyticsImpressionPlugin: (config: DotCMSAnalyticsConfig) => {
+    name: string;
+    /**
+     * Initialize impression tracking if enabled
+     * 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/impression/dot-analytics.impression.plugin.js

@@ -0,0 +1,35 @@
+import { DotCMSImpressionTracker as t } from "../../shared/dot-content-analytics.impression-tracker.js";
+const a = (n) => {
+  let e = null, i = null;
+  return {
+    name: "dot-analytics-impression",
+    /**
+     * Initialize impression tracking if enabled
+     * Called when Analytics.js initializes the plugin with instance context
+     * @param instance - Analytics.js instance with track method
+     */
+    initialize: ({ instance: s }) => (n.impressions ? (e = new t(n), e.initialize(), i = e.onImpression((o, r) => {
+      s.track(o, r);
+    }), n.debug && console.warn("DotCMS Analytics: Impression tracking plugin initialized")) : n.debug && console.warn(
+      "DotCMS Analytics: Impression tracking disabled (config.impressions not set)"
+    ), Promise.resolve()),
+    /**
+     * Setup cleanup handlers when plugin is loaded
+     * Called after Analytics.js completes plugin loading
+     */
+    loaded: () => {
+      if (typeof window < "u" && e) {
+        const s = () => {
+          i && (i.unsubscribe(), i = null), e && (e.cleanup(), e = null, n.debug && console.warn(
+            "DotCMS Analytics: Impression tracking cleaned up on page unload"
+          ));
+        };
+        window.addEventListener("beforeunload", s), window.addEventListener("pagehide", s);
+      }
+      return !0;
+    }
+  };
+};
+export {
+  a as dotAnalyticsImpressionPlugin
+};

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

@@ -0,0 +1,51 @@
+import { ViewportMetrics } from '../../shared/models';
+/**
+ * Calculates the visibility ratio of an element in the viewport
+ * @param element - The HTML element to check
+ * @returns A number between 0 and 1 representing the visible percentage
+ */
+export declare function calculateElementVisibilityRatio(element: HTMLElement): number;
+/**
+ * Calculates the offset percentage of an element from the top of the viewport
+ * @param element - The HTML element to check
+ * @returns Percentage value (can be negative if above viewport)
+ */
+export declare function calculateViewportOffset(element: HTMLElement): number;
+/**
+ * Checks if an element meets a specific visibility threshold
+ * @param element - The HTML element to check
+ * @param threshold - The required visibility ratio (0.0 to 1.0)
+ * @returns True if the element meets or exceeds the threshold
+ */
+export declare function isElementMeetingVisibilityThreshold(element: HTMLElement, threshold: number): boolean;
+/**
+ * Gets comprehensive viewport metrics for an element
+ * @param element - The HTML element to analyze
+ * @returns Object containing offset percentage and visibility ratio
+ */
+export declare function getViewportMetrics(element: HTMLElement): ViewportMetrics;
+/**
+ * Creates a debounced version of a callback function
+ * @param callback - The function to debounce
+ * @param delayMs - The delay in milliseconds
+ * @returns A debounced function that shares the same timer reference
+ */
+export declare function createDebounce(callback: () => void, delayMs: number): () => void;
+/**
+ * Extracts the contentlet identifier from a DOM element
+ * @param element - The HTML element containing data attributes
+ * @returns The contentlet identifier or null if not found
+ */
+export declare function extractContentletIdentifier(element: HTMLElement): string | null;
+/**
+ * Extracts all contentlet data from a DOM element's data attributes
+ * @param element - The HTML element containing data attributes
+ * @returns Complete contentlet data object
+ */
+export declare function extractContentletData(element: HTMLElement): {
+    identifier: string;
+    inode: string;
+    contentType: string;
+    title: string;
+    baseType: string;
+};

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

@@ -0,0 +1,50 @@
+function r(t) {
+  const e = t.getBoundingClientRect(), i = window.innerHeight || document.documentElement.clientHeight, n = window.innerWidth || document.documentElement.clientWidth, o = Math.min(e.bottom, i) - Math.max(e.top, 0), c = Math.min(e.right, n) - Math.max(e.left, 0);
+  if (o <= 0 || c <= 0)
+    return 0;
+  const s = o * c, a = e.height * e.width;
+  return a > 0 ? s / a : 0;
+}
+function l(t) {
+  const e = t.getBoundingClientRect(), i = window.innerHeight || document.documentElement.clientHeight, n = e.top / i * 100;
+  return Math.round(n * 100) / 100;
+}
+function d(t, e) {
+  return r(t) >= e;
+}
+function u(t) {
+  const e = r(t);
+  return {
+    offsetPercentage: l(t),
+    visibilityRatio: e
+  };
+}
+function f(t, e) {
+  let i = null;
+  return () => {
+    i !== null && window.clearTimeout(i), i = window.setTimeout(() => {
+      t(), i = null;
+    }, e);
+  };
+}
+function h(t) {
+  return t.dataset.dotAnalyticsIdentifier || null;
+}
+function g(t) {
+  return {
+    identifier: t.dataset.dotAnalyticsIdentifier || "",
+    inode: t.dataset.dotAnalyticsInode || "",
+    contentType: t.dataset.dotAnalyticsContenttype || "",
+    title: t.dataset.dotAnalyticsTitle || "",
+    baseType: t.dataset.dotAnalyticsBasetype || ""
+  };
+}
+export {
+  r as calculateElementVisibilityRatio,
+  l as calculateViewportOffset,
+  f as createDebounce,
+  g as extractContentletData,
+  h as extractContentletIdentifier,
+  u as getViewportMetrics,
+  d as isElementMeetingVisibilityThreshold
+};