@dotcms/analytics 1.1.1 → 1.2.0-next.10

package/lib/core/shared/utils/dot-analytics.utils.d.ts

@@ -0,0 +1,260 @@
+import { AnalyticsPlugin, PageData } from 'analytics';
+import { DotCMSPredefinedEventType } from '../constants';
+import { DotLogger, LogLevel } from '../dot-analytics.logger';
+import { AnalyticsBasePayloadWithContext, ContentletData, DotCMSAnalyticsConfig, DotCMSAnalyticsEventContext, DotCMSBrowserData, DotCMSEventDeviceData, DotCMSEventUtmData, EnrichedAnalyticsPayload } from '../models';
+export { cleanupActivityTracking, initializeActivityTracking, updateSessionActivity } from '../../plugin/identity/dot-analytics.identity.activity-tracker';
+/**
+ * Type guard to check if an event is a predefined event type.
+ * Enables TypeScript type narrowing for better type safety.
+ *
+ * @param event - Event name to check
+ * @returns True if event is a predefined type, false for custom events
+ *
+ * @example
+ * ```typescript
+ * if (isPredefinedEventType(eventName)) {
+ *   // TypeScript knows eventName is DotCMSPredefinedEventType here
+ *   console.log('Predefined event:', eventName);
+ * } else {
+ *   // TypeScript knows eventName is string (custom) here
+ *   console.log('Custom event:', eventName);
+ * }
+ * ```
+ */
+export declare function isPredefinedEventType(event: string): event is DotCMSPredefinedEventType;
+/**
+ * Validates required configuration fields for Analytics initialization.
+ *
+ * @param config - The analytics configuration to validate
+ * @returns Array of missing field names, or null if all required fields are present
+ *
+ * @example
+ * ```ts
+ * const missing = validateAnalyticsConfig(config);
+ * if (missing) {
+ *   console.error(`Missing: ${missing.join(' and ')}`);
+ * }
+ * ```
+ */
+export declare function validateAnalyticsConfig(config: DotCMSAnalyticsConfig): string[] | null;
+/**
+ * Generates a cryptographically secure random ID.
+ * @internal This function is for internal use only and should not be used outside of the SDK.
+ * @param prefix - The prefix for the generated ID
+ * @returns A unique ID string with the given prefix
+ */
+export declare const generateSecureId: (prefix: string) => string;
+/**
+ * Safe sessionStorage wrapper with error handling
+ */
+export declare const safeSessionStorage: {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+};
+/**
+ * Gets or generates a user ID from localStorage.
+ * @internal This function is for internal use only.
+ * @returns The user ID string
+ */
+export declare const getUserId: () => string;
+/**
+ * Gets session ID with comprehensive lifecycle management.
+ * Returns existing valid session ID or creates a new one if needed.
+ * @internal This function is for internal use only.
+ *
+ * Session validation criteria:
+ * 1. User is still active (< 30 min inactivity)
+ * 2. Session hasn't passed midnight (UTC)
+ *
+ * @returns The session ID string
+ */
+export declare const getSessionId: () => string;
+/**
+ * Gets analytics context with user and session identification.
+ * Used by the identity plugin to inject context into analytics events.
+ *
+ * @param config - The analytics configuration object
+ * @returns The analytics context with site_key, session_id, and user_id
+ */
+export declare const getAnalyticsContext: (config: DotCMSAnalyticsConfig) => DotCMSAnalyticsEventContext;
+/**
+ * Configuration result with warnings for analytics setup
+ */
+export interface AnalyticsConfigResult {
+    config: DotCMSAnalyticsConfig;
+    warnings?: string[];
+    missingAttributes?: string[];
+    hasIssues: boolean;
+}
+/**
+ * Gets analytics configuration from script tag attributes.
+ * Always returns a config (with defaults if needed).
+ *
+ * - If no data-analytics-server attribute is found, uses the current domain as the server endpoint
+ * - Both debug and autoPageView default to false (must be explicitly set to "true")
+ *
+ * @returns The analytics configuration object
+ */
+export declare const getAnalyticsConfig: () => DotCMSAnalyticsConfig;
+/**
+ * Gets current device data for analytics.
+ * Combines static browser data with dynamic viewport information.
+ * Used by the identity plugin to inject device data into context.
+ *
+ * @returns Device data with screen resolution, language, and viewport dimensions
+ */
+export declare const getDeviceDataForContext: () => DotCMSEventDeviceData;
+/**
+ * Retrieves the browser event data - optimized but accurate.
+ * @internal This function is for internal use only.
+ * @param location - The Location object to extract data from
+ * @returns Browser event data with all relevant information
+ */
+export declare const getBrowserEventData: (location: Location) => DotCMSBrowserData;
+/**
+ * Extracts and transforms UTM parameters from the URL - cached for performance.
+ * Returns UTM data in DotCMS format (without 'utm_' prefix).
+ * @internal This function is for internal use only.
+ * @param location - The Location object to extract UTM parameters from
+ * @returns DotCMSEventUtmData object with transformed UTM parameters (source, medium, campaign, etc.)
+ */
+export declare const extractUTMParameters: (location: Location) => DotCMSEventUtmData;
+/**
+ * Default redirect function.
+ * @internal This function is for internal use only.
+ * @param href - The URL to redirect to
+ */
+export declare const defaultRedirectFn: (href: string) => string;
+/**
+ * Gets local time in ISO format without milliseconds.
+ * Used by enricher plugins to add local_time to events.
+ *
+ * @returns Local time string in ISO 8601 format with timezone offset (e.g., "2024-01-01T12:00:00-05:00")
+ */
+export declare const getLocalTime: () => string;
+/**
+ * Gets page data from browser event data and payload.
+ * @internal This function is for internal use only.
+ * @param browserData - Browser event data
+ * @param payload - Payload with properties
+ * @returns PageData object for Analytics.js
+ */
+export declare const getPageData: (browserData: DotCMSBrowserData, payload: {
+    properties: Record<string, unknown>;
+}) => PageData;
+/**
+ * Gets device data from browser event data.
+ * @internal This function is for internal use only.
+ * @param browserData - Browser event data
+ * @returns Device data with screen resolution, language, and viewport dimensions
+ */
+export declare const getDeviceData: (browserData: DotCMSBrowserData) => DotCMSEventDeviceData;
+/**
+ * Gets UTM data from browser event data.
+ * @internal This function is for internal use only.
+ * @param browserData - Browser event data
+ * @returns UTM data with source, medium, campaign, etc.
+ */
+export declare const getUtmData: (browserData: DotCMSBrowserData) => DotCMSEventUtmData;
+/**
+ * Enriches payload with UTM data.
+ * @internal This function is for internal use only.
+ * @param payload - The payload to enrich
+ * @returns The payload with UTM data added
+ */
+export declare const enrichWithUtmData: <T extends Record<string, unknown>>(payload: T) => T;
+/**
+ * Optimized payload enrichment using existing analytics.js data.
+ * Filters out Analytics.js default properties and only keeps user-provided properties in custom.
+ * Used by the enricher plugin to transform Analytics.js payload into DotCMS event format.
+ *
+ * @param payload - The Analytics.js payload with context already injected by identity plugin
+ * @param location - The Location object to extract page data from (defaults to window.location)
+ * @returns Enriched payload with page, UTM, custom data, and local_time (device is in context)
+ */
+export declare const enrichPagePayloadOptimized: (payload: AnalyticsBasePayloadWithContext, location?: Location) => EnrichedAnalyticsPayload;
+/**
+ * Legacy function that enriches page payload with all data in one call.
+ * @internal This function is for internal use only.
+ * @param payload - The payload to enrich
+ * @param location - The Location object to extract data from
+ * @returns Object with enriched payload
+ */
+export declare const enrichPagePayload: (payload: {
+    properties: Record<string, unknown>;
+} & Record<string, unknown>, location?: Location) => {
+    payload: {
+        local_time: string;
+        utm?: DotCMSEventUtmData | undefined;
+        page: PageData;
+        device: DotCMSEventDeviceData;
+        properties: Record<string, unknown>;
+    };
+};
+/**
+ * Creates a throttled version of a callback function
+ * Ensures the callback is executed at most once every `limitMs` milliseconds
+ * @param callback - The function to throttle
+ * @param limitMs - The time limit in milliseconds
+ * @returns A throttled function
+ */
+export declare function createThrottle<T extends (...args: unknown[]) => void>(callback: T, limitMs: number): (...args: Parameters<T>) => 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): ContentletData;
+/**
+ * Initial scan delay for DOM readiness
+ * Allows React/Next.js to finish rendering before scanning for contentlets
+ */
+export declare const INITIAL_SCAN_DELAY_MS = 100;
+/**
+ * Checks if code is running in a browser environment
+ * @returns true if window and document are available
+ */
+export declare const isBrowser: () => boolean;
+/**
+ * Finds all contentlet elements in the DOM
+ * @returns Array of contentlet HTMLElements
+ */
+export declare const findContentlets: () => HTMLElement[];
+/**
+ * Creates a MutationObserver that watches for contentlet changes in the DOM
+ * @param callback - Function to call when mutations are detected
+ * @param debounceMs - Debounce time in milliseconds (default: 250ms)
+ * @returns Configured and active MutationObserver
+ */
+export declare const createContentletObserver: (callback: () => void, debounceMs?: number) => MutationObserver;
+/**
+ * Sets up cleanup handlers for page unload events
+ * Registers cleanup function to both 'beforeunload' and 'pagehide' for maximum compatibility
+ * @param cleanup - Function to call on page unload
+ */
+export declare const setupPluginCleanup: (cleanup: () => void) => void;
+/**
+ * Creates a logger with plugin-specific prefix and configurable log level
+ * @param pluginName - Name of the plugin (e.g., 'Click', 'Impression')
+ * @param config - Analytics configuration with debug flag and optional logLevel
+ * @returns DotLogger instance with configured log level
+ */
+export declare const createPluginLogger: (pluginName: string, config: {
+    debug: boolean;
+    logLevel?: LogLevel;
+}) => DotLogger;
+/**
+ * Gets enhanced tracking plugins based on configuration
+ * Returns content impression and click tracking plugins if enabled
+ * @param config - Analytics configuration
+ * @param impressionPlugin - Impression tracking plugin factory
+ * @param clickPlugin - Click tracking plugin factory
+ * @returns Array of enabled tracking plugins
+ */
+export declare const getEnhancedTrackingPlugins: (config: DotCMSAnalyticsConfig, impressionPlugin: (config: DotCMSAnalyticsConfig) => AnalyticsPlugin, clickPlugin: (config: DotCMSAnalyticsConfig) => AnalyticsPlugin) => AnalyticsPlugin[];

package/lib/core/shared/utils/dot-analytics.utils.js

@@ -0,0 +1,202 @@
+import { ANALYTICS_JS_DEFAULT_PROPERTIES as T, SESSION_STORAGE_KEY as h, DEFAULT_SESSION_TIMEOUT_MINUTES as y, USER_ID_KEY as w, DEFAULT_IMPRESSION_MUTATION_OBSERVER_DEBOUNCE_MS as I, EXPECTED_UTM_KEYS as D, ANALYTICS_CONTENTLET_CLASS as S } from "../constants/dot-analytics.constants.js";
+import { DotLogger as E } from "../dot-analytics.logger.js";
+import "../../../../uve/src/internal/constants.js";
+function Y(t) {
+  var n, s;
+  const e = [];
+  return (n = t.siteAuth) != null && n.trim() || e.push('"siteAuth"'), (s = t.server) != null && s.trim() || e.push('"server"'), e.length > 0 ? e : null;
+}
+let u = null, l = null;
+const g = (t) => {
+  const e = Date.now(), n = Math.random().toString(36).substr(2, 9), s = Math.random().toString(36).substr(2, 9);
+  return `${t}_${e}_${n}${s}`;
+}, _ = {
+  getItem: (t) => {
+    try {
+      return localStorage.getItem(t);
+    } catch {
+      return null;
+    }
+  },
+  setItem: (t, e) => {
+    try {
+      localStorage.setItem(t, e);
+    } catch {
+      console.warn(`DotCMS Analytics [Core]: Could not save ${t} to localStorage`);
+    }
+  }
+}, A = () => {
+  let t = _.getItem(w);
+  return t || (t = g("user"), _.setItem(w, t)), t;
+}, C = (t) => {
+  const e = new Date(t), n = /* @__PURE__ */ new Date(), s = new Date(
+    e.getUTCFullYear(),
+    e.getUTCMonth(),
+    e.getUTCDate()
+  ), r = new Date(n.getUTCFullYear(), n.getUTCMonth(), n.getUTCDate());
+  return s.getTime() !== r.getTime();
+}, v = () => {
+  const t = Date.now();
+  if (typeof window > "u")
+    return g("session_fallback");
+  try {
+    const e = sessionStorage.getItem(h);
+    if (e) {
+      const { sessionId: r, startTime: o, lastActivity: a } = JSON.parse(e), i = !C(o), c = t - a < y * 60 * 1e3;
+      if (i && c)
+        return sessionStorage.setItem(
+          h,
+          JSON.stringify({
+            sessionId: r,
+            startTime: o,
+            lastActivity: t
+          })
+        ), r;
+    }
+    const n = g("session"), s = {
+      sessionId: n,
+      startTime: t,
+      lastActivity: t
+    };
+    return sessionStorage.setItem(h, JSON.stringify(s)), n;
+  } catch {
+    return g("session_fallback");
+  }
+}, x = (t) => {
+  const e = v(), n = A(), s = O();
+  return {
+    site_auth: t.siteAuth,
+    session_id: e,
+    user_id: n,
+    device: s
+  };
+}, p = () => u || (u = {
+  user_language: navigator.language,
+  doc_encoding: document.characterSet || document.charset,
+  screen_resolution: typeof screen < "u" && screen.width && screen.height ? `${screen.width}x${screen.height}` : ""
+}, u), O = () => {
+  const t = p(), e = window.innerWidth || document.documentElement.clientWidth || 0, n = window.innerHeight || document.documentElement.clientHeight || 0;
+  return {
+    screen_resolution: t.screen_resolution ?? "",
+    language: t.user_language ?? "",
+    viewport_width: String(e),
+    viewport_height: String(n)
+  };
+}, N = (t) => {
+  const e = t.search;
+  if (l && l.search === e)
+    return l.params;
+  const n = new URLSearchParams(e), s = {};
+  return D.forEach((r) => {
+    const o = n.get(r);
+    if (o) {
+      const a = r.replace("utm_", "");
+      s[a] = o;
+    }
+  }), l = { search: e, params: s }, s;
+}, b = () => {
+  try {
+    const t = (/* @__PURE__ */ new Date()).getTimezoneOffset(), e = t > 0 ? "-" : "+", n = Math.abs(t), s = Math.floor(n / 60), r = n % 60;
+    return `${e}${s.toString().padStart(2, "0")}:${r.toString().padStart(2, "0")}`;
+  } catch {
+    return "+00:00";
+  }
+}, M = () => {
+  try {
+    const t = /* @__PURE__ */ new Date(), e = b(), n = t.getFullYear(), s = (t.getMonth() + 1).toString().padStart(2, "0"), r = t.getDate().toString().padStart(2, "0"), o = t.getHours().toString().padStart(2, "0"), a = t.getMinutes().toString().padStart(2, "0"), i = t.getSeconds().toString().padStart(2, "0");
+    return `${n}-${s}-${r}T${o}:${a}:${i}${e}`;
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+}, B = (t, e = typeof window < "u" ? window.location : {}) => {
+  const n = M(), s = p(), { properties: r } = t, o = {};
+  Object.keys(r).forEach((c) => {
+    T.includes(c) || (o[c] = r[c]);
+  });
+  const a = {
+    url: e.href,
+    doc_encoding: s.doc_encoding,
+    doc_hash: e.hash,
+    doc_protocol: e.protocol,
+    doc_search: e.search,
+    doc_host: e.hostname,
+    doc_path: e.pathname,
+    title: r.title ?? (document == null ? void 0 : document.title)
+  }, i = N(e);
+  return {
+    ...t,
+    page: a,
+    ...Object.keys(i).length > 0 && { utm: i },
+    // Only include custom if there are user-provided properties
+    ...Object.keys(o).length > 0 && { custom: o },
+    local_time: n
+  };
+};
+function L(t, e) {
+  let n = 0;
+  return (...s) => {
+    const r = Date.now();
+    r - n >= e && (t(...s), n = r);
+  };
+}
+function F(t) {
+  return t.dataset.dotAnalyticsIdentifier || null;
+}
+function k(t) {
+  return {
+    identifier: t.dataset.dotAnalyticsIdentifier || "",
+    inode: t.dataset.dotAnalyticsInode || "",
+    contentType: t.dataset.dotAnalyticsContenttype || "",
+    title: t.dataset.dotAnalyticsTitle || "",
+    baseType: t.dataset.dotAnalyticsBasetype || ""
+  };
+}
+const z = 100, U = () => typeof window < "u" && typeof document < "u", H = () => Array.from(document.querySelectorAll(`.${S}`)), J = (t, e = I) => {
+  const n = L(t, e), s = new MutationObserver((r) => {
+    r.some((a) => a.addedNodes.length === 0 && a.removedNodes.length === 0 ? !1 : [
+      ...Array.from(a.addedNodes),
+      ...Array.from(a.removedNodes)
+    ].some((c) => {
+      var f, m;
+      if (c.nodeType !== Node.ELEMENT_NODE)
+        return !1;
+      const d = c;
+      return (f = d.classList) != null && f.contains(S) ? !0 : ((m = d.querySelector) == null ? void 0 : m.call(d, `.${S}`)) !== null;
+    })) && n();
+  });
+  return s.observe(document.body, {
+    childList: !0,
+    subtree: !0,
+    attributes: !1,
+    characterData: !1
+  }), s;
+}, K = (t) => {
+  U() && (window.addEventListener("beforeunload", t), window.addEventListener("pagehide", t));
+}, j = (t, e) => {
+  const n = e.logLevel ?? (e.debug ? "debug" : "warn");
+  return new E("Analytics", t, n);
+}, W = (t, e, n) => [
+  t.impressions && e(t),
+  t.clicks && n(t)
+].filter(Boolean);
+export {
+  z as INITIAL_SCAN_DELAY_MS,
+  J as createContentletObserver,
+  j as createPluginLogger,
+  L as createThrottle,
+  B as enrichPagePayloadOptimized,
+  k as extractContentletData,
+  F as extractContentletIdentifier,
+  N as extractUTMParameters,
+  H as findContentlets,
+  g as generateSecureId,
+  x as getAnalyticsContext,
+  O as getDeviceDataForContext,
+  W as getEnhancedTrackingPlugins,
+  M as getLocalTime,
+  v as getSessionId,
+  A as getUserId,
+  U as isBrowser,
+  K as setupPluginCleanup,
+  Y as validateAnalyticsConfig
+};

package/lib/react/components/DotContentAnalytics.d.ts

@@ -1,5 +1,5 @@
 import { ReactElement } from 'react';
-import { DotCMSAnalyticsConfig } from '../../core/shared/dot-content-analytics.model';
+import { DotCMSAnalyticsConfig } from '../../core/shared/models';
 /**
  * Client bootstrapper for dotCMS Analytics in React/Next.
  * - No UI: initializes the analytics singleton from props or env config.

package/lib/react/hook/useContentAnalytics.d.ts

@@ -1,29 +1,57 @@
-import { DotCMSAnalytics, DotCMSAnalyticsConfig } from '../../core/shared/dot-content-analytics.model';
+import { DotCMSAnalytics, DotCMSAnalyticsConfig } from '../../core/shared/models';
 /**
- * Custom hook that handles analytics tracking for anonymous users.
- * Provides methods to track events and page views with automatic timestamp injection.
- * Automatically disables tracking when inside the UVE editor.
+ * React hook for tracking user interactions and page views in your DotCMS application.
+ *
+ * Use this hook to add analytics tracking to your React components. It automatically
+ * handles user sessions, device information, and UTM campaign parameters.
+ *
+ * **Important:** Tracking is automatically disabled when editing content in DotCMS to avoid
+ * polluting your analytics data with editor activity.
  *
  * @example
+ * Basic usage - Track custom events
  * ```tsx
- * function Button({ title, urlTitle }) {
+ * function ProductCard({ title, price }) {
  *   const { track } = useContentAnalytics({
  *     server: 'https://demo.dotcms.com',
- *     siteKey: 'my-site-key',
+ *     siteAuth: 'my-site-auth',
  *     debug: false
  *   });
  *
- *   // Track button click with custom properties
- *   return (
- *     <button onClick={() => track('btn-click', { title, urlTitle })}>
- *       See Details →
- *     </button>
- *   );
+ *   const handleAddToCart = () => {
+ *     track('add-to-cart', {
+ *       product: title,
+ *       price: price
+ *     });
+ *   };
+ *
+ *   return <button onClick={handleAddToCart}>Add to Cart</button>;
+ * }
+ * ```
+ *
+ * @example
+ * Track page views manually
+ * ```tsx
+ * function ArticlePage({ article }) {
+ *   const { pageView } = useContentAnalytics({
+ *     server: 'https://demo.dotcms.com',
+ *     siteKey: 'your-site-key'
+ *   });
+ *
+ *   useEffect(() => {
+ *     pageView({
+ *       category: article.category,
+ *       author: article.author
+ *     });
+ *   }, [article.id]);
  * }
  * ```
  *
- * @param {DotCMSAnalyticsConfig} config - Required configuration object for analytics initialization
- * @returns {DotCMSAnalytics} The analytics instance with tracking capabilities
- * @throws {Error} When analytics initialization fails due to invalid configuration
+ * @param config - Configuration object with server URL and site key
+ * @param config.server - The URL of your DotCMS Analytics server
+ * @param config.siteKey - Your unique site key for authentication
+ * @param config.debug - Optional. Set to true to see analytics events in the console
+ * @returns Object with `track()` and `pageView()` methods for analytics tracking
+ * @throws {Error} If the configuration is invalid (missing server or siteKey)
  */
 export declare const useContentAnalytics: (config: DotCMSAnalyticsConfig) => DotCMSAnalytics;

package/lib/react/hook/useContentAnalytics.js

@@ -1,32 +1,29 @@
-import { useRef as l, useCallback as n } from "react";
-import { getUVEState as r } from "../../../uve/src/lib/core/core.utils.js";
+import { useMemo as n, useCallback as o } from "react";
+import { getUVEState as u } from "../../../uve/src/lib/core/core.utils.js";
 import "../../../uve/src/internal/constants.js";
-import { initializeAnalytics as f } from "../internal/utils.js";
-const g = (o) => {
-  const t = f(o), i = l(null);
+import { initializeAnalytics as l } from "../internal/utils.js";
+const h = (r) => {
+  const t = n(() => l(r), [r.server, r.siteAuth]), e = n(() => !!u(), []);
   if (!t)
     throw new Error(
-      "Failed to initialize DotContentAnalytics. Please verify the required configuration (server and siteKey)."
+      "DotCMS Analytics: Failed to initialize. Please verify the required configuration (server and siteAuth)."
     );
-  const a = n(
-    (e, s = {}) => {
-      r() || t.track(e, {
-        ...s,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
+  const a = o(
+    (i, c = {}) => {
+      e || t.track(i, c);
     },
-    [t]
-  ), c = n(() => {
-    if (!r()) {
-      const e = window.location.pathname;
-      e !== i.current && (i.current = e, t.pageView());
-    }
-  }, [t]);
+    [t, e]
+  ), s = o(
+    (i = {}) => {
+      e || t.pageView(i);
+    },
+    [t, e]
+  );
   return {
     track: a,
-    pageView: c
+    pageView: s
   };
 };
 export {
-  g as useContentAnalytics
+  h as useContentAnalytics
 };

package/lib/react/hook/useRouterTracker.d.ts

@@ -1,4 +1,4 @@
-import { DotCMSAnalytics } from '../../core/shared/dot-content-analytics.model';
+import { DotCMSAnalytics } from '../../core/shared/models';
 /**
  * Tracks page views on route changes using Next.js App Router signals.
  * - Fires a single pageView per unique path+search.

package/lib/react/hook/useRouterTracker.js

@@ -1,16 +1,16 @@
-import { usePathname as u, useSearchParams as p } from "next/navigation";
-import { useRef as c, useEffect as m } from "react";
+import { usePathname as u, useSearchParams as c } from "next/navigation";
+import { useRef as p, useEffect as m } from "react";
 import { getUVEState as s } from "../../../uve/src/lib/core/core.utils.js";
 import "../../../uve/src/internal/constants.js";
 const g = (e, t) => `${e}${t != null && t.toString() ? "?" + t.toString() : ""}`;
 function A(e, t = !1) {
-  const o = c(null), n = u(), r = p();
+  const o = p(null), n = u(), r = c();
   m(() => {
     if (!e) return;
     const i = (f) => {
       s() || f !== o.current && (o.current = f, e.pageView());
     };
-    t && console.info("DotContentAnalytics: using Next.js App Router tracking"), i(g(n, r));
+    t && console.info("DotCMS Analytics [React]: using Next.js App Router tracking"), i(g(n, r));
   }, [e, n, r, t]);
 }
 export {

package/lib/react/internal/utils.d.ts

@@ -1,4 +1,4 @@
-import { DotCMSAnalytics, DotCMSAnalyticsConfig } from '../../core/shared/dot-content-analytics.model';
+import { DotCMSAnalytics, DotCMSAnalyticsConfig } from '../../core/shared/models';
 /**
  * Initializes analytics with explicit configuration.
  * Resets singleton if config changes.

package/lib/react/internal/utils.js

@@ -1,6 +1,6 @@
-import { initializeContentAnalytics as r } from "../../core/dot-content-analytics.js";
-let e, t;
-const s = (i) => (t && (t.server !== i.server || t.siteKey !== i.siteKey) && (e = void 0), e !== void 0 || (t = i, e = r(i)), e);
+import { initializeContentAnalytics as r } from "../../core/dot-analytics.content.js";
+let t, i;
+const s = (e) => (i && (i.server !== e.server || i.siteAuth !== e.siteAuth) && (t = void 0), t !== void 0 || (i = e, t = r(e)), t);
 export {
   s as initializeAnalytics
 };

package/lib/react/public-api.d.ts

@@ -1,3 +1,3 @@
-export type { DotCMSAnalyticsConfig } from '../core/shared/dot-content-analytics.model';
+export type { DotCMSAnalyticsConfig } from '../core/shared/models';
 export { DotContentAnalytics } from './components/DotContentAnalytics';
 export { useContentAnalytics } from './hook/useContentAnalytics';

package/lib/standalone.d.ts

@@ -1,5 +1,5 @@
-import { ANALYTICS_WINDOWS_KEY } from './core/shared/dot-content-analytics.constants';
-import { DotCMSAnalytics } from './core/shared/dot-content-analytics.model';
+import { ANALYTICS_WINDOWS_KEY } from './core/shared/constants';
+import { DotCMSAnalytics } from './core/shared/models';
 declare global {
     interface Window {
         [ANALYTICS_WINDOWS_KEY]: DotCMSAnalytics | null;