@cascayd/experiment 0.1.0 → 0.3.0

package/README.md

@@ -138,3 +138,21 @@ import type { InitOptions, EventType, RecordOptions } from '@cascayd/experiment'
 
 MIT
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/dist/client.d.ts

@@ -1,5 +1,6 @@
-import { InitOptions, ExperimentConfigResponse, EventType, RecordOptions } from './types';
+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<{
     variantId: string;
     config: ExperimentConfigResponse;

package/dist/client.js

@@ -1,14 +1,17 @@
 import { getOrCreateSession, readVariantChoice } from './cookies';
 let API_KEY = '';
-let BASE_URL = 'http://localhost:8000';
-const SDK_VERSION = '0.1.0-dev';
+let BASE_URL = 'https://ab-mvp-backend.onrender.com';
+const SDK_VERSION = '0.2.0-dev';
 export function initCascayd(opts) {
     API_KEY = opts.apiKey;
-    BASE_URL = opts.baseUrl ?? BASE_URL;
     const masked = API_KEY ? API_KEY.slice(0, 3) + '***' + API_KEY.slice(-3) : '(empty)';
     // Visible init log to confirm updated SDK loaded
     // eslint-disable-next-line no-console
     console.log('[cascayd-sdk]', SDK_VERSION, { baseUrl: BASE_URL, apiKey: masked });
+    console.log('[cascayd-sdk] init complete', {
+        version: SDK_VERSION,
+        url: BASE_URL,
+    });
 }
 async function fetchConfig(experimentId) {
     const res = await fetch(`${BASE_URL}/experiments/${encodeURIComponent(experimentId)}/config`);
@@ -16,6 +19,18 @@ async function fetchConfig(experimentId) {
         throw new Error(`Config load failed: ${res.status}`);
     return (await res.json());
 }
+export async function getVariantStatus(experimentId, variantId) {
+    console.log('[cascayd-sdk] getVariantStatus', experimentId, variantId);
+    const res = await fetch(`${BASE_URL}/experiments/${encodeURIComponent(experimentId)}/variants/${encodeURIComponent(variantId)}/status`);
+    const data = (await res.json());
+    console.log('[cascayd-sdk] getVariantStatus response', data);
+    if (!res.ok) {
+        const err = new Error(`Variant status failed: ${res.status}`);
+        err.payload = data;
+        throw err;
+    }
+    return data;
+}
 function chooseByWeight(variants) {
     const total = variants.reduce((s, v) => s + v.weight, 0);
     const r = Math.random() * total;
@@ -28,9 +43,37 @@ function chooseByWeight(variants) {
     return variants[variants.length - 1]?.id ?? 'control';
 }
 export async function assignVariant(experimentId) {
-    const cfg = await fetchConfig(experimentId);
-    const variantId = chooseByWeight(cfg.variants);
-    return { variantId, config: cfg };
+    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.error('[cascayd-sdk] getVariantStatus failed', { experimentId, candidate, error });
+            const weights = error?.payload?.weights;
+            if (weights) {
+                console.log('[cascayd-sdk] getVariantStatus failed weights', weights);
+            }
+            // swallow and fall back to candidate
+        }
+    }
+    const serving = finalStatus?.serving_variant_id || candidate || 'control';
+    const config = {
+        experiment_id: baseStatus.experiment_id,
+        variants: variants.length > 0 ? variants : baseStatusToVariants(baseStatus),
+    };
+    return { variantId: serving, config };
+}
+function baseStatusToVariants(status) {
+    const entries = Object.entries(status.weights || {});
+    if (entries.length === 0) {
+        return [{ id: 'control', weight: 1 }];
+    }
+    return entries.map(([id, weight]) => ({ id, weight }));
 }
 export async function record(type, opts = {}) {
     const sessionId = getOrCreateSession();

package/dist/react/Experiment.d.ts

@@ -1,5 +1,6 @@
+import type { ReactElement } from 'react';
 export type ExperimentProps = {
     id: string;
     children: React.ReactNode;
 };
-export declare function Experiment({ id, children }: ExperimentProps): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;
+export declare function Experiment({ id, children }: ExperimentProps): ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;

package/dist/react/Experiment.js

@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { record } from '../client';
+import { getVariantStatus, record } from '../client';
 import { getOrCreateSession, persistVariantChoice, readVariantChoice } from '../cookies';
 const sentImpressions = new Set();
 export function Experiment({ id, children }) {
@@ -15,61 +15,179 @@ export function Experiment({ id, children }) {
         }
         return arr;
     }, [children]);
-    function chooseByWeight(items) {
-        const total = items.reduce((s, i) => s + i.weight, 0) || 1;
-        const r = Math.random() * total;
-        let acc = 0;
-        for (const it of items) {
-            acc += it.weight;
-            if (r <= acc)
-                return it.id;
-        }
-        return items[items.length - 1]?.id || 'control';
-    }
     useEffect(() => {
         if (hasRunRef.current)
             return;
         hasRunRef.current = true;
         const existing = readVariantChoice(id);
-        if (existing) {
-            setActive(existing);
-            if (!sentImpressions.has(id)) {
-                sentImpressions.add(id);
-                void record('impression', { experimentId: id, variantId: existing });
-            }
-            return;
-        }
         let cancelled = false;
         getOrCreateSession();
-        // Decide assignment: use provided weights if any, else split evenly among variant children
-        const provided = childrenArray.filter((c) => typeof c.weight === 'number');
-        let chosen = null;
-        if (provided.length > 0) {
-            const normalized = (() => {
-                const sum = provided.reduce((s, c) => s + c.weight, 0) || 1;
-                return provided.map((c) => ({ id: c.id, weight: c.weight / sum }));
-            })();
-            chosen = chooseByWeight(normalized);
-        }
-        else if (childrenArray.length > 0) {
-            const equal = 1 / childrenArray.length;
-            const items = childrenArray.map((c) => ({ id: c.id, weight: equal }));
-            chosen = chooseByWeight(items);
-        }
-        if (chosen && !cancelled) {
-            persistVariantChoice(id, chosen);
-            setActive(chosen);
-            if (!sentImpressions.has(id)) {
-                sentImpressions.add(id);
-                void record('impression', { experimentId: id, variantId: chosen });
+        void (async () => {
+            try {
+                if (existing) {
+                    console.log('[cascayd-sdk] fetching variant status', {
+                        experimentId: id,
+                        variantId: existing,
+                    });
+                    console.log('[cascayd-sdk] current children', childrenArray.map((c) => c.id));
+                    try {
+                        const status = await getVariantStatus(id, existing);
+                        if (cancelled)
+                            return;
+                        console.log('[cascayd-sdk] received variant status', status);
+                        logWeights('[cascayd-sdk] existing variant weights', status.weights);
+                        const serving = resolveVariant(status.serving_variant_id || existing, childrenArray);
+                        applyAssignment(id, serving, setActive);
+                        sendImpression(id, serving);
+                        return;
+                    }
+                    catch (error) {
+                        console.error('[cascayd-sdk] existing variant status fetch failed', {
+                            experimentId: id,
+                            variantId: existing,
+                            error,
+                        });
+                        logWeights('[cascayd-sdk] existing variant weights (error path)', errorWeights(error));
+                    }
+                }
+                console.log('[cascayd-sdk] fetching base status', { experimentId: id, variantId: 'control' });
+                const baseStatus = await getVariantStatus(id, 'control');
+                if (cancelled)
+                    return;
+                console.log('[cascayd-sdk] received base status', baseStatus);
+                logWeights('[cascayd-sdk] base weights', baseStatus.weights);
+                const weighted = buildWeights(childrenArray, baseStatus.weights);
+                console.log('[cascayd-sdk] child weights entries', weighted);
+                logWeights('[cascayd-sdk] computed child weights', Object.fromEntries(weighted.map((w) => [w.id, w.weight])));
+                const candidate = chooseByWeight(weighted);
+                let finalVariant = candidate;
+                if (candidate) {
+                    console.log('[cascayd-sdk] verifying candidate status', {
+                        experimentId: id,
+                        variantId: candidate,
+                    });
+                    try {
+                        const status = await getVariantStatus(id, candidate);
+                        if (cancelled)
+                            return;
+                        console.log('[cascayd-sdk] received candidate status', status);
+                        logWeights('[cascayd-sdk] candidate weights', status.weights);
+                        finalVariant = status.serving_variant_id || candidate;
+                    }
+                    catch (error) {
+                        console.error('[cascayd-sdk] candidate status fetch failed, using fallback', {
+                            experimentId: id,
+                            variantId: candidate,
+                            error,
+                        });
+                        logWeights('[cascayd-sdk] candidate weights (error path)', errorWeights(error));
+                    }
+                }
+                const serving = resolveVariant(finalVariant, childrenArray);
+                applyAssignment(id, serving, setActive);
+                sendImpression(id, serving);
             }
-        }
+            catch (err) {
+                console.error('[cascayd-sdk] variant assignment error, using fallback assignment', err);
+                console.log('[cascayd-sdk] fallback children', childrenArray);
+                const fallbackVariant = fallbackAssign(childrenArray);
+                if (cancelled)
+                    return;
+                console.log('[cascayd-sdk] fallback assignment chosen', fallbackVariant);
+                applyAssignment(id, fallbackVariant, setActive);
+                sendImpression(id, fallbackVariant);
+            }
+        })();
         return () => {
             cancelled = true;
         };
-    }, [id]);
+    }, [id, childrenArray]);
     if (!active)
         return null;
     const match = childrenArray.find((c) => c.id === active);
     return match ? match.element : null;
 }
+function buildWeights(children, weights) {
+    if (weights && Object.keys(weights).length > 0) {
+        const subset = children
+            .map((child) => ({ id: child.id, weight: typeof weights[child.id] === 'number' ? weights[child.id] : 0 }))
+            .filter((item) => item.weight > 0);
+        if (subset.length > 0) {
+            const total = subset.reduce((sum, item) => sum + item.weight, 0) || 1;
+            return subset.map((item) => ({ id: item.id, weight: item.weight / total }));
+        }
+    }
+    const provided = children.filter((c) => typeof c.weight === 'number');
+    if (provided.length > 0) {
+        const sum = provided.reduce((acc, item) => acc + item.weight, 0) || 1;
+        return provided.map((item) => ({ id: item.id, weight: item.weight / sum }));
+    }
+    if (children.length === 0)
+        return [{ id: 'control', weight: 1 }];
+    const equal = 1 / children.length;
+    return children.map((c) => ({ id: c.id, weight: equal }));
+}
+function resolveVariant(candidate, children) {
+    if (candidate && children.some((c) => c.id === candidate))
+        return candidate;
+    if (children.some((c) => c.id === 'control'))
+        return 'control';
+    return children[0]?.id ?? 'control';
+}
+function applyAssignment(experimentId, variantId, setActive) {
+    persistVariantChoice(experimentId, variantId);
+    setActive(variantId);
+}
+function sendImpression(experimentId, variantId) {
+    if (!variantId)
+        return;
+    if (sentImpressions.has(`${experimentId}:${variantId}`))
+        return;
+    sentImpressions.add(`${experimentId}:${variantId}`);
+    void record('impression', { experimentId, variantId });
+}
+function fallbackAssign(children) {
+    console.log('[cascayd-sdk] fallback assign start', children);
+    const weighted = buildWeights(children, undefined);
+    console.log('[cascayd-sdk] fallback weighted', weighted);
+    const chosen = chooseByWeight(weighted);
+    console.log('[cascayd-sdk] fallback chosen', chosen);
+    return chosen;
+}
+function chooseByWeight(items) {
+    console.log('[cascayd-sdk] choosing by weight', items);
+    const total = items.reduce((sum, item) => sum + item.weight, 0) || 1;
+    const roll = Math.random() * total;
+    console.log('[cascayd-sdk] total weight', total, 'roll', roll);
+    let acc = 0;
+    for (const item of items) {
+        acc += item.weight;
+        console.log('[cascayd-sdk] accumulate', { item: item.id, acc });
+        if (roll <= acc)
+            return item.id;
+    }
+    return items[items.length - 1]?.id || 'control';
+}
+function logWeights(label, weights) {
+    if (!weights || Object.keys(weights).length === 0) {
+        console.log(label, '(none)');
+        return;
+    }
+    console.log(label, weights);
+    console.table(Object.entries(weights).map(([variantId, weight]) => ({
+        variantId,
+        weight: Number(weight.toFixed(4)),
+        percentage: `${(weight * 100).toFixed(2)}%`,
+    })));
+}
+function errorWeights(error) {
+    if (!error)
+        return undefined;
+    if (typeof error === 'object' && error && 'weights' in error) {
+        const weights = error.weights;
+        if (weights && typeof weights === 'object') {
+            return weights;
+        }
+    }
+    return undefined;
+}

package/dist/shopify-handler-browser.js

@@ -0,0 +1,323 @@
+/**
+ * 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';
+
+  // Cookie helper functions (matching SDK's cookie logic)
+  function getCookie(name) {
+    const match = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/[.$?*|{}()\[\]\\\/\+^]/g, '\\$&') + '=([^;]*)'));
+    return match ? decodeURIComponent(match[1]) : null;
+  }
+
+  function setCookie(name, value) {
+    document.cookie = `${name}=${encodeURIComponent(value)}; path=/; SameSite=Lax; max-age=31536000`;
+  }
+
+  function getVariantCookieKey(experimentId) {
+    return `cascayd:${experimentId}`;
+  }
+
+  function readVariantChoice(experimentId) {
+    return getCookie(getVariantCookieKey(experimentId));
+  }
+
+  function persistVariantChoice(experimentId, variantId) {
+    setCookie(getVariantCookieKey(experimentId), 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 res = await fetch(
+      BASE_URL + '/experiments/' + encodeURIComponent(experimentId) + '/variants/' + encodeURIComponent(variantId) + '/status'
+    );
+    const data = await res.json();
+    if (!res.ok) {
+      const err = new Error('Variant status failed: ' + res.status);
+      err.payload = data;
+      throw err;
+    }
+    return data;
+  }
+
+  function chooseByWeight(variants) {
+    const total = variants.reduce(function(s, v) { return s + v.weight; }, 0);
+    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;
+      }
+    }
+    return variants[variants.length - 1] ? 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) {
+    const baseStatus = await getVariantStatus(experimentId, 'control');
+    const weights = baseStatus.weights || {};
+    const variants = Object.entries(weights).map(function(entry) {
+      return { id: entry[0], weight: entry[1] };
+    });
+
+    const allVariants = variants.length > 0 ? variants : baseStatusToVariants(baseStatus);
+    let candidate = chooseByWeight(allVariants);
+    let finalStatus = null;
+
+    if (candidate) {
+      try {
+        finalStatus = await getVariantStatus(experimentId, candidate);
+      } catch (error) {
+        console.error('[cascayd-shopify] getVariantStatus failed', { experimentId: experimentId, candidate: candidate, error: error });
+        // Fall back to candidate
+      }
+    }
+
+    const serving = (finalStatus && finalStatus.serving_variant_id) || candidate || 'control';
+    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;
+    }
+
+    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;
+    
+    return new Promise(function(resolve) {
+      let attempts = 0;
+      const checkSDK = function() {
+        attempts++;
+        // Check if SDK functions are available on window
+        let assignVariantFn = null;
+        let recordFn = null;
+        
+        if (typeof window !== 'undefined') {
+          if (window.assignVariant) assignVariantFn = window.assignVariant;
+          if (window.record) recordFn = window.record;
+          // Try Cascayd namespace
+          if (!assignVariantFn && window.Cascayd && window.Cascayd.assignVariant) {
+            assignVariantFn = window.Cascayd.assignVariant;
+          }
+          if (!recordFn && window.Cascayd && window.Cascayd.record) {
+            recordFn = window.Cascayd.record;
+          }
+        }
+        
+        if (assignVariantFn && recordFn) {
+          resolve({ assignVariant: assignVariantFn, record: recordFn });
+        } else if (attempts >= maxAttempts) {
+          // Use direct API calls as fallback
+          resolve({ assignVariant: assignVariantDirect, record: recordDirect });
+        } else {
+          setTimeout(checkSDK, interval);
+        }
+      };
+      checkSDK();
+    });
+  }
+
+  // Record impression event
+  async function recordImpression(experimentId, variantId, sdk) {
+    if (!sdk || !sdk.record) {
+      console.debug('[cascayd-shopify] Record function not available, skipping impression tracking');
+      return;
+    }
+
+    try {
+      await sdk.record('impression', {
+        experimentId: experimentId,
+        variantId: variantId
+      });
+    } catch (error) {
+      console.error('[cascayd-shopify] Failed to record impression', error);
+    }
+  }
+
+  // Process a single experiment
+  async function processExperiment(experimentId, variantElements, sdk) {
+    // Check if we already have a variant choice stored
+    let variantId = readVariantChoice(experimentId);
+
+    // If no stored choice, assign a variant
+    if (!variantId) {
+      if (sdk && sdk.assignVariant) {
+        try {
+          const result = await sdk.assignVariant(experimentId);
+          variantId = result.variantId;
+          persistVariantChoice(experimentId, variantId);
+        } catch (error) {
+          console.error('[cascayd-shopify] Failed to assign variant', 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);
+            }
+          });
+          variantId = variants.indexOf('control') >= 0 ? 'control' : (variants[0] || 'control');
+          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)
+      }
+    }
+
+    // Show the selected variant, hide all others
+    let hasRecorded = false;
+    variantElements.forEach(function(el) {
+      const elVariantId = el.getAttribute('data-cascayd-variant');
+      if (elVariantId === variantId) {
+        el.style.display = '';
+        el.removeAttribute('hidden');
+        // Record impression only once for the shown variant
+        if (!hasRecorded) {
+          recordImpression(experimentId, variantId, sdk);
+          hasRecorded = true;
+        }
+      } else {
+        el.style.display = 'none';
+        el.setAttribute('hidden', 'hidden');
+      }
+    });
+  }
+
+  // Main initialization function
+  async function initCascaydExperiments() {
+    // Wait for SDK to be loaded (with timeout)
+    const sdk = await waitForSDK(50, 100);
+
+    // Find all elements with data-cascayd-experiment attribute
+    const allExperimentElements = document.querySelectorAll('[data-cascayd-experiment]');
+
+    if (allExperimentElements.length === 0) {
+      return; // No experiments to process
+    }
+
+    // Group elements by experiment ID
+    const experiments = new Map();
+
+    allExperimentElements.forEach(function(el) {
+      const experimentId = el.getAttribute('data-cascayd-experiment');
+      if (!experimentId) return;
+
+      if (!experiments.has(experimentId)) {
+        experiments.set(experimentId, []);
+      }
+      experiments.get(experimentId).push(el);
+    });
+
+    // Process each experiment
+    const promises = [];
+    experiments.forEach(function(variantElements, experimentId) {
+      promises.push(processExperiment(experimentId, variantElements, sdk));
+    });
+
+    await Promise.all(promises);
+  }
+
+  // Initialize when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initCascaydExperiments);
+  } else {
+    // DOM already ready
+    initCascaydExperiments();
+  }
+
+  // Handle Shopify's dynamic content (sections loaded via AJAX)
+  if (typeof window.addEventListener !== 'undefined') {
+    document.addEventListener('shopify:section:load', initCascaydExperiments);
+    document.addEventListener('shopify:section:reorder', initCascaydExperiments);
+  }
+})();
+

package/dist/shopify-handler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Cascayd A/B Testing - Shopify Theme Handler
+ * This script automatically handles variant selection for elements with
+ * data-cascayd-experiment and data-cascayd-variant attributes
+ *
+ * Expects the Cascayd SDK to be loaded first via:
+ * <script src="https://cdn.jsdelivr.net/npm/@cascayd/experiment@latest/dist/client.js"></script>
+ */
+export {};

package/dist/shopify-handler.js

@@ -0,0 +1,124 @@
+/**
+ * Cascayd A/B Testing - Shopify Theme Handler
+ * This script automatically handles variant selection for elements with
+ * data-cascayd-experiment and data-cascayd-variant attributes
+ *
+ * Expects the Cascayd SDK to be loaded first via:
+ * <script src="https://cdn.jsdelivr.net/npm/@cascayd/experiment@latest/dist/client.js"></script>
+ */
+import { assignVariant, record } from './client';
+import { readVariantChoice, persistVariantChoice } from './cookies';
+// Wait for SDK to be available
+function waitForSDK(maxAttempts = 50, interval = 100) {
+    return new Promise((resolve, reject) => {
+        let attempts = 0;
+        const checkSDK = () => {
+            attempts++;
+            // Check if SDK functions are available (either from import or window)
+            if (typeof assignVariant === 'function' && typeof record === 'function') {
+                resolve();
+            }
+            else if (attempts >= maxAttempts) {
+                console.warn('[cascayd-shopify] SDK not loaded after', maxAttempts, 'attempts');
+                reject(new Error('SDK not available'));
+            }
+            else {
+                setTimeout(checkSDK, interval);
+            }
+        };
+        checkSDK();
+    });
+}
+// Record impression event
+async function recordImpression(experimentId, variantId) {
+    try {
+        await record('impression', {
+            experimentId,
+            variantId,
+        });
+    }
+    catch (error) {
+        console.error('[cascayd-shopify] Failed to record impression', error);
+    }
+}
+// Process a single experiment
+async function processExperiment(experimentId, variantElements) {
+    // Check if we already have a variant choice stored
+    let variantId = readVariantChoice(experimentId);
+    // If no stored choice, assign a variant
+    if (!variantId) {
+        try {
+            const result = await assignVariant(experimentId);
+            variantId = result.variantId;
+            persistVariantChoice(experimentId, variantId);
+        }
+        catch (error) {
+            console.error('[cascayd-shopify] Failed to assign variant', error);
+            // Fallback: use first available variant or control
+            const variants = variantElements.map(el => el.getAttribute('data-cascayd-variant')).filter(Boolean);
+            variantId = variants.find(v => v === 'control') || variants[0] || 'control';
+        }
+    }
+    // Show the selected variant, hide all others
+    let hasRecorded = false;
+    variantElements.forEach(el => {
+        const htmlEl = el;
+        const elVariantId = el.getAttribute('data-cascayd-variant');
+        if (elVariantId === variantId) {
+            htmlEl.style.display = '';
+            el.removeAttribute('hidden');
+            // Record impression only once for the shown variant
+            if (!hasRecorded) {
+                recordImpression(experimentId, variantId);
+                hasRecorded = true;
+            }
+        }
+        else {
+            htmlEl.style.display = 'none';
+            el.setAttribute('hidden', 'hidden');
+        }
+    });
+}
+// Main initialization function
+async function initCascaydExperiments() {
+    // Wait for SDK to be loaded
+    try {
+        await waitForSDK();
+    }
+    catch (error) {
+        console.error('[cascayd-shopify] SDK not available, experiments will not run', error);
+        return;
+    }
+    // Find all elements with data-cascayd-experiment attribute
+    const allExperimentElements = document.querySelectorAll('[data-cascayd-experiment]');
+    if (allExperimentElements.length === 0) {
+        return; // No experiments to process
+    }
+    // Group elements by experiment ID
+    const experiments = new Map();
+    allExperimentElements.forEach(el => {
+        const experimentId = el.getAttribute('data-cascayd-experiment');
+        if (!experimentId)
+            return;
+        if (!experiments.has(experimentId)) {
+            experiments.set(experimentId, []);
+        }
+        experiments.get(experimentId).push(el);
+    });
+    // Process each experiment in parallel
+    const promises = Array.from(experiments.entries()).map(([experimentId, variantElements]) => processExperiment(experimentId, variantElements));
+    await Promise.all(promises);
+}
+// Initialize when DOM is ready
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', initCascaydExperiments);
+}
+else {
+    // DOM already ready
+    initCascaydExperiments();
+}
+// Handle Shopify's dynamic content (sections loaded via AJAX)
+if (typeof window.addEventListener !== 'undefined') {
+    document.addEventListener('shopify:section:load', initCascaydExperiments);
+    document.addEventListener('shopify:section:reorder', initCascaydExperiments);
+}

package/dist/types.d.ts

@@ -1,6 +1,5 @@
 export type InitOptions = {
     apiKey: string;
-    baseUrl?: string;
 };
 export type VariantConfig = {
     id: string;
@@ -10,6 +9,13 @@ export type ExperimentConfigResponse = {
     experiment_id: string;
     variants: VariantConfig[];
 };
+export type VariantStatusResponse = {
+    experiment_id: string;
+    requested_variant_id: string;
+    variant_status: string | null;
+    serving_variant_id: string;
+    weights: Record<string, number>;
+};
 export type EventType = 'impression' | 'conversion';
 export type RecordOptions = {
     experimentId?: string;

package/package.json

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