@levi123/experiment 4.0.0-dev.0

package/dist/esm/index.mjs

@@ -0,0 +1,685 @@
+"use client"
+const EXPERIMENT_STORAGE_KEYS = {
+    PREFIX: 'gemx-ab-test:',
+    SESSION_ID: 'gemx-ab-session-id',
+    USER_ID: 'gemx-ab-user-id',
+};
+const EXPERIMENT_ATTRIBUTES = {
+    config: 'config',
+    trackingEndpoint: 'tracking-endpoint',
+    gaTracking: 'ga-tracking',
+    autoTrack: 'auto-track',
+    fallbackVariant: 'fallback-variant',
+    debug: 'debug',
+    loading: 'loading',
+    onTrack: 'on-track',
+    onVariantAssigned: 'on-variant-assigned',
+    onError: 'on-error',
+    selectedVariant: 'selected-variant',
+};
+const EXPERIMENT_EVENTS = {
+    VARIANT_ASSIGNED: 'variant-assigned',
+    TRACK: 'track',
+    ERROR: 'error',
+};
+
+const isBrowser$1 = () => typeof window !== 'undefined';
+/**
+ * Parse cookie string into key-value pairs
+ */
+const parseCookies = (cookieString = '') => {
+    return cookieString
+        .split(';')
+        .map((cookie) => cookie.trim())
+        .filter(Boolean)
+        .reduce((acc, cookie) => {
+        const [key, ...valueParts] = cookie.split('=');
+        if (key) {
+            acc[key] = decodeURIComponent(valueParts.join('='));
+        }
+        return acc;
+    }, {});
+};
+/**
+ * Get cookie value (works on both client and server)
+ * @param key - Cookie name
+ * @param cookieString - Optional cookie string from server (e.g., from request headers)
+ */
+const getCookie = (key, cookieString) => {
+    if (isBrowser$1()) {
+        // Client-side: read from document.cookie
+        const cookies = parseCookies(document.cookie);
+        return cookies[key] || null;
+    }
+    else if (cookieString) {
+        // Server-side: parse from provided cookie string
+        const cookies = parseCookies(cookieString);
+        return cookies[key] || null;
+    }
+    return null;
+};
+/**
+ * Set cookie (client-side only)
+ * @param key - Cookie name
+ * @param value - Cookie value
+ * @param days - Number of days until expiration (default: 365)
+ */
+const setCookie = (key, value, days = 30) => {
+    if (!isBrowser$1())
+        return;
+    if (getCookie(key))
+        return;
+    const expires = new Date();
+    expires.setTime(expires.getTime() + days * 24 * 60 * 60 * 1000);
+    document.cookie = `${key}=${encodeURIComponent(value)}; expires=${expires.toUTCString()}; path=/; SameSite=None; Secure`;
+};
+/**
+ * Remove cookie (client-side only)
+ */
+const removeCookie = (key) => {
+    if (!isBrowser$1())
+        return;
+    document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+};
+
+function getExperimentKey(experimentId) {
+    return `${EXPERIMENT_STORAGE_KEYS.PREFIX}${experimentId}`;
+}
+function getVariant(config, cookieString) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { experimentId, variants, weights } = config;
+    if (!experimentId || !variants || variants.length === 0) {
+        return 'control';
+    }
+    const experimentKey = getExperimentKey(experimentId);
+    try {
+        let persistedVariant = getCookie(experimentKey, cookieString);
+        if (!persistedVariant) {
+            // Determine weights - use config.weights or individual variant weights or equal distribution
+            let variantWeights;
+            if (weights && weights.length === variants.length) {
+                // Use provided weights array
+                variantWeights = weights;
+            }
+            else {
+                // Use individual variant weights or equal distribution
+                variantWeights = variants.map((variant) => variant.weight !== undefined ? variant.weight : 1 / variants.length);
+            }
+            // Calculate cumulative weights for selection
+            const totalWeight = variantWeights.reduce((sum, w) => sum + w, 0);
+            const rand = Math.random() * totalWeight;
+            let weightSum = 0;
+            for (let i = 0; i < variants.length; i++) {
+                weightSum += variantWeights[i] || 0;
+                if (rand < weightSum) {
+                    persistedVariant = (_d = (_b = (_a = variants[i]) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = variants[0]) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : 'control';
+                    break;
+                }
+            }
+            // Fallback to first variant if selection failed
+            if (!persistedVariant) {
+                persistedVariant = (_f = (_e = variants[0]) === null || _e === void 0 ? void 0 : _e.name) !== null && _f !== void 0 ? _f : 'control';
+            }
+            // Save to cookie
+            setCookie(experimentKey, persistedVariant);
+        }
+        return persistedVariant || ((_g = variants[0]) === null || _g === void 0 ? void 0 : _g.name) || 'control';
+    }
+    catch (error) {
+        return ((_h = variants[0]) === null || _h === void 0 ? void 0 : _h.name) || 'control';
+    }
+}
+
+var IDeviceType;
+(function (IDeviceType) {
+    IDeviceType["MOBILE"] = "mobile";
+    IDeviceType["DESKTOP"] = "desktop";
+    IDeviceType["TABLET"] = "tablet";
+})(IDeviceType || (IDeviceType = {}));
+
+const getDeviceType = (agent) => {
+    const userAgent = agent !== null && agent !== void 0 ? agent : navigator.userAgent;
+    if (/tablet|ipad|playbook|silk/i.test(userAgent)) {
+        return IDeviceType.TABLET;
+    }
+    if (/mobile|iphone|ipod|android|blackberry|opera|mini|windows\sce|palm|smartphone|iemobile/i.test(userAgent)) {
+        return IDeviceType.MOBILE;
+    }
+    return IDeviceType.DESKTOP;
+};
+
+/**
+ * Sets all attributes on the gx-experiment-wrapper element
+ */
+const setExperimentWrapperAttributes = (element, config) => {
+    var _a, _b, _c, _d;
+    if (!element)
+        return;
+    const attributesToSet = [];
+    // Set required config
+    attributesToSet.push([EXPERIMENT_ATTRIBUTES.config, JSON.stringify(config.config)]);
+    attributesToSet.push([EXPERIMENT_ATTRIBUTES.gaTracking, ((_a = config.gaTracking) !== null && _a !== void 0 ? _a : false).toString()]);
+    attributesToSet.push([EXPERIMENT_ATTRIBUTES.autoTrack, ((_b = config.autoTrack) !== null && _b !== void 0 ? _b : true).toString()]);
+    attributesToSet.push([EXPERIMENT_ATTRIBUTES.debug, ((_c = config.debug) !== null && _c !== void 0 ? _c : false).toString()]);
+    attributesToSet.push([EXPERIMENT_ATTRIBUTES.loading, ((_d = config.loading) !== null && _d !== void 0 ? _d : false).toString()]);
+    // Set optional attributes
+    if (config.trackingEndpoint) {
+        attributesToSet.push([EXPERIMENT_ATTRIBUTES.trackingEndpoint, config.trackingEndpoint]);
+    }
+    if (config.fallbackVariant) {
+        attributesToSet.push([EXPERIMENT_ATTRIBUTES.fallbackVariant, config.fallbackVariant]);
+    }
+    if (config.selectedVariant) {
+        attributesToSet.push([EXPERIMENT_ATTRIBUTES.selectedVariant, config.selectedVariant]);
+    }
+    // Set all attributes in a single microtask to minimize re-initializations
+    if (attributesToSet.length > 0) {
+        requestAnimationFrame(() => {
+            attributesToSet.forEach(([attr, value]) => {
+                element.setAttribute(attr, value);
+            });
+        });
+    }
+};
+/**
+ * Sets up event listeners on the gx-experiment-wrapper element
+ */
+const setupExperimentWrapperEventListeners = (element, callbacks = {}) => {
+    if (!element)
+        return () => { };
+    const handleVariantAssigned = (event) => {
+        var _a;
+        const customEvent = event;
+        const { variant, experimentId } = customEvent.detail;
+        console.log('🚀 ~ Experiment Wrapper: Variant assigned', {
+            variant,
+            experimentId,
+        });
+        (_a = callbacks.onVariantAssigned) === null || _a === void 0 ? void 0 : _a.call(callbacks, variant, experimentId);
+    };
+    const handleTrack = (event) => {
+        var _a;
+        const customEvent = event;
+        console.log('🚀 ~ Experiment Wrapper: Track event', customEvent.detail);
+        (_a = callbacks.onTrack) === null || _a === void 0 ? void 0 : _a.call(callbacks, customEvent.detail.event, customEvent.detail);
+    };
+    const handleError = (event) => {
+        var _a;
+        const customEvent = event;
+        const { error, experimentId: expId } = customEvent.detail;
+        console.log('🚀 ~ Experiment Wrapper: Error event', {
+            error,
+            experimentId: expId,
+        });
+        (_a = callbacks.onError) === null || _a === void 0 ? void 0 : _a.call(callbacks, error, expId);
+    };
+    const abortController = new AbortController();
+    element.addEventListener(EXPERIMENT_EVENTS.VARIANT_ASSIGNED, handleVariantAssigned, {
+        signal: abortController.signal,
+    });
+    element.addEventListener(EXPERIMENT_EVENTS.TRACK, handleTrack, {
+        signal: abortController.signal,
+    });
+    element.addEventListener(EXPERIMENT_EVENTS.ERROR, handleError, {
+        signal: abortController.signal,
+    });
+    // Return cleanup function
+    return () => {
+        abortController.abort();
+    };
+};
+/**
+ * Complete setup function that configures both attributes and event listeners
+ */
+const setupExperimentWrapper = (element, config) => {
+    if (!element)
+        return () => { };
+    // Set attributes
+    setExperimentWrapperAttributes(element, config);
+    // Setup event listeners and return cleanup function
+    return setupExperimentWrapperEventListeners(element, config.callbacks);
+};
+
+const getOrCreateSessionId = () => {
+    let sessionId = sessionStorage.getItem(EXPERIMENT_STORAGE_KEYS.SESSION_ID);
+    if (!sessionId) {
+        sessionId = 'session_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+        sessionStorage.setItem(EXPERIMENT_STORAGE_KEYS.SESSION_ID, sessionId);
+    }
+    return sessionId;
+};
+
+const isBrowser = () => typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';
+const getLocalStorageItem = (key) => {
+    if (!isBrowser())
+        return null;
+    try {
+        return window.localStorage.getItem(key);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const setLocalStorageItem = (key, value) => {
+    if (!isBrowser())
+        return;
+    try {
+        window.localStorage.setItem(key, value);
+    }
+    catch (_a) {
+        // ignore
+    }
+};
+const removeLocalStorageItem = (key) => {
+    if (!isBrowser())
+        return;
+    try {
+        window.localStorage.removeItem(key);
+    }
+    catch (_a) {
+        // ignore
+    }
+};
+
+const getOrCreateUserId = () => {
+    let userId = localStorage.getItem(EXPERIMENT_STORAGE_KEYS.USER_ID);
+    if (!userId) {
+        userId = 'user_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+        localStorage.setItem(EXPERIMENT_STORAGE_KEYS.USER_ID, userId);
+    }
+    return userId;
+};
+const hashUserId = (userId) => {
+    let hash = 0;
+    for (let i = 0; i < userId.length; i++) {
+        const char = userId.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash);
+};
+
+/**
+ * GxExperimentWrapper - Framework-Agnostic A/B Testing Web Component
+ *
+ * This is a comprehensive Web Component that contains ALL A/B testing logic,
+ * making it truly framework-agnostic. It can be used in React, Vue, Angular,
+ * Svelte, or vanilla JavaScript without any framework-specific dependencies.
+ */
+function registerExperimentWebComponent() {
+    if (typeof window === 'undefined')
+        return;
+    class GxExperimentWrapper extends HTMLElement {
+        static get observedAttributes() {
+            return [
+                EXPERIMENT_ATTRIBUTES.config,
+                EXPERIMENT_ATTRIBUTES.trackingEndpoint,
+                EXPERIMENT_ATTRIBUTES.gaTracking,
+                EXPERIMENT_ATTRIBUTES.autoTrack,
+                EXPERIMENT_ATTRIBUTES.fallbackVariant,
+                EXPERIMENT_ATTRIBUTES.onTrack,
+                EXPERIMENT_ATTRIBUTES.onVariantAssigned,
+                EXPERIMENT_ATTRIBUTES.onError,
+                EXPERIMENT_ATTRIBUTES.selectedVariant,
+                EXPERIMENT_ATTRIBUTES.debug,
+            ];
+        }
+        constructor() {
+            super();
+            this.experimentConfig = null;
+            this.currentVariant = null;
+            this.isInitialized = false;
+            this.impressionTracked = false;
+            this.retryCount = 0;
+            this.maxRetries = 3;
+            this.initializationTimeout = null;
+            this.attachShadow({ mode: 'open' });
+            this.sessionId = getOrCreateSessionId();
+            this.userId = getOrCreateUserId();
+        }
+        connectedCallback() {
+            this.initializeExperiment();
+        }
+        attributeChangedCallback(_name, oldValue, newValue) {
+            if (oldValue !== newValue) {
+                // Debounce initialization to prevent multiple calls when setting multiple attributes
+                if (this.initializationTimeout) {
+                    clearTimeout(this.initializationTimeout);
+                }
+                this.initializationTimeout = window.setTimeout(() => {
+                    this.initializeExperiment();
+                    this.initializationTimeout = null;
+                }, 0);
+            }
+        }
+        /**
+         * Initialize the experiment with all configuration
+         */
+        initializeExperiment() {
+            try {
+                this.parseConfiguration();
+                if (!this.experimentConfig)
+                    return;
+                if (this.isInitialized && this.currentVariant)
+                    return;
+                // Check targeting rules
+                if (!this.shouldRunExperiment()) {
+                    this.currentVariant = this.getFallbackVariant();
+                    this.render();
+                    return;
+                }
+                // Get or assign variant
+                this.currentVariant = this.getExperimentVariant();
+                // Mark as initialized
+                this.isInitialized = true;
+                // Render with selected variant
+                this.render();
+                // Auto-track impression if enabled
+                if (this.isAutoTrackEnabled()) {
+                    this.trackImpression();
+                }
+                // Emit variant assigned event
+                this.dispatchEvent(new CustomEvent(EXPERIMENT_EVENTS.VARIANT_ASSIGNED, {
+                    detail: {
+                        experimentId: this.experimentConfig.experimentId,
+                        variant: this.currentVariant,
+                        timestamp: Date.now(),
+                    },
+                    bubbles: true,
+                }));
+                if (this.isDebugEnabled()) {
+                    console.log('🚀 ~ GxExperimentWrapper ~ Experiment Initialized:', {
+                        experimentId: this.experimentConfig.experimentId,
+                        variant: this.currentVariant,
+                        config: this.experimentConfig,
+                    });
+                }
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        }
+        parseConfiguration() {
+            const configAttr = this.getAttribute(EXPERIMENT_ATTRIBUTES.config);
+            if (configAttr) {
+                try {
+                    this.experimentConfig = JSON.parse(configAttr);
+                }
+                catch (error) {
+                    console.warn('Failed to parse config attribute:', error);
+                }
+            }
+        }
+        /**
+         * Check if experiment should run based on targeting rules
+         */
+        shouldRunExperiment() {
+            var _a;
+            const targeting = (_a = this.experimentConfig) === null || _a === void 0 ? void 0 : _a.targeting;
+            if (!targeting)
+                return true;
+            // Traffic percentage check
+            if (targeting.trafficPercentage && targeting.trafficPercentage < 100) {
+                const hash = hashUserId(this.userId);
+                const percentage = (hash % 100) + 1;
+                if (percentage > targeting.trafficPercentage) {
+                    if (this.isDebugEnabled()) {
+                        console.log('🚀 ~ GxExperimentWrapper ~ User excluded from experiment due to traffic percentage');
+                    }
+                    return false;
+                }
+            }
+            // Device type check
+            if (targeting.deviceType) {
+                const deviceType = getDeviceType();
+                if (deviceType !== targeting.deviceType) {
+                    if (this.isDebugEnabled()) {
+                        console.log('🚀 ~ GxExperimentWrapper ~ User excluded from experiment due to device type');
+                    }
+                    return false;
+                }
+            }
+            // Add more targeting rules as needed
+            return true;
+        }
+        getExperimentVariant() {
+            if (!this.experimentConfig)
+                return this.getFallbackVariant();
+            const selectedVariant = this.getAttribute(EXPERIMENT_ATTRIBUTES.selectedVariant);
+            if (selectedVariant) {
+                const key = getExperimentKey(this.experimentConfig.experimentId);
+                setCookie(key, selectedVariant);
+                return selectedVariant;
+            }
+            return getVariant(this.experimentConfig);
+        }
+        /**
+         * Render the component with CSS variant visibility
+         */
+        render() {
+            const variant = this.currentVariant || this.getFallbackVariant();
+            console.log('🚀 ~ GxExperimentWrapper ~ render ~ variant:', variant);
+            const style = `
+        <style>
+          :host {
+            display: block;
+          }
+
+          /* Hide all variants by default */
+          ::slotted([data-variant]) {
+            display: none !important;
+          }
+
+          /* Show only the selected variant */
+          ::slotted([data-variant="${variant}"]) {
+            display: block !important;
+          }
+
+          /* Fallback: if no data-variant specified, show all content */
+          ::slotted(:not([data-variant])) {
+            display: block !important;
+          }
+
+          /* Loading state */
+          :host([loading="true"]) {
+            opacity: 0.7;
+            pointer-events: none;
+          }
+
+          /* Error state */
+          :host([error="true"]) {
+            border: 2px solid #ef4444;
+            background-color: #fef2f2;
+            padding: 1rem;
+            border-radius: 0.5rem;
+          }
+
+          /* Debug styles */
+          :host([debug="true"]) {
+            border: 2px dashed #3b82f6;
+            position: relative;
+          }
+
+          :host([debug="true"])::before {
+            content: "🧪 " attr(experiment-id) " → " attr(variant);
+            position: absolute;
+            top: -1.5rem;
+            left: 0;
+            background: #3b82f6;
+            color: white;
+            padding: 0.25rem 0.5rem;
+            border-radius: 0.25rem;
+            font-size: 0.75rem;
+            font-family: monospace;
+            z-index: 1000;
+          }
+        </style>
+      `;
+            this.shadowRoot.innerHTML = `${style}<slot></slot>`;
+            if (!this.isInitialized) {
+                this.setAttribute(EXPERIMENT_ATTRIBUTES.loading, '');
+            }
+            else {
+                this.removeAttribute(EXPERIMENT_ATTRIBUTES.loading);
+            }
+        }
+        /**
+         * Track impression event
+         */
+        trackImpression() {
+            if (this.impressionTracked || !this.experimentConfig || !this.currentVariant) {
+                return;
+            }
+            this.impressionTracked = true;
+            const trackingData = {
+                event: 'impression',
+                experimentId: this.experimentConfig.experimentId,
+                variant: this.currentVariant,
+                timestamp: Date.now(),
+                sessionId: this.sessionId,
+                userId: this.userId,
+                description: this.experimentConfig.description,
+                userAgent: navigator.userAgent,
+                referrer: document.referrer,
+                url: window.location.href,
+                deviceType: getDeviceType(),
+            };
+            this.track('impression', trackingData);
+        }
+        /**
+         * Track custom events
+         */
+        trackEvent(event, data = {}) {
+            if (!this.experimentConfig || !this.currentVariant) {
+                return;
+            }
+            const trackingData = Object.assign({ event, experimentId: this.experimentConfig.experimentId, variant: this.currentVariant, timestamp: Date.now(), sessionId: this.sessionId, userId: this.userId }, data);
+            this.track(event, trackingData);
+        }
+        track(event, data) {
+            this.dispatchEvent(new CustomEvent(EXPERIMENT_EVENTS.TRACK, {
+                detail: data,
+                bubbles: true,
+            }));
+            // Google Analytics tracking
+            if (this.isGATrackingEnabled() && typeof window.gtag === 'function') {
+                window.gtag('event', event, data);
+            }
+            // Custom tracking endpoint
+            const trackingEndpoint = this.getAttribute(EXPERIMENT_ATTRIBUTES.trackingEndpoint);
+            if (trackingEndpoint) {
+                fetch(trackingEndpoint, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(data),
+                }).catch((error) => {
+                    console.warn('Failed to send tracking data:', error);
+                });
+            }
+            // Debug logging
+            if (this.isDebugEnabled()) {
+                console.log('🚀 ~ GxExperimentWrapper ~ Tracked Event:', data);
+            }
+        }
+        /**
+         * Handle errors with retry logic
+         */
+        handleError(error) {
+            var _a, _b;
+            console.error('🚀 ~ GxExperimentWrapper ~ Experiment Error:', error);
+            // Set error state
+            this.setAttribute('error', '');
+            // Try fallback variant
+            this.currentVariant = this.getFallbackVariant();
+            this.render();
+            // Emit error event
+            this.dispatchEvent(new CustomEvent(EXPERIMENT_EVENTS.ERROR, {
+                detail: {
+                    error: error.message,
+                    experimentId: (_a = this.experimentConfig) === null || _a === void 0 ? void 0 : _a.experimentId,
+                },
+                bubbles: true,
+            }));
+            // Retry logic
+            if (this.retryCount < this.maxRetries) {
+                this.retryCount++;
+                setTimeout(() => {
+                    this.removeAttribute('error');
+                    this.initializeExperiment();
+                }, 1000 * this.retryCount);
+            }
+            // Track error
+            if (typeof window.gtag === 'function') {
+                window.gtag('event', 'exception', {
+                    description: error.message,
+                    fatal: false,
+                    experiment_error: true,
+                    experiment_id: ((_b = this.experimentConfig) === null || _b === void 0 ? void 0 : _b.experimentId) || 'unknown',
+                });
+            }
+        }
+        // Helper Methods
+        getFallbackVariant() {
+            var _a, _b;
+            return (this.getAttribute(EXPERIMENT_ATTRIBUTES.fallbackVariant) ||
+                ((_b = (_a = this.experimentConfig) === null || _a === void 0 ? void 0 : _a.variants[0]) === null || _b === void 0 ? void 0 : _b.name) ||
+                'control');
+        }
+        isAutoTrackEnabled() {
+            const autoTrack = this.getAttribute(EXPERIMENT_ATTRIBUTES.autoTrack);
+            return autoTrack !== 'false';
+        }
+        isGATrackingEnabled() {
+            const gaTracking = this.getAttribute(EXPERIMENT_ATTRIBUTES.gaTracking);
+            return gaTracking === 'true';
+        }
+        isDebugEnabled() {
+            const debug = this.getAttribute(EXPERIMENT_ATTRIBUTES.debug);
+            return debug === 'true';
+        }
+        // Public API Methods
+        /**
+         * Get current variant
+         */
+        getCurrentVariant() {
+            return this.currentVariant;
+        }
+        /**
+         * Get experiment status
+         */
+        getExperimentStatus() {
+            var _a;
+            return {
+                experimentId: (_a = this.experimentConfig) === null || _a === void 0 ? void 0 : _a.experimentId,
+                variant: this.currentVariant,
+                isInitialized: this.isInitialized,
+                sessionId: this.sessionId,
+                userId: this.userId,
+                config: this.experimentConfig,
+            };
+        }
+        /**
+         * Force re-assignment of variant (useful for testing)
+         */
+        reassignVariant() {
+            if (this.experimentConfig) {
+                // Clear stored variant
+                removeCookie(`${EXPERIMENT_STORAGE_KEYS.PREFIX}${this.experimentConfig.experimentId}`);
+                // Re-initialize
+                this.impressionTracked = false;
+                this.initializeExperiment();
+            }
+        }
+        /**
+         * Check if current variant matches target
+         */
+        isVariant(targetVariant) {
+            return this.currentVariant === targetVariant;
+        }
+    }
+    if (!customElements.get('gx-experiment-wrapper')) {
+        customElements.define('gx-experiment-wrapper', GxExperimentWrapper);
+    }
+}
+
+export { EXPERIMENT_ATTRIBUTES, EXPERIMENT_EVENTS, EXPERIMENT_STORAGE_KEYS, IDeviceType, getCookie, getDeviceType, getExperimentKey, getLocalStorageItem, getOrCreateSessionId, getOrCreateUserId, getVariant, hashUserId, parseCookies, registerExperimentWebComponent, removeCookie, removeLocalStorageItem, setCookie, setExperimentWrapperAttributes, setLocalStorageItem, setupExperimentWrapper, setupExperimentWrapperEventListeners };

package/dist/esm/tracking/tracker.d.ts

@@ -0,0 +1,12 @@
+interface TrackData {
+    event: string;
+    variant: string;
+    experimentId: string;
+    [key: string]: any;
+}
+export declare class Tracker {
+    private callback?;
+    constructor(callback?: (event: string, data: TrackData) => void);
+    trackEvent(event: string, data: TrackData): void;
+}
+export {};

package/dist/esm/types/devices.d.ts

@@ -0,0 +1,5 @@
+export declare enum IDeviceType {
+    MOBILE = "mobile",
+    DESKTOP = "desktop",
+    TABLET = "tablet"
+}