@dotcms/analytics 1.2.0-next.1 → 1.2.0-next.10

package/README.md

@@ -108,13 +108,15 @@ track(eventName: string, properties?: Record<string, unknown>): void
 
 ## ⚙️ Configuration Options
 
-| Option | Type | Required | Default | Description |
-| -------------- | --------- | -------- | ----------------------------------- | -------------------------------------- |
-| `siteAuth` | `string` | ✅ | - | Site auth from dotCMS Analytics app |
-| `server` | `string` | ✅ | - | Your dotCMS server URL |
-| `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 |
+| Option         | Type                        | Required | Default                             | Description                                                      |
+| -------------- | --------------------------- | -------- | ----------------------------------- | ---------------------------------------------------------------- |
+| `siteAuth`     | `string`                    | ✅       | -                                   | Site auth from dotCMS Analytics app                              |
+| `server`       | `string`                    | ✅       | -                                   | Your dotCMS server URL                                           |
+| `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)                |
+| `clicks`       | `boolean`                   | ❌       | `false`                             | Content click tracking with 300ms throttle (disabled by default) |
 
 ### Queue Configuration
 
@@ -168,6 +170,194 @@ 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)
+});
+```
+
+### Click Tracking Configuration
+
+The `clicks` option controls automatic tracking of user interactions with content elements:
+
+-   **`false` or `undefined` (default)**: Click tracking disabled
+-   **`true`**: Enable tracking with default settings (300ms throttle)
+
+**How it works:**
+
+-   ✅ Tracks clicks on `<a>` and `<button>` elements within contentlets
+-   ✅ Contentlets must be marked with `dotcms-analytics-contentlet` class and `data-dot-analytics-*` attributes
+-   ✅ Captures semantic attributes (`href`, `aria-label`, `data-*`) and excludes CSS classes
+-   ✅ Throttles rapid clicks to prevent duplicate tracking (300ms fixed)
+-   ✅ One click event per interaction
+-   ✅ Respects user consent settings
+-   ✅ Automatically disabled in dotCMS editor mode
+
+**Captured Data:**
+
+For each click, the SDK captures:
+
+-   **Content Info**: `identifier`, `inode`, `title`, `content_type`
+-   **Element Info**:
+    -   `text` - Button/link text (truncated to 100 chars)
+    -   `type` - Element type (`a` or `button`)
+    -   `id` - Element ID (required by backend, empty string if not present)
+    -   `class` - Element CSS classes (required by backend, empty string if not present)
+    -   `href` - Link destination as written in HTML (e.g., `/signup` not `http://...`, only for `<a>`, empty string for buttons)
+    -   `attributes` - Additional useful attributes (see below)
+-   **Position Info**:
+    -   `viewport_offset_pct` - Position relative to viewport (0-100%)
+    -   `dom_index` - Element position in DOM
+
+**Attributes Array:**
+
+> **Note**: The `attributes` field is formatted as an array of `'key:value'` strings (e.g., `['data-category:primary-cta', 'aria-label:Sign up']`) for efficient serialization and backend parsing.
+
+The `attributes` array captures additional semantic data in `'key:value'` string format:
+
+✅ **Included** (semantic/analytics value):
+
+-   `data-*` - Custom data attributes (e.g., `'data-category:primary-cta'`)
+-   `aria-*` - Accessibility attributes (e.g., `'aria-label:Sign up now'`)
+-   `title` - Element title
+-   `target` - Link target (e.g., `'target:_blank'`)
+-   Any other standard HTML attributes
+
+❌ **Excluded** (to avoid duplication):
+
+-   `class` - Already captured as top-level property
+-   `id` - Already captured as top-level property
+-   `href` - Already captured as top-level property
+-   `data-dot-analytics-*` - Internal SDK attributes
+
+**Example: Enable click tracking**
+
+```javascript
+const analytics = initializeContentAnalytics({
+    siteAuth: 'abc123',
+    server: 'https://your-dotcms.com',
+    clicks: true // Enable with 300ms throttle (fixed)
+});
+```
+
+**Example: Adding Custom Analytics Metadata**
+
+Use `data-*` attributes to enrich click tracking with custom metadata:
+
+```html
+<!-- Primary CTA with category -->
+<a
+    href="/signup"
+    id="cta-signup"
+    data-category="primary-cta"
+    data-campaign="summer-sale"
+    aria-label="Sign up for free trial">
+    Start Free Trial →
+</a>
+
+<!-- Product link with metadata -->
+<a href="/products/123" data-product-id="123" data-product-name="Premium Plan" data-price="29.99">
+    View Product
+</a>
+
+<!-- Button with custom tracking -->
+<button data-action="download" data-file-type="pdf" data-category="lead-magnet">
+    Download Whitepaper
+</button>
+```
+
+**Resulting Click Event:**
+
+```json
+{
+    "content": {
+        "identifier": "abc123",
+        "inode": "xyz789",
+        "title": "Product Page",
+        "content_type": "Page"
+    },
+    "element": {
+        "text": "Start Free Trial →",
+        "type": "a",
+        "id": "cta-signup",
+        "class": "btn btn-primary text-white",
+        "href": "/signup",
+        "attributes": [
+            "data-category:primary-cta",
+            "data-campaign:summer-sale",
+            "aria-label:Sign up for free trial",
+            "target:_blank"
+        ]
+    },
+    "position": {
+        "viewport_offset_pct": 45.2,
+        "dom_index": 2
+    }
+}
+```
+
+**Example: Disable tracking**
+
+```javascript
+const analytics = initializeContentAnalytics({
+    siteAuth: 'abc123',
+    server: 'https://your-dotcms.com',
+    clicks: false // Explicitly disabled (also default if omitted)
+});
+```
+
 ## 🛠️ Usage Examples
 
 ### Vanilla JavaScript

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

@@ -0,0 +1,63 @@
+import { Analytics as c } from "analytics";
+import { ANALYTICS_WINDOWS_ACTIVE_KEY as r, ANALYTICS_WINDOWS_CLEANUP_KEY as l } from "../../uve/src/internal/constants.js";
+import { dotAnalyticsClickPlugin as d } from "./plugin/click/dot-analytics.click.plugin.js";
+import { dotAnalyticsEnricherPlugin as m } from "./plugin/enricher/dot-analytics.enricher.plugin.js";
+import { dotAnalyticsIdentityPlugin as u } from "./plugin/identity/dot-analytics.identity.plugin.js";
+import { dotAnalyticsImpressionPlugin as p } from "./plugin/impression/dot-analytics.impression.plugin.js";
+import { dotAnalytics as y } from "./plugin/main/dot-analytics.plugin.js";
+import { validateAnalyticsConfig as A, getEnhancedTrackingPlugins as f } from "./shared/utils/dot-analytics.utils.js";
+import { cleanupActivityTracking as w } from "./plugin/identity/dot-analytics.identity.activity-tracker.js";
+const v = (n) => {
+  const o = A(n);
+  if (o)
+    return console.error(
+      `DotCMS Analytics [Core]: Missing ${o.join(" and ")} in configuration`
+    ), typeof window < "u" && (window[r] = !1), null;
+  const a = f(
+    n,
+    p,
+    d
+  ), i = c({
+    app: "dotAnalytics",
+    debug: n.debug,
+    plugins: [
+      u(n),
+      // Inject identity context
+      ...a,
+      //Track content impressions & clicks (conditionally loaded)
+      m(),
+      // Enrich and clean payload with page, device, utm data and custom data
+      y(n)
+      // Send events to server
+    ]
+  }), e = () => w();
+  return typeof window < "u" && (window.addEventListener("beforeunload", e), window[l] = e, window[r] = !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 = {}) => {
+      if (!i) {
+        console.warn("DotCMS Analytics [Core]: Analytics instance not initialized");
+        return;
+      }
+      i.page(t);
+    },
+    /**
+     * Track a custom event.
+     * @param eventName - The name of the event to track
+     * @param payload - Custom data to include with the event (any valid JSON object)
+     */
+    track: (t, s = {}) => {
+      if (!i) {
+        console.warn("DotCMS Analytics [Core]: Analytics instance not initialized");
+        return;
+      }
+      i.track(t, s);
+    }
+  };
+};
+export {
+  v as initializeContentAnalytics
+};

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

@@ -0,0 +1,108 @@
+import { DotCMSAnalyticsConfig, DotCMSContentClickPayload } from '../../shared/models';
+/** Callback function for click events */
+export type ClickCallback = (eventName: string, payload: DotCMSContentClickPayload) => void;
+/** Subscription object with unsubscribe method */
+export interface ClickSubscription {
+    unsubscribe: () => void;
+}
+/**
+ * Tracks content clicks using event listeners on contentlet containers.
+ * Detects clicks on <a> and <button> elements inside contentlets and fires events.
+ *
+ * Features:
+ * - Attaches event listeners to contentlet containers
+ * - Tracks clicks on anchor and button elements only
+ * - Uses MutationObserver to detect dynamically added content
+ * - Throttles rapid clicks to prevent duplicates (300ms)
+ * - Subscription-based event system for decoupling
+ *
+ * @example
+ * ```typescript
+ * const tracker = new DotCMSClickTracker(config);
+ * const subscription = tracker.onClick((eventName, payload) => {
+ *   console.log('Click detected:', payload);
+ * });
+ * tracker.initialize();
+ * // Later: subscription.unsubscribe();
+ * ```
+ */
+export declare class DotCMSClickTracker {
+    private config;
+    private mutationObserver;
+    private lastClickTime;
+    private logger;
+    private subscribers;
+    private trackedElements;
+    private elementHandlers;
+    constructor(config: DotCMSAnalyticsConfig);
+    /**
+     * Subscribe to click events
+     * @param callback - Function called when click is detected
+     * @returns Subscription object with unsubscribe method
+     */
+    onClick(callback: ClickCallback): ClickSubscription;
+    /**
+     * 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
+     */
+    private notifySubscribers;
+    /**
+     * 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(): void;
+    /**
+     * 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
+     */
+    private attachClickListener;
+    /**
+     * 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.
+     */
+    private findAndAttachListeners;
+    /**
+     * Initialize MutationObserver to detect new contentlet containers
+     * Uses same simple strategy as impression tracker - no complex filtering
+     */
+    private initializeMutationObserver;
+    /**
+     * Remove all click listeners from tracked contentlets
+     *
+     * Iterates through all contentlet elements and removes their
+     * click event handlers, cleaning up WeakMap references.
+     */
+    private removeAllListeners;
+    /**
+     * 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(): void;
+}

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
+};