@cascayd/experiment 0.3.10 → 0.3.12

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { InitOptions, ExperimentConfigResponse, EventType, RecordOptions, VariantStatusResponse } from './types';
 export declare function initCascayd(opts: InitOptions): void;
 export declare function getVariantStatus(experimentId: string, variantId: string): Promise<VariantStatusResponse>;
-export declare function assignVariant(experimentId: string): Promise<{
+export declare function assignVariant(experimentId: string, detectedVariants?: string[], route?: string, shop?: string): Promise<{
     variantId: string;
     config: ExperimentConfigResponse;
 }>;

package/dist/client.js

@@ -71,10 +71,60 @@ function chooseByWeight(variants, experimentId) {
     console.log('[cascayd-sdk] chooseByWeight fallback to:', fallback);
     return fallback;
 }
-export async function assignVariant(experimentId) {
+export async function assignVariant(experimentId, detectedVariants, route, shop) {
     const baseStatus = await getVariantStatus(experimentId, 'control');
-    const weights = baseStatus.weights || {};
+    let weights = baseStatus.weights || {};
     console.log('[cascayd-sdk] assignVariant weights received:', weights);
+    // If we have detected variants, ensure they exist in the database
+    if (detectedVariants && detectedVariants.length > 0) {
+        // Check if all detected variants exist in weights
+        const missingVariants = detectedVariants.filter(vid => !(vid in weights));
+        if (missingVariants.length > 0) {
+            console.log('[cascayd-sdk] assignVariant: Missing variants detected, ensuring they exist:', missingVariants);
+            try {
+                // Call ensure endpoint to create missing variants
+                const ensureBody = {
+                    experiment_id: experimentId,
+                    variant_ids: detectedVariants,
+                    route: route || (typeof window !== 'undefined' ? window.location.pathname : "/"),
+                };
+                if (shop) {
+                    ensureBody.shop = shop;
+                }
+                const ensureRes = await fetch(`${BASE_URL}/experiments/ensure`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${API_KEY}`,
+                    },
+                    body: JSON.stringify(ensureBody),
+                });
+                if (ensureRes.ok) {
+                    console.log('[cascayd-sdk] assignVariant: Successfully ensured variants exist');
+                    // Fetch status again to get updated weights
+                    const updatedStatus = await getVariantStatus(experimentId, 'control');
+                    weights = updatedStatus.weights || {};
+                    console.log('[cascayd-sdk] assignVariant: Updated weights after ensuring:', weights);
+                }
+                else {
+                    console.warn('[cascayd-sdk] assignVariant: Failed to ensure variants, using fallback weights');
+                }
+            }
+            catch (error) {
+                console.error('[cascayd-sdk] assignVariant: Error ensuring variants:', error);
+            }
+        }
+    }
+    // If weights only has control and we have detected variants, use detected variants with equal weights (fallback)
+    if (Object.keys(weights).length === 1 && weights.control === 1 && detectedVariants && detectedVariants.length > 1) {
+        console.log('[cascayd-sdk] assignVariant: Only control in weights, using detected variants as fallback:', detectedVariants);
+        const equalWeight = 1 / detectedVariants.length;
+        weights = {};
+        detectedVariants.forEach(vid => {
+            weights[vid] = equalWeight;
+        });
+        console.log('[cascayd-sdk] assignVariant: Created equal weights from detected variants:', weights);
+    }
     console.log('[cascayd-sdk] assignVariant weights entries:', Object.entries(weights));
     const variants = Object.entries(weights).map(([id, weight]) => ({ id, weight }));
     console.log('[cascayd-sdk] assignVariant variants array:', variants);
@@ -118,11 +168,21 @@ export async function record(type, opts = {}) {
         body.experiment_id = opts.experimentId;
         const fromCookie = readVariantChoice(opts.experimentId);
         const variantId = opts.variantId || fromCookie;
-        if (variantId)
+        if (variantId) {
             body.variant_id = variantId;
+        }
+        else if (opts.experimentId) {
+            console.warn(`[cascayd-sdk] No variant_id found for experiment ${opts.experimentId}`);
+        }
     }
     if (typeof opts.value === 'number')
         body.value = opts.value;
+    if (opts.route) {
+        body.route = opts.route;
+    }
+    else if (typeof window !== 'undefined' && window.location) {
+        body.route = window.location.pathname;
+    }
     const res = await fetch(`${BASE_URL}/events`, {
         method: 'POST',
         headers: {

package/dist/shopify-handler-browser.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shopify-handler-browser.js

@@ -1,433 +1,163 @@
-/**
- * Cascayd A/B Testing - Shopify Theme Handler (Browser Standalone)
- * This script automatically handles variant selection for elements with 
- * data-cascayd-experiment and data-cascayd-variant attributes
- * 
- * Usage:
- * 1. Load the Cascayd SDK first:
- *    <script type="module" src="https://cdn.jsdelivr.net/npm/@cascayd/experiment@latest/dist/client.js"></script>
- * 2. Load this handler:
- *    <script src="https://cdn.jsdelivr.net/npm/@cascayd/experiment@latest/dist/shopify-handler-browser.js"></script>
- * 
- * Or if SDK is loaded as a module that exposes functions to window:
- * <script>
- *   window.initCascayd({ apiKey: 'YOUR_KEY' });
- * </script>
- */
-
-(function() {
-  'use strict';
-
-  console.log('[cascayd-shopify] 🚀 Handler script starting...');
-  console.log('[cascayd-shopify] Document readyState:', document.readyState);
-  console.log('[cascayd-shopify] Window object available:', typeof window !== 'undefined');
-
-  // Cookie helper functions (matching SDK's cookie logic)
-  function getCookie(name) {
-    const match = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/[.$?*|{}()\[\]\\\/\+^]/g, '\\$&') + '=([^;]*)'));
-    const value = match ? decodeURIComponent(match[1]) : null;
-    console.log('[cascayd-shopify] 📦 getCookie:', name, '=', value);
-    return value;
-  }
-
-  function setCookie(name, value) {
-    document.cookie = `${name}=${encodeURIComponent(value)}; path=/; SameSite=Lax; max-age=31536000`;
-  }
-
-  function getVariantCookieKey(experimentId) {
-    return `cascayd:${experimentId}`;
-  }
-
-  function readVariantChoice(experimentId) {
-    const choice = getCookie(getVariantCookieKey(experimentId));
-    console.log('[cascayd-shopify] 📖 Read variant choice:', { experimentId, choice });
-    return choice;
-  }
-
-  function persistVariantChoice(experimentId, variantId) {
-    const key = getVariantCookieKey(experimentId);
-    console.log('[cascayd-shopify] 💾 Persisting variant choice:', { experimentId, variantId, cookieKey: key });
-    setCookie(key, variantId);
-  }
-
-  // API configuration (same as SDK)
-  const BASE_URL = 'https://ab-mvp-backend.onrender.com';
-  let API_KEY = '';
-
-  // Try to get API key from window (if SDK was initialized)
-  function getAPIKey() {
-    if (typeof window !== 'undefined' && window._cascaydAPIKey) {
-      return window._cascaydAPIKey;
-    }
-    return API_KEY;
-  }
-
-  // Direct API call functions (same logic as SDK)
-  async function getVariantStatus(experimentId, variantId) {
-    const url = BASE_URL + '/experiments/' + encodeURIComponent(experimentId) + '/variants/' + encodeURIComponent(variantId) + '/status';
-    console.log('[cascayd-shopify] 🌐 Fetching variant status:', { experimentId, variantId, url });
-    try {
-      const res = await fetch(url);
-      const data = await res.json();
-      console.log('[cascayd-shopify] ✅ Variant status response:', { status: res.status, data });
-      if (!res.ok) {
-        const err = new Error('Variant status failed: ' + res.status);
-        err.payload = data;
-        throw err;
-      }
-      return data;
-    } catch (error) {
-      console.error('[cascayd-shopify] ❌ getVariantStatus error:', error);
-      throw error;
-    }
-  }
-
-  function chooseByWeight(variants) {
-    const total = variants.reduce(function(s, v) { return s + v.weight; }, 0);
+import { record, getVariantStatus } from './client';
+import { getOrCreateSession, persistVariantChoice, readVariantChoice } from './cookies';
+const sentImpressions = new Set();
+function chooseByWeight(variants) {
+    const total = variants.reduce((s, v) => s + v.weight, 0);
+    if (total === 0)
+        return variants[0]?.id ?? 'control';
     const r = Math.random() * total;
     let acc = 0;
-    for (let i = 0; i < variants.length; i++) {
-      acc += variants[i].weight;
-      if (r <= acc) {
-        return variants[i].id;
-      }
+    for (const v of variants) {
+        acc += v.weight;
+        if (r <= acc)
+            return v.id;
     }
-    return variants[variants.length - 1] ? variants[variants.length - 1].id : 'control';
-  }
-
-  function baseStatusToVariants(status) {
+    return variants[variants.length - 1]?.id ?? 'control';
+}
+function baseStatusToVariants(status) {
     const entries = Object.entries(status.weights || {});
     if (entries.length === 0) {
-      return [{ id: 'control', weight: 1 }];
-    }
-    return entries.map(function(entry) {
-      return { id: entry[0], weight: entry[1] };
-    });
-  }
-
-  // Assign variant using same logic as SDK
-  async function assignVariantDirect(experimentId) {
-    console.log('[cascayd-shopify] 🎲 assignVariantDirect called for:', experimentId);
-    const baseStatus = await getVariantStatus(experimentId, 'control');
-    console.log('[cascayd-shopify] 📊 Base status received:', baseStatus);
-    const weights = baseStatus.weights || {};
-    const variants = Object.entries(weights).map(function(entry) {
-      return { id: entry[0], weight: entry[1] };
-    });
-    console.log('[cascayd-shopify] 📋 Variants from weights:', variants);
-
-    const allVariants = variants.length > 0 ? variants : baseStatusToVariants(baseStatus);
-    console.log('[cascayd-shopify] 🎯 All variants for selection:', allVariants);
-    let candidate = chooseByWeight(allVariants);
-    console.log('[cascayd-shopify] 🎲 Selected candidate:', candidate);
-    let finalStatus = null;
-
-    if (candidate) {
-      try {
-        finalStatus = await getVariantStatus(experimentId, candidate);
-        console.log('[cascayd-shopify] ✅ Final status for candidate:', finalStatus);
-      } catch (error) {
-        console.error('[cascayd-shopify] ❌ getVariantStatus failed for candidate', { experimentId: experimentId, candidate: candidate, error: error });
-        // Fall back to candidate
-      }
-    }
-
-    const serving = (finalStatus && finalStatus.serving_variant_id) || candidate || 'control';
-    console.log('[cascayd-shopify] ✅ Final serving variant:', serving);
-    return { variantId: serving };
-  }
-
-  // Record event using same logic as SDK
-  async function recordDirect(type, opts) {
-    const sessionId = getOrCreateSession();
-    const body = {
-      type: type,
-      session_id: sessionId
-    };
-
-    if (opts.experimentId) {
-      body.experiment_id = opts.experimentId;
-      const fromCookie = readVariantChoice(opts.experimentId);
-      const variantId = opts.variantId || fromCookie;
-      if (variantId) {
-        body.variant_id = variantId;
-      }
-    }
-
-    if (typeof opts.value === 'number') {
-      body.value = opts.value;
-    }
-
-    const headers = {
-      'Content-Type': 'application/json'
-    };
-    const apiKey = getAPIKey();
-    if (apiKey) {
-      headers.Authorization = 'Bearer ' + apiKey;
+        return [{ id: 'control', weight: 1 }];
     }
-
-    const res = await fetch(BASE_URL + '/events', {
-      method: 'POST',
-      headers: headers,
-      body: JSON.stringify(body)
-    });
-
-    if (!res.ok) {
-      throw new Error('Record failed: ' + res.status);
-    }
-  }
-
-  function getOrCreateSession() {
-    const key = 'cascayd:session';
-    let id = getCookie(key);
-    if (id) return id;
-    id = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-      const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0xf) >>> 0;
-      const v = c === 'x' ? r : (r & 0x3) | 0x8;
-      return v.toString(16);
-    });
-    setCookie(key, id);
-    return id;
-  }
-
-  // Try to use SDK functions if available, otherwise use direct API calls
-  async function waitForSDK(maxAttempts, interval) {
-    maxAttempts = maxAttempts || 10;
-    interval = interval || 100;
-    console.log('[cascayd-shopify] ⏳ Waiting for SDK...', { maxAttempts, interval });
-    
-    return new Promise(function(resolve) {
-      let attempts = 0;
-      const checkSDK = function() {
-        attempts++;
-        console.log('[cascayd-shopify] 🔍 Checking for SDK (attempt ' + attempts + '/' + maxAttempts + ')');
-        
-        // Check if SDK functions are available on window
-        let assignVariantFn = null;
-        let recordFn = null;
-        
-        if (typeof window !== 'undefined') {
-          console.log('[cascayd-shopify] 🪟 Window available, checking functions...');
-          console.log('[cascayd-shopify]   - window.assignVariant:', typeof window.assignVariant);
-          console.log('[cascayd-shopify]   - window.record:', typeof window.record);
-          console.log('[cascayd-shopify]   - window.Cascayd:', typeof window.Cascayd);
-          console.log('[cascayd-shopify]   - window.initCascayd:', typeof window.initCascayd);
-          
-          if (window.assignVariant) {
-            assignVariantFn = window.assignVariant;
-            console.log('[cascayd-shopify] ✅ Found window.assignVariant');
-          }
-          if (window.record) {
-            recordFn = window.record;
-            console.log('[cascayd-shopify] ✅ Found window.record');
-          }
-          // Try Cascayd namespace
-          if (!assignVariantFn && window.Cascayd && window.Cascayd.assignVariant) {
-            assignVariantFn = window.Cascayd.assignVariant;
-            console.log('[cascayd-shopify] ✅ Found Cascayd.assignVariant');
-          }
-          if (!recordFn && window.Cascayd && window.Cascayd.record) {
-            recordFn = window.Cascayd.record;
-            console.log('[cascayd-shopify] ✅ Found Cascayd.record');
-          }
+    return entries.map(([id, weight]) => ({ id, weight }));
+}
+async function assignVariantForExperiment(experimentId) {
+    try {
+        const existing = readVariantChoice(experimentId);
+        if (existing) {
+            try {
+                const status = await getVariantStatus(experimentId, existing);
+                const serving = status.serving_variant_id || existing;
+                if (serving === existing) {
+                    return existing;
+                }
+            }
+            catch (error) {
+                console.warn('[cascayd-shopify] Failed to verify existing variant, reassigning', error);
+            }
         }
-        
-        if (assignVariantFn && recordFn) {
-          console.log('[cascayd-shopify] ✅ SDK functions found! Using SDK.');
-          resolve({ assignVariant: assignVariantFn, record: recordFn });
-        } else if (attempts >= maxAttempts) {
-          console.log('[cascayd-shopify] ⚠️ SDK not found after ' + maxAttempts + ' attempts. Using direct API calls.');
-          // Use direct API calls as fallback
-          resolve({ assignVariant: assignVariantDirect, record: recordDirect });
-        } else {
-          console.log('[cascayd-shopify] ⏳ SDK not ready, retrying in ' + interval + 'ms...');
-          setTimeout(checkSDK, interval);
+        const baseStatus = await getVariantStatus(experimentId, 'control');
+        const weights = baseStatus.weights || {};
+        const variants = Object.entries(weights).map(([id, weight]) => ({ id, weight }));
+        let candidate = chooseByWeight(variants.length > 0 ? variants : baseStatusToVariants(baseStatus));
+        let finalStatus = null;
+        if (candidate) {
+            try {
+                finalStatus = await getVariantStatus(experimentId, candidate);
+            }
+            catch (error) {
+                console.warn('[cascayd-shopify] getVariantStatus failed, using candidate', error);
+            }
         }
-      };
-      checkSDK();
-    });
-  }
-
-  // Record impression event
-  async function recordImpression(experimentId, variantId, sdk) {
-    console.log('[cascayd-shopify] 📝 Recording impression:', { experimentId, variantId, hasSDK: !!sdk, hasRecordFn: !!(sdk && sdk.record) });
-    if (!sdk || !sdk.record) {
-      console.warn('[cascayd-shopify] ⚠️ Record function not available, skipping impression tracking');
-      return;
+        const serving = finalStatus?.serving_variant_id || candidate || 'control';
+        persistVariantChoice(experimentId, serving);
+        return serving;
     }
-
-    try {
-      await sdk.record('impression', {
-        experimentId: experimentId,
-        variantId: variantId
-      });
-      console.log('[cascayd-shopify] ✅ Impression recorded successfully');
-    } catch (error) {
-      console.error('[cascayd-shopify] ❌ Failed to record impression:', error);
+    catch (error) {
+        console.error('[cascayd-shopify] Variant assignment failed', error);
+        return 'control';
     }
-  }
-
-  // Process a single experiment
-  async function processExperiment(experimentId, variantElements, sdk) {
-    console.log('[cascayd-shopify] 🔬 Processing experiment:', { experimentId, variantElementCount: variantElements.length, hasSDK: !!sdk });
-    
-    // Check if we already have a variant choice stored
-    let variantId = readVariantChoice(experimentId);
-    console.log('[cascayd-shopify] 📖 Variant choice from cookie:', variantId);
-
-    // If no stored choice, assign a variant
-    if (!variantId) {
-      console.log('[cascayd-shopify] 🆕 No stored variant, assigning new one...');
-      if (sdk && sdk.assignVariant) {
-        try {
-          console.log('[cascayd-shopify] 🎲 Calling SDK assignVariant...');
-          const result = await sdk.assignVariant(experimentId);
-          variantId = result.variantId;
-          console.log('[cascayd-shopify] ✅ SDK assigned variant:', variantId);
-          persistVariantChoice(experimentId, variantId);
-        } catch (error) {
-          console.error('[cascayd-shopify] ❌ Failed to assign variant via SDK:', error);
-          // Fallback: use first available variant or control
-          const variants = [];
-          variantElements.forEach(function(el) {
-            const vId = el.getAttribute('data-cascayd-variant');
-            if (vId && variants.indexOf(vId) === -1) {
-              variants.push(vId);
+}
+function showVariant(experimentId, variantId) {
+    const selector = `[data-cascayd-experiment="${experimentId}"]`;
+    const elements = document.querySelectorAll(selector);
+    elements.forEach((el) => {
+        const elVariantId = el.getAttribute('data-cascayd-variant');
+        if (elVariantId === variantId) {
+            el.classList.add('cascayd-visible');
+            const computedStyle = window.getComputedStyle(el);
+            if (computedStyle.display === 'inline' || computedStyle.display === 'inline-block') {
+                el.classList.add('cascayd-visible-inline');
             }
-          });
-          variantId = variants.indexOf('control') >= 0 ? 'control' : (variants[0] || 'control');
-          console.log('[cascayd-shopify] 🔄 Using fallback variant:', variantId, 'from available:', variants);
-          persistVariantChoice(experimentId, variantId);
-        }
-      } else {
-        console.error('[cascayd-shopify] ❌ No assignVariant function available');
-        // This shouldn't happen since waitForSDK always returns functions (direct API or SDK)
-      }
-    } else {
-      console.log('[cascayd-shopify] ✅ Using existing variant choice:', variantId);
-    }
-
-    // Show the selected variant, hide all others
-    console.log('[cascayd-shopify] 👁️ Showing/hiding variants. Selected:', variantId);
-    let hasRecorded = false;
-    variantElements.forEach(function(el, index) {
-      const elVariantId = el.getAttribute('data-cascayd-variant');
-      console.log('[cascayd-shopify]   Element ' + (index + 1) + ':', { variantId: elVariantId, matches: elVariantId === variantId });
-      
-      if (elVariantId === variantId) {
-        console.log('[cascayd-shopify]   ✅ Showing element with variant:', elVariantId);
-        // Remove CSS hiding and mark as visible
-        el.classList.remove('cascayd-hidden');
-        el.classList.add('cascayd-visible');
-        // Detect if element should be inline or block based on original display
-        const computedStyle = window.getComputedStyle(el);
-        if (computedStyle.display === 'inline' || computedStyle.display === 'inline-block') {
-          el.classList.add('cascayd-visible-inline');
         }
-        el.style.display = '';
-        el.removeAttribute('hidden');
-        console.log('[cascayd-shopify]   ✅ Element shown, classes:', el.className);
-        // Record impression only once for the shown variant
-        if (!hasRecorded) {
-          recordImpression(experimentId, variantId, sdk);
-          hasRecorded = true;
+        else {
+            el.classList.remove('cascayd-visible', 'cascayd-visible-inline');
         }
-      } else {
-        console.log('[cascayd-shopify]   🚫 Hiding element with variant:', elVariantId);
-        el.style.display = 'none';
-        el.setAttribute('hidden', 'hidden');
-        el.classList.add('cascayd-hidden');
-        el.classList.remove('cascayd-visible', 'cascayd-visible-inline');
-      }
     });
-    console.log('[cascayd-shopify] ✅ Finished processing experiment:', experimentId);
-  }
-
-  // Main initialization function
-  async function initCascaydExperiments() {
-    console.log('[cascayd-shopify] 🎯 initCascaydExperiments called');
-    console.log('[cascayd-shopify] 📄 Document readyState:', document.readyState);
-    
-    // Wait for SDK to be loaded (with timeout)
-    console.log('[cascayd-shopify] ⏳ Waiting for SDK...');
-    const sdk = await waitForSDK(50, 100);
-    console.log('[cascayd-shopify] ✅ SDK ready:', { hasSDK: !!sdk, hasAssignVariant: !!(sdk && sdk.assignVariant), hasRecord: !!(sdk && sdk.record) });
-
-    // Find all elements with data-cascayd-experiment attribute
-    const allExperimentElements = document.querySelectorAll('[data-cascayd-experiment]');
-    console.log('[cascayd-shopify] 🔍 Found experiment elements:', allExperimentElements.length);
-
-    if (allExperimentElements.length === 0) {
-      console.log('[cascayd-shopify] ℹ️ No experiment elements found, exiting');
-      return; // No experiments to process
+}
+function sendImpression(experimentId, variantId) {
+    if (!variantId)
+        return;
+    const key = `${experimentId}:${variantId}`;
+    if (sentImpressions.has(key))
+        return;
+    sentImpressions.add(key);
+    void record('impression', { experimentId, variantId });
+}
+function findVariantIdFromElement(el, experimentId) {
+    // First try cookie (most reliable)
+    const fromCookie = readVariantChoice(experimentId);
+    if (fromCookie)
+        return fromCookie;
+    // Fallback: traverse up DOM to find parent with data-cascayd-variant
+    let current = el;
+    while (current) {
+        const variantId = current.getAttribute('data-cascayd-variant');
+        if (variantId)
+            return variantId;
+        // Check if we're inside an experiment container
+        const experimentIdAttr = current.getAttribute('data-cascayd-experiment');
+        if (experimentIdAttr === experimentId) {
+            // We're in the right experiment container, continue up
+            current = current.parentElement;
+        }
+        else {
+            // Move up to find experiment container
+            current = current.parentElement;
+        }
     }
-
-    // Log all found elements
-    allExperimentElements.forEach(function(el, index) {
-      const expId = el.getAttribute('data-cascayd-experiment');
-      const varId = el.getAttribute('data-cascayd-variant');
-      console.log('[cascayd-shopify]   Element ' + (index + 1) + ':', { experimentId: expId, variantId: varId, tagName: el.tagName });
+    return null;
+}
+function setupConversionTracking(experimentId) {
+    const selector = `[data-cascayd-experiment="${experimentId}"] [data-cascayd-conversion]`;
+    const elements = document.querySelectorAll(selector);
+    elements.forEach((el) => {
+        if (el.hasAttribute('data-cascayd-tracked'))
+            return;
+        el.setAttribute('data-cascayd-tracked', 'true');
+        el.addEventListener('click', (e) => {
+            const variantId = findVariantIdFromElement(el, experimentId);
+            if (variantId) {
+                void record('conversion', { experimentId, variantId });
+            }
+            else {
+                console.warn(`[cascayd-shopify] No variant found for experiment ${experimentId} when recording conversion`);
+            }
+        });
     });
-
-    // Group elements by experiment ID
-    const experiments = new Map();
-
-    allExperimentElements.forEach(function(el) {
-      const experimentId = el.getAttribute('data-cascayd-experiment');
-      if (!experimentId) {
-        console.warn('[cascayd-shopify] ⚠️ Element missing experiment ID:', el);
+}
+async function processExperiment(experimentId) {
+    try {
+        getOrCreateSession();
+        const variantId = await assignVariantForExperiment(experimentId);
+        showVariant(experimentId, variantId);
+        sendImpression(experimentId, variantId);
+        setupConversionTracking(experimentId);
+    }
+    catch (error) {
+        console.error(`[cascayd-shopify] Failed to process experiment ${experimentId}`, error);
+    }
+}
+function initShopifyHandler() {
+    if (typeof window === 'undefined' || typeof document === 'undefined')
         return;
-      }
-
-      if (!experiments.has(experimentId)) {
-        experiments.set(experimentId, []);
-      }
-      experiments.get(experimentId).push(el);
-    });
-
-    console.log('[cascayd-shopify] 📊 Grouped experiments:', Array.from(experiments.keys()).map(function(id) {
-      return { experimentId: id, variantCount: experiments.get(id).length };
-    }));
-
-    // Process each experiment
-    const promises = [];
-    experiments.forEach(function(variantElements, experimentId) {
-      console.log('[cascayd-shopify] 🚀 Processing experiment:', experimentId, 'with', variantElements.length, 'variants');
-      promises.push(processExperiment(experimentId, variantElements, sdk));
-    });
-
-    console.log('[cascayd-shopify] ⏳ Waiting for all experiments to process...');
-    await Promise.all(promises);
-    console.log('[cascayd-shopify] ✅ All experiments processed!');
-  }
-
-  // Initialize when DOM is ready
-  console.log('[cascayd-shopify] 🔄 Setting up initialization...');
-  if (document.readyState === 'loading') {
-    console.log('[cascayd-shopify] ⏳ DOM still loading, waiting for DOMContentLoaded...');
-    document.addEventListener('DOMContentLoaded', function() {
-      console.log('[cascayd-shopify] ✅ DOMContentLoaded fired!');
-      initCascaydExperiments();
-    });
-  } else {
-    // DOM already ready
-    console.log('[cascayd-shopify] ✅ DOM already ready, initializing immediately');
-    initCascaydExperiments();
-  }
-
-  // Handle Shopify's dynamic content (sections loaded via AJAX)
-  if (typeof window.addEventListener !== 'undefined') {
-    console.log('[cascayd-shopify] 🛒 Setting up Shopify section event listeners...');
-    document.addEventListener('shopify:section:load', function() {
-      console.log('[cascayd-shopify] 🔄 shopify:section:load event fired, re-initializing...');
-      initCascaydExperiments();
+    const experimentElements = document.querySelectorAll('[data-cascayd-experiment]');
+    const experimentIds = new Set();
+    experimentElements.forEach((el) => {
+        const experimentId = el.getAttribute('data-cascayd-experiment');
+        if (experimentId) {
+            experimentIds.add(experimentId);
+        }
     });
-    document.addEventListener('shopify:section:reorder', function() {
-      console.log('[cascayd-shopify] 🔄 shopify:section:reorder event fired, re-initializing...');
-      initCascaydExperiments();
+    experimentIds.forEach((experimentId) => {
+        void processExperiment(experimentId);
     });
-  }
-  
-  console.log('[cascayd-shopify] ✅ Handler script initialization complete');
-})();
-
+}
+if (typeof window !== 'undefined') {
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initShopifyHandler);
+    }
+    else {
+        initShopifyHandler();
+    }
+}

package/dist/types.d.ts

@@ -21,4 +21,5 @@ export type RecordOptions = {
     experimentId?: string;
     value?: number;
     variantId?: string;
+    route?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascayd/experiment",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "A lightweight A/B testing SDK for React applications with server-side analytics integration",
   "keywords": [
     "ab-testing",