@dotcms/analytics 0.0.1-alpha.54

package/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/react';

package/index.mjs

@@ -0,0 +1,6 @@
+import { DotContentAnalyticsProvider as e } from "./lib/react/components/DotContentAnalyticsProvider.mjs";
+import { useContentAnalytics as r } from "./lib/react/hook/useContentAnalytics.mjs";
+export {
+  e as DotContentAnalyticsProvider,
+  r as useContentAnalytics
+};

package/lib/dotAnalytics/dot-content-analytics.d.ts

@@ -0,0 +1,9 @@
+import { DotAnalytics, DotContentAnalyticsConfig } from './shared/dot-content-analytics.model';
+
+/**
+ * Creates an analytics instance.
+ *
+ * @param {DotContentAnalyticsConfig} config - The configuration object for the analytics instance.
+ * @returns {DotAnalytics} - The analytics instance.
+ */
+export declare const initializeContentAnalytics: (config: DotContentAnalyticsConfig) => DotAnalytics;

package/lib/dotAnalytics/dot-content-analytics.mjs

@@ -0,0 +1,24 @@
+import { createAnalyticsInstance as o } from "./shared/dot-content-analytics.utils.mjs";
+const i = (r) => {
+  const t = o(r);
+  return {
+    /**
+     * Track a page view.
+     * @param {Record<string, unknown>} payload - The payload to track.
+     */
+    pageView: (e = {}) => {
+      t == null || t.page(e);
+    },
+    /**
+     * Track a custom event.
+     * @param {string} eventName - The name of the event to track.
+     * @param {Record<string, unknown>} payload - The payload to track.
+     */
+    track: (e, n = {}) => {
+      t == null || t.track(e, n);
+    }
+  };
+};
+export {
+  i as initializeContentAnalytics
+};

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

@@ -0,0 +1,31 @@
+import { DotAnalyticsPayload, PageViewEvent, TrackEvent } from '../shared/dot-content-analytics.model';
+
+/**
+ * Plugin that enriches the analytics payload data based on the event type.
+ * For page view events, it adds browser data like viewport size, user agent, etc.
+ * For track events, it adds custom event properties and standardizes the event format.
+ * All events are enriched with source type and anonymous ID if available.
+ */
+export declare const dotAnalyticsEnricherPlugin: {
+    name: string;
+    'page:dot-analytics': ({ payload }: {
+        payload: DotAnalyticsPayload;
+    }) => {
+        properties: PageViewEvent;
+        type: string;
+        event: string;
+        options: Record<string, unknown>;
+        userId: string | null;
+        anonymousId: string | null;
+    };
+    'track:dot-analytics': ({ payload }: {
+        payload: DotAnalyticsPayload;
+    }) => {
+        properties: TrackEvent;
+        type: string;
+        event: string;
+        options: Record<string, unknown>;
+        userId: string | null;
+        anonymousId: string | null;
+    };
+};

package/lib/dotAnalytics/plugin/dot-analytics.enricher.plugin.mjs

@@ -0,0 +1,28 @@
+import { ANALYTICS_PAGEVIEW_EVENT as n, ANALYTICS_SOURCE_TYPE as r, EventType as o } from "../shared/dot-content-analytics.constants.mjs";
+import { getBrowserEventData as i } from "../shared/dot-content-analytics.utils.mjs";
+const p = {
+  name: "enrich-dot-analytics",
+  "page:dot-analytics": ({ payload: e }) => {
+    const t = {
+      ...i(window.location),
+      ...e.properties,
+      event_type: n,
+      anonymousId: e.anonymousId || void 0,
+      src: r
+    };
+    return { ...e, properties: t };
+  },
+  "track:dot-analytics": ({ payload: e }) => {
+    const t = {
+      ...e.properties,
+      custom_event: e.event,
+      event_type: o.Track,
+      anonymousId: e.anonymousId || void 0,
+      src: r
+    };
+    return { ...e, properties: t };
+  }
+};
+export {
+  p as dotAnalyticsEnricherPlugin
+};

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

@@ -0,0 +1,31 @@
+import { DotAnalyticsParams, DotContentAnalyticsConfig } from '../shared/dot-content-analytics.model';
+
+/**
+ * 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.
+ *
+ * @param {DotAnalyticsConfig} config - Configuration object containing API key, server URL,
+ *                                     debug mode and auto page view settings
+ * @returns {Object} Plugin object with methods for initialization and event tracking
+ */
+export declare const dotAnalytics: (config: DotContentAnalyticsConfig) => {
+    name: string;
+    config: DotContentAnalyticsConfig;
+    /**
+     * Initialize the plugin
+     */
+    initialize: (params: DotAnalyticsParams) => Promise<void>;
+    /**
+     * Track a page view event
+     */
+    page: (params: DotAnalyticsParams) => Promise<void>;
+    /**
+     * Track a custom event
+     */
+    track: (params: DotAnalyticsParams) => Promise<void>;
+    /**
+     * Check if the plugin is loaded
+     */
+    loaded: () => boolean;
+};

package/lib/dotAnalytics/plugin/dot-analytics.plugin.mjs

@@ -0,0 +1,55 @@
+import { sendAnalyticsEventToServer as r } from "../shared/dot-content-analytics.http.mjs";
+const s = (a) => {
+  let n = !1;
+  return {
+    name: "dot-analytics",
+    config: a,
+    /**
+     * Initialize the plugin
+     */
+    initialize: (o) => {
+      const { config: i, payload: t } = o;
+      if (i.debug && console.warn("DotAnalytics: Initialized with config", i), n = !0, i.autoPageView) {
+        const e = {
+          ...t.properties,
+          key: i.apiKey
+        };
+        return r(e, i);
+      }
+      return Promise.resolve();
+    },
+    /**
+     * Track a page view event
+     */
+    page: (o) => {
+      const { config: i, payload: t } = o;
+      if (!n)
+        throw new Error("DotAnalytics: Plugin not initialized");
+      const e = {
+        ...t.properties,
+        key: i.apiKey
+      };
+      return r(e, i);
+    },
+    /**
+     * Track a custom event
+     */
+    track: (o) => {
+      const { config: i, payload: t } = o;
+      if (!n)
+        throw new Error("DotAnalytics: Plugin not initialized");
+      const e = {
+        ...t.properties,
+        key: i.apiKey
+      };
+      return r(e, i);
+    },
+    /**
+     * Check if the plugin is loaded
+     */
+    loaded: () => n
+  };
+};
+export {
+  s as dotAnalytics
+};

package/lib/dotAnalytics/shared/dot-content-analytics.constants.d.ts

@@ -0,0 +1,13 @@
+export declare const ANALYTICS_WINDOWS_KEY = "dotAnalytics";
+export declare const ANALYTICS_SOURCE_TYPE = "dotAnalytics";
+export declare const ANALYTICS_ENDPOINT = "/api/v1/analytics/content/event";
+export declare const ANALYTICS_PAGEVIEW_EVENT = "PAGE_REQUEST";
+export declare const ANALYTICS_TRACK_EVENT = "TRACK_EVENT";
+export declare const EXPECTED_UTM_KEYS: string[];
+/**
+ * The type of event.
+ */
+export declare enum EventType {
+    Track = "track",
+    PageView = "pageview"
+}

package/lib/dotAnalytics/shared/dot-content-analytics.constants.mjs

@@ -0,0 +1,10 @@
+const E = "dotAnalytics", c = E, a = "/api/v1/analytics/content/event", n = "PAGE_REQUEST", A = ["utm_source", "utm_medium", "utm_campaign", "utm_id"];
+var _ = /* @__PURE__ */ ((t) => (t.Track = "track", t.PageView = "pageview", t))(_ || {});
+export {
+  a as ANALYTICS_ENDPOINT,
+  n as ANALYTICS_PAGEVIEW_EVENT,
+  c as ANALYTICS_SOURCE_TYPE,
+  E as ANALYTICS_WINDOWS_KEY,
+  A as EXPECTED_UTM_KEYS,
+  _ as EventType
+};

package/lib/dotAnalytics/shared/dot-content-analytics.http.d.ts

@@ -0,0 +1,9 @@
+import { DotContentAnalyticsConfig } from './dot-content-analytics.model';
+
+/**
+ * Send an analytics event to the server
+ * @param data - The event data
+ * @param options - The options for the event
+ * @returns A promise that resolves to the response from the server
+ */
+export declare const sendAnalyticsEventToServer: (data: Record<string, unknown>, options: DotContentAnalyticsConfig) => Promise<void>;

package/lib/dotAnalytics/shared/dot-content-analytics.http.mjs

@@ -0,0 +1,22 @@
+import { ANALYTICS_ENDPOINT as o } from "./dot-content-analytics.constants.mjs";
+const a = async (n, t) => {
+  const r = {
+    ...n,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    key: t.apiKey
+  };
+  t.debug && console.warn("DotAnalytics: Event sent:", r);
+  try {
+    const e = await fetch(`${t.server}${o}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(r)
+    });
+    e.ok || console.error(`DotAnalytics: Server responded with status ${e.status}`);
+  } catch (e) {
+    console.error("DotAnalytics: Error sending event:", e);
+  }
+};
+export {
+  a as sendAnalyticsEventToServer
+};

package/lib/dotAnalytics/shared/dot-content-analytics.model.d.ts

@@ -0,0 +1,143 @@
+import { ANALYTICS_PAGEVIEW_EVENT, EventType, EXPECTED_UTM_KEYS } from './dot-content-analytics.constants';
+
+/**
+ * Configuration interface for DotAnalytics SDK.
+ *
+ * @interface DotAnalyticsConfig
+ */
+export interface DotContentAnalyticsConfig {
+    /**
+     * The URL of the Analytics server endpoint.
+     */
+    server: string;
+    /**
+     * Enable debug mode to get additional logging information.
+     */
+    debug: boolean;
+    /**
+     * Automatically track page views when set to true.
+     */
+    autoPageView?: boolean;
+    /**
+     * The API key for authenticating with the Analytics service.
+     */
+    apiKey: string;
+    /**
+     * Custom redirect function handler.
+     * When provided, this function will be called instead of the default browser redirect
+     * for handling URL redirections.
+     *
+     * @param {string} url - The URL to redirect to
+     */
+    redirectFn?: (url: string) => void;
+}
+type UTMParams = {
+    [key in (typeof EXPECTED_UTM_KEYS)[number] as key extends `utm_${infer U}` ? U : never]?: string;
+};
+interface BaseEventData {
+    anonymousId?: string;
+    src: string;
+    utc_time: string;
+    local_tz_offset: number;
+    doc_path: string;
+    doc_host: string;
+}
+export interface BrowserEventData {
+    utc_time: string;
+    local_tz_offset: number;
+    screen_resolution: string;
+    vp_size: string;
+    userAgent: string;
+    user_language: string;
+    doc_encoding: string;
+    doc_path: string;
+    doc_host: string;
+    doc_protocol: string;
+    doc_hash: string;
+    doc_search: string;
+    referrer: string;
+    page_title: string;
+    utm: UTMParams;
+}
+export interface PageViewEvent extends BaseEventData, BrowserEventData {
+    event_type: typeof ANALYTICS_PAGEVIEW_EVENT;
+}
+export interface TrackEvent {
+    event_type: 'track';
+    custom_event: string;
+    [key: string]: unknown;
+}
+export interface TrackPayload extends DotAnalyticsPayload {
+    type: EventType.Track;
+    properties: Record<string, unknown> & {
+        title: string;
+        url: string;
+        path: string;
+        hash: string;
+        search: string;
+        width: number;
+        height: number;
+        source: string;
+    };
+}
+export interface PageViewPayload extends DotAnalyticsPayload {
+    type: EventType.PageView;
+    properties: {
+        title: string;
+        url: string;
+        path: string;
+        hash: string;
+        search: string;
+        width: number;
+        height: number;
+        source: string;
+    };
+}
+/**
+ * The payload for a track event.
+ */
+export interface DotAnalyticsPayload {
+    type: string;
+    properties: {
+        title: string;
+        url: string;
+        path: string;
+        hash: string;
+        search: string;
+        width: number;
+        height: number;
+        source: string;
+    };
+    event: string;
+    options: Record<string, unknown>;
+    userId: string | null;
+    anonymousId: string | null;
+}
+/**
+ * Add ServerEvent type for HTTP layer
+ */
+export interface ServerEvent extends Record<string, unknown> {
+    timestamp: string;
+    key: string;
+}
+/**
+ * Interface for the AnalyticsTracker.
+ */
+export interface DotContentAnalyticsCustomHook {
+    track: (eventName: string, payload?: Record<string, unknown>) => void;
+}
+/**
+ * Params for the DotAnalytics plugin
+ */
+export interface DotAnalyticsParams {
+    config: DotContentAnalyticsConfig;
+    payload: DotAnalyticsPayload;
+}
+/**
+ * Shared interface for the DotAnalytics plugin
+ */
+export interface DotAnalytics {
+    pageView: (payload?: Record<string, unknown>) => void;
+    track: (eventName: string, payload?: Record<string, unknown>) => void;
+}
+export {};

package/lib/dotAnalytics/shared/dot-content-analytics.utils.d.ts

@@ -0,0 +1,48 @@
+import { BrowserEventData, DotContentAnalyticsConfig } from './dot-content-analytics.model';
+
+/**
+ * Retrieves analytics attributes from a given script element.
+ *
+ * @return {DotAnalyticsConfig | null} - The analytics attributes or null if there are no valid attributes present.
+ */
+export declare const getDataAnalyticsAttributes: (location: Location) => DotContentAnalyticsConfig;
+/**
+ * Retrieves the analytics script tag from the document.
+ *
+ * @returns {HTMLScriptElement} - The analytics script tag.
+ */
+export declare const getAnalyticsScriptTag: () => HTMLScriptElement;
+/**
+ * Retrieves the browser event data.
+ *
+ * @param {Location} location - The location object.
+ * @returns {BrowserEventData} - The browser event data.
+ */
+export declare const getBrowserEventData: (location: Location) => BrowserEventData;
+/**
+ * Extracts UTM parameters from a given URL location.
+ *
+ * @param {Location} location - The location object containing the URL.
+ * @returns {Record<string, string>} - An object containing the extracted UTM parameters.
+ */
+export declare const extractUTMParameters: (location: Location) => Record<string, string>;
+/**
+ * A function to redirect the user to a new URL.
+ *
+ * @param {string} href - The URL to redirect to.
+ * @returns {void}
+ */
+export declare const defaultRedirectFn: (href: string) => string;
+/**
+ * Checks if the current environment is inside the dotCMS editor.
+ *
+ * @returns {boolean} - True if inside the editor, false otherwise.
+ */
+export declare const isInsideEditor: () => boolean;
+/**
+ * Creates an analytics instance.
+ *
+ * @param {DotContentAnalyticsConfig} config - The configuration object for the analytics instance.
+ * @returns {Analytics | null} - The analytics instance or null if there is an error.
+ */
+export declare const createAnalyticsInstance: (config: DotContentAnalyticsConfig) => import('analytics').AnalyticsInstance | null;

package/lib/dotAnalytics/shared/dot-content-analytics.utils.mjs

@@ -0,0 +1,46 @@
+import { Analytics as i } from "../../../node_modules/analytics/lib/analytics.browser.es.mjs";
+import { EXPECTED_UTM_KEYS as a } from "./dot-content-analytics.constants.mjs";
+import { dotAnalyticsEnricherPlugin as s } from "../plugin/dot-analytics.enricher.plugin.mjs";
+import { dotAnalytics as c } from "../plugin/dot-analytics.plugin.mjs";
+const h = (e) => ({
+  utc_time: (/* @__PURE__ */ new Date()).toISOString(),
+  local_tz_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+  screen_resolution: `${window.screen.width}x${window.screen.height}`,
+  vp_size: `${window.innerWidth}x${window.innerHeight}`,
+  userAgent: navigator.userAgent,
+  user_language: navigator.language,
+  doc_encoding: document.characterSet,
+  doc_path: e.pathname,
+  doc_host: e.hostname,
+  doc_protocol: e.protocol,
+  doc_hash: e.hash,
+  doc_search: e.search,
+  referrer: document.referrer,
+  page_title: document.title,
+  utm: u(window.location)
+}), u = (e) => {
+  const o = new URLSearchParams(e.search);
+  return a.reduce(
+    (t, r) => {
+      const n = o.get(r);
+      return n !== null && (t[r.replace("utm_", "")] = n), t;
+    },
+    {}
+  );
+}, m = () => {
+  try {
+    return typeof window > "u" || !window.parent ? !1 : window.parent !== window;
+  } catch {
+    return !1;
+  }
+}, p = (e) => e.apiKey ? e.server ? i({
+  app: "dotAnalytics",
+  debug: e.debug,
+  plugins: [s, c(e)]
+}) : (console.error('DotContentAnalytics: Missing "server" in configuration'), null) : (console.error('DotContentAnalytics: Missing "apiKey" in configuration'), null);
+export {
+  p as createAnalyticsInstance,
+  u as extractUTMParameters,
+  h as getBrowserEventData,
+  m as isInsideEditor
+};

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

@@ -0,0 +1,20 @@
+import { DotContentAnalyticsConfig } from '../../dotAnalytics/shared/dot-content-analytics.model';
+import { ReactElement, ReactNode } from 'react';
+
+interface DotContentAnalyticsProviderProps {
+    children?: ReactNode;
+    config: DotContentAnalyticsConfig;
+}
+/**
+ * Provider component that initializes and manages DotContentAnalytics instance.
+ * It makes the analytics functionality available to all child components through React Context.
+ * This component is responsible for:
+ * - Initializing the DotContentAnalytics singleton instance with the provided config
+ * - Making the instance accessible via useContext hook to child components
+ * - Managing the lifecycle of the analytics instance
+ *
+ * @param {DotContentAnalyticsProviderProps} props - Configuration and children to render
+ * @returns {ReactElement} Provider component that enables analytics tracking
+ */
+export declare const DotContentAnalyticsProvider: ({ children, config }: DotContentAnalyticsProviderProps) => ReactElement;
+export {};

package/lib/react/components/DotContentAnalyticsProvider.mjs

@@ -0,0 +1,15 @@
+import { jsx as e } from "react/jsx-runtime";
+import { useMemo as i } from "react";
+import { initializeContentAnalytics as n } from "../../dotAnalytics/dot-content-analytics.mjs";
+import a from "../contexts/DotContentAnalyticsContext.mjs";
+import { useRouterTracker as m } from "../hook/useRouterTracker.mjs";
+const f = ({
+  children: r,
+  config: t
+}) => {
+  const o = i(() => n(t), [t]);
+  return t.autoPageView !== !1 && m(o), /* @__PURE__ */ e(a.Provider, { value: o, children: r });
+};
+export {
+  f as DotContentAnalyticsProvider
+};

package/lib/react/contexts/DotContentAnalyticsContext.d.ts

@@ -0,0 +1,13 @@
+import { DotAnalytics } from '../../dotAnalytics/shared/dot-content-analytics.model';
+
+/**
+ * `DotContentAnalyticsContext` is a React context that is designed to provide an instance of
+ * `DotContentAnalytics` to all of the components within its tree that are Consumers of this context.
+ *
+ * The context is created with a default value of `null`. It is meant to be provided a real value
+ * using the `DotContentAnalyticsProvider` component.
+ *
+ * @see {@link https://reactjs.org/docs/context.html|React Context}
+ */
+declare const DotContentAnalyticsContext: import('react').Context<DotAnalytics | null>;
+export default DotContentAnalyticsContext;

package/lib/react/contexts/DotContentAnalyticsContext.mjs

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = t(null);
+export {
+  e as default
+};

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

@@ -0,0 +1,22 @@
+import { DotAnalytics } from '../../dotAnalytics/shared/dot-content-analytics.model';
+
+/**
+ * Custom hook that handles analytics page view tracking.
+ *
+ * @example
+ * ```tsx
+ * function Button({ title, urlTitle }) {
+ *   const { track } = useContentAnalytics();
+ *
+ *   // First parameter: custom event name to identify the action
+ *   // Second parameter: object with properties you want to track
+ *   return (
+ *     <button onClick={() => track('btn-click', { title, urlTitle })}>
+ *       See Details →
+ *     </button>
+ *   );
+ * }
+ * ```
+ * @returns {DotContentAnalyticsCustomHook} - The analytics instance used to track page views
+ */
+export declare const useContentAnalytics: () => DotAnalytics;

package/lib/react/hook/useContentAnalytics.mjs

@@ -0,0 +1,34 @@
+import { useContext as i, useRef as s } from "react";
+import { isInsideEditor as r } from "../../dotAnalytics/shared/dot-content-analytics.utils.mjs";
+import a from "../contexts/DotContentAnalyticsContext.mjs";
+const f = () => {
+  const t = i(a), o = s(null);
+  if (!t)
+    throw new Error("useContentAnalytics must be used within a DotContentAnalyticsProvider");
+  return {
+    /**
+     * Track a custom event.
+     * @param {string} eventName - The name of the event to track.
+     * @param {Record<string, unknown>} payload - The payload to track.
+     */
+    track: (n, e = {}) => {
+      r() || t == null || t.track(n, {
+        ...e,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    },
+    /**
+     * Track a page view.
+     * @param {Record<string, unknown>} payload - The payload to track.
+     */
+    pageView: (n = {}) => {
+      if (!r()) {
+        const e = window.location.pathname;
+        e !== o.current && (o.current = e, t.pageView(n));
+      }
+    }
+  };
+};
+export {
+  f as useContentAnalytics
+};

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

@@ -0,0 +1,10 @@
+import { DotAnalytics } from '../../dotAnalytics/shared/dot-content-analytics.model';
+
+/**
+ * Internal custom hook that handles analytics page view tracking.
+ *
+ * @param {DotContentAnalytics | null} instance - The analytics instance used to track page views
+ * @returns {void}
+ *
+ */
+export declare function useRouterTracker(analytics: DotAnalytics | null): void;

package/lib/react/hook/useRouterTracker.mjs

@@ -0,0 +1,19 @@
+import { useRef as r, useEffect as i } from "react";
+import { isInsideEditor as u } from "../../dotAnalytics/shared/dot-content-analytics.utils.mjs";
+function s(t) {
+  const n = r(null);
+  i(() => {
+    if (!t)
+      return;
+    function e() {
+      const o = window.location.pathname;
+      o !== n.current && !u() && t && (n.current = o, t.pageView());
+    }
+    return e(), window.addEventListener("popstate", e), window.addEventListener("beforeunload", e), () => {
+      window.removeEventListener("popstate", e), window.removeEventListener("beforeunload", e);
+    };
+  }, [t]);
+}
+export {
+  s as useRouterTracker
+};

package/lib/react/index.d.ts

@@ -0,0 +1 @@
+export * from './public-api';

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

@@ -0,0 +1,2 @@
+export { DotContentAnalyticsProvider } from './components/DotContentAnalyticsProvider';
+export { useContentAnalytics } from './hook/useContentAnalytics';

package/lib/standalone.d.ts

@@ -0,0 +1,8 @@
+import { DotAnalytics } from './dotAnalytics/shared/dot-content-analytics.model';
+import { ANALYTICS_WINDOWS_KEY } from './dotAnalytics/shared/dot-content-analytics.constants';
+
+declare global {
+    interface Window {
+        [ANALYTICS_WINDOWS_KEY]: DotAnalytics;
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@dotcms/analytics",
+    "version": "0.0.1-alpha.54",
+    "description": "Official JavaScript library for Content Analytics with DotCMS.",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dotCMS/core.git#main"
+    },
+    "keywords": [
+        "dotCMS",
+        "CMS",
+        "Content Management",
+        "Analytics",
+        "Tracking"
+    ],
+    "author": "dotcms <dev@dotcms.com>",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/dotCMS/core/issues"
+    },
+    "homepage": "https://github.com/dotCMS/core/tree/main/core-web/libs/sdk/analytics/README.md",
+    "dependencies": {
+        "analytics": "^0.8.14",
+        "vite": "~5.0.0"
+    },
+    "peerDependencies": {
+        "react": "^18.2.0"
+    },
+    "devDependencies": {
+        "@testing-library/jest-dom": "^6.1.6",
+        "@testing-library/react": "^14.0.0"
+    },
+    "main": "./index.cjs.js",
+    "module": "./index.esm.js",
+    "exports": {
+        "./react": {
+            "import": "./react/index.js",
+            "types": "./src/lib/react/index.d.ts"
+        }
+    }
+}

package/react/index.mjs

@@ -0,0 +1,6 @@
+import { DotContentAnalyticsProvider as e } from "../lib/react/components/DotContentAnalyticsProvider.mjs";
+import { useContentAnalytics as r } from "../lib/react/hook/useContentAnalytics.mjs";
+export {
+  e as DotContentAnalyticsProvider,
+  r as useContentAnalytics
+};