shopkit-analytics 1.0.0

package/dist/affiliate/index.js

@@ -0,0 +1,816 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/affiliate/index.tsx
+var affiliate_exports = {};
+__export(affiliate_exports, {
+  AFFILIATE_PARAMETERS: () => AFFILIATE_PARAMETERS,
+  ALL_AFFILIATE_PARAMETERS: () => ALL_AFFILIATE_PARAMETERS,
+  ATTRIBUTION_CHANNELS: () => ATTRIBUTION_CHANNELS,
+  ATTRIBUTION_MODELS: () => ATTRIBUTION_MODELS,
+  AffiliateAnalytics: () => AffiliateAnalytics,
+  AffiliateAttribution: () => AffiliateAttribution,
+  AffiliateTestUtils: () => AffiliateTestUtils,
+  AffiliateTracker: () => AffiliateTracker_default,
+  AffiliateUrlUtils: () => AffiliateUrlUtils,
+  AffiliateValidation: () => AffiliateValidation,
+  CLICK_ID_PARAMETERS: () => CLICK_ID_PARAMETERS,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  EVENT_TYPES: () => EVENT_TYPES,
+  SEARCH_ENGINES: () => SEARCH_ENGINES,
+  SOCIAL_PLATFORMS: () => SOCIAL_PLATFORMS,
+  STORAGE_CONFIG: () => STORAGE_CONFIG,
+  STORAGE_TYPES: () => STORAGE_TYPES,
+  UTM_PARAMETERS: () => UTM_PARAMETERS,
+  addEventListener: () => addEventListener,
+  appendAffiliateParams: () => appendAffiliateParams,
+  captureAffiliateParams: () => captureAffiliateParams,
+  clearAffiliateParams: () => clearAffiliateParams,
+  configureAffiliateTracker: () => configureAffiliateTracker,
+  getAffiliateParams: () => getAffiliateParams,
+  getAffiliateParamsAsUrlString: () => getAffiliateParamsAsUrlString,
+  getAffiliateSource: () => getAffiliateSource,
+  getConfig: () => getConfig,
+  hasAffiliateData: () => hasAffiliateData,
+  resetConfig: () => resetConfig,
+  useAffiliateEvents: () => useAffiliateEvents,
+  useAffiliateSource: () => useAffiliateSource,
+  useAffiliateTracker: () => useAffiliateTracker,
+  useAutoCapture: () => useAutoCapture,
+  useHasAffiliateData: () => useHasAffiliateData
+});
+module.exports = __toCommonJS(affiliate_exports);
+
+// src/affiliate/AffiliateTracker.tsx
+var import_react = require("react");
+
+// src/affiliate/constants.ts
+var UTM_PARAMETERS = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content"
+];
+var CLICK_ID_PARAMETERS = [
+  "gclid",
+  // Google Ads
+  "fbclid",
+  // Facebook
+  "msclkid",
+  // Microsoft Ads
+  "ttclid",
+  // TikTok
+  "twclid",
+  // Twitter
+  "li_fat_id"
+  // LinkedIn
+];
+var AFFILIATE_PARAMETERS = [
+  "click_id",
+  "affiliate_id",
+  "ref",
+  "source",
+  "referrer"
+];
+var ALL_AFFILIATE_PARAMETERS = [
+  ...UTM_PARAMETERS,
+  ...CLICK_ID_PARAMETERS,
+  ...AFFILIATE_PARAMETERS
+];
+var STORAGE_CONFIG = {
+  DEFAULT_KEY: "affiliateParams",
+  DEFAULT_TTL: 30 * 24 * 60 * 60 * 1e3
+  // 30 days in milliseconds
+};
+var ATTRIBUTION_MODELS = {
+  FIRST_TOUCH: "first-touch",
+  LAST_TOUCH: "last-touch"
+};
+var STORAGE_TYPES = {
+  SESSION: "sessionStorage",
+  LOCAL: "localStorage"
+};
+var EVENT_TYPES = {
+  CAPTURE: "capture",
+  CLEAR: "clear",
+  EXPIRE: "expire"
+};
+var ATTRIBUTION_CHANNELS = {
+  DIRECT: "direct",
+  PAID_SEARCH: "paid_search",
+  ORGANIC_SEARCH: "organic_search",
+  SOCIAL: "social",
+  EMAIL: "email",
+  AFFILIATE: "affiliate",
+  REFERRAL: "referral",
+  DISPLAY: "display"
+};
+var SEARCH_ENGINES = [
+  "google.com",
+  "bing.com",
+  "yahoo.com",
+  "duckduckgo.com",
+  "baidu.com",
+  "yandex.com",
+  "ask.com"
+];
+var SOCIAL_PLATFORMS = [
+  "facebook",
+  "instagram",
+  "twitter",
+  "linkedin",
+  "tiktok",
+  "youtube",
+  "pinterest",
+  "snapchat"
+];
+
+// src/affiliate/affiliate-tracker.ts
+var DEFAULT_CONFIG = {
+  storageKey: STORAGE_CONFIG.DEFAULT_KEY,
+  storageType: STORAGE_TYPES.SESSION,
+  attribution: ATTRIBUTION_MODELS.LAST_TOUCH,
+  ttl: STORAGE_CONFIG.DEFAULT_TTL,
+  customParams: [],
+  enableReferrerCapture: true,
+  enableUserAgentCapture: false,
+  onCapture: () => {
+  },
+  onError: () => {
+  }
+};
+var currentConfig = { ...DEFAULT_CONFIG };
+var eventListeners = [];
+function configureAffiliateTracker(config = {}) {
+  currentConfig = { ...DEFAULT_CONFIG, ...config };
+}
+function generateSessionId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function getStorage() {
+  if (typeof window === "undefined") return null;
+  try {
+    return currentConfig.storageType === "localStorage" ? window.localStorage : window.sessionStorage;
+  } catch (error) {
+    currentConfig.onError(new Error(`Storage not available: ${error}`));
+    return null;
+  }
+}
+function isExpired(timestamp) {
+  return Date.now() - timestamp > currentConfig.ttl;
+}
+function emitEvent(event) {
+  eventListeners.forEach((listener) => {
+    try {
+      listener(event);
+    } catch (error) {
+      currentConfig.onError(new Error(`Event listener error: ${error}`));
+    }
+  });
+}
+function addEventListener(listener) {
+  eventListeners.push(listener);
+  return () => {
+    const index = eventListeners.indexOf(listener);
+    if (index > -1) {
+      eventListeners.splice(index, 1);
+    }
+  };
+}
+function captureAffiliateParams(customConfig) {
+  if (typeof window === "undefined") return null;
+  const originalConfig = currentConfig;
+  if (customConfig) {
+    currentConfig = { ...currentConfig, ...customConfig };
+  }
+  try {
+    const storage = getStorage();
+    if (!storage) return null;
+    const urlParams = new URLSearchParams(window.location.search);
+    const allKeys = [
+      ...ALL_AFFILIATE_PARAMETERS,
+      ...currentConfig.customParams
+    ];
+    const affiliateParams = {};
+    for (const key of allKeys) {
+      const value = urlParams.get(key);
+      if (value) {
+        affiliateParams[key] = value;
+      }
+    }
+    if (currentConfig.enableReferrerCapture && document.referrer) {
+      affiliateParams.referrer = document.referrer;
+    }
+    if (Object.keys(affiliateParams).length === 0) {
+      return null;
+    }
+    const existingData = getAffiliateParams();
+    let shouldUpdate = true;
+    if (existingData && currentConfig.attribution === "first-touch") {
+      shouldUpdate = false;
+    }
+    if (shouldUpdate) {
+      const affiliateData = {
+        ...affiliateParams,
+        timestamp: Date.now(),
+        sessionId: generateSessionId(),
+        attribution: currentConfig.attribution,
+        url: window.location.href,
+        ...currentConfig.enableUserAgentCapture && {
+          userAgent: navigator.userAgent
+        }
+      };
+      storage.setItem(currentConfig.storageKey, JSON.stringify(affiliateData));
+      emitEvent({
+        type: "capture",
+        data: affiliateData,
+        timestamp: Date.now()
+      });
+      currentConfig.onCapture(affiliateData);
+      return affiliateData;
+    }
+    return existingData;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    currentConfig.onError(errorObj);
+    return null;
+  } finally {
+    if (customConfig) {
+      currentConfig = originalConfig;
+    }
+  }
+}
+function getAffiliateParams() {
+  if (typeof window === "undefined") return null;
+  try {
+    const storage = getStorage();
+    if (!storage) return null;
+    const stored = storage.getItem(currentConfig.storageKey);
+    if (!stored) return null;
+    const data = JSON.parse(stored);
+    if (isExpired(data.timestamp)) {
+      clearAffiliateParams();
+      emitEvent({
+        type: "expire",
+        data,
+        timestamp: Date.now()
+      });
+      return null;
+    }
+    return data;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    currentConfig.onError(errorObj);
+    return null;
+  }
+}
+function clearAffiliateParams() {
+  if (typeof window === "undefined") return;
+  try {
+    const storage = getStorage();
+    if (!storage) return;
+    const existingData = getAffiliateParams();
+    storage.removeItem(currentConfig.storageKey);
+    emitEvent({
+      type: "clear",
+      data: existingData || void 0,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    currentConfig.onError(errorObj);
+  }
+}
+function getAffiliateParamsAsUrlString() {
+  const data = getAffiliateParams();
+  if (!data) return "";
+  const params = new URLSearchParams();
+  const affiliateKeys = [
+    ...ALL_AFFILIATE_PARAMETERS,
+    ...currentConfig.customParams
+  ];
+  for (const key of affiliateKeys) {
+    const value = data[key];
+    if (typeof value === "string" && value) {
+      params.set(key, value);
+    }
+  }
+  return params.toString();
+}
+function appendAffiliateParams(url) {
+  const affiliateParams = getAffiliateParamsAsUrlString();
+  if (!affiliateParams) return url;
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}${affiliateParams}`;
+}
+function hasAffiliateData() {
+  return getAffiliateParams() !== null;
+}
+function getAffiliateSource() {
+  const data = getAffiliateParams();
+  if (!data) return null;
+  if (data.utm_source) return data.utm_source;
+  if (data.referrer) {
+    try {
+      return new URL(data.referrer).hostname;
+    } catch {
+      return data.referrer;
+    }
+  }
+  return null;
+}
+function getConfig() {
+  return { ...currentConfig };
+}
+function resetConfig() {
+  currentConfig = { ...DEFAULT_CONFIG };
+}
+
+// src/affiliate/AffiliateTracker.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AffiliateTracker = ({
+  config,
+  autoCapture = true,
+  children
+}) => {
+  (0, import_react.useEffect)(() => {
+    if (config) {
+      configureAffiliateTracker(config);
+    }
+    if (autoCapture) {
+      captureAffiliateParams();
+    }
+  }, [config, autoCapture]);
+  return children ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children }) : null;
+};
+var AffiliateTracker_default = AffiliateTracker;
+
+// src/affiliate/hooks.ts
+var import_react2 = require("react");
+function useAffiliateTracker(config) {
+  const [affiliateParams, setAffiliateParams] = (0, import_react2.useState)(
+    null
+  );
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const configRef = (0, import_react2.useRef)(config);
+  (0, import_react2.useEffect)(() => {
+    configRef.current = config;
+  }, [config]);
+  (0, import_react2.useEffect)(() => {
+    if (configRef.current) {
+      configureAffiliateTracker({
+        ...configRef.current,
+        onError: (err) => {
+          setError(err);
+          configRef.current?.onError?.(err);
+        }
+      });
+    }
+  }, []);
+  const refreshParams = (0, import_react2.useCallback)(() => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const params = getAffiliateParams();
+      setAffiliateParams(params);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const captureParams = (0, import_react2.useCallback)(() => {
+    setError(null);
+    try {
+      const params = captureAffiliateParams(configRef.current);
+      setAffiliateParams(params);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    }
+  }, []);
+  const clearParams = (0, import_react2.useCallback)(() => {
+    setError(null);
+    try {
+      clearAffiliateParams();
+      setAffiliateParams(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const unsubscribe = addEventListener((event) => {
+      switch (event.type) {
+        case "capture":
+          setAffiliateParams(event.data || null);
+          break;
+        case "clear":
+        case "expire":
+          setAffiliateParams(null);
+          break;
+      }
+    });
+    return unsubscribe;
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    refreshParams();
+  }, [refreshParams]);
+  return {
+    affiliateParams,
+    isLoading,
+    error,
+    captureParams,
+    clearParams,
+    refreshParams
+  };
+}
+function useHasAffiliateData() {
+  const [hasData, setHasData] = (0, import_react2.useState)(false);
+  (0, import_react2.useEffect)(() => {
+    const checkData = () => {
+      setHasData(hasAffiliateData());
+    };
+    checkData();
+    const unsubscribe = addEventListener(() => {
+      checkData();
+    });
+    return unsubscribe;
+  }, []);
+  return hasData;
+}
+function useAffiliateSource() {
+  const [source, setSource] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    const updateSource = () => {
+      setSource(getAffiliateSource());
+    };
+    updateSource();
+    const unsubscribe = addEventListener(() => {
+      updateSource();
+    });
+    return unsubscribe;
+  }, []);
+  return source;
+}
+function useAutoCapture(config) {
+  const hasRun = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
+    if (hasRun.current) return;
+    hasRun.current = true;
+    if (config) {
+      configureAffiliateTracker(config);
+    }
+    captureAffiliateParams();
+  }, [config]);
+}
+function useAffiliateEvents(callback, eventTypes) {
+  const callbackRef = (0, import_react2.useRef)(callback);
+  const eventTypesRef = (0, import_react2.useRef)(eventTypes);
+  (0, import_react2.useEffect)(() => {
+    callbackRef.current = callback;
+    eventTypesRef.current = eventTypes;
+  });
+  (0, import_react2.useEffect)(() => {
+    const unsubscribe = addEventListener((event) => {
+      if (!eventTypesRef.current || eventTypesRef.current.includes(event.type)) {
+        callbackRef.current(event);
+      }
+    });
+    return unsubscribe;
+  }, []);
+}
+
+// src/affiliate/utils.ts
+var AffiliateAnalytics = class {
+  /**
+   * Send affiliate data to Google Analytics 4
+   */
+  static sendToGA4(eventName = "affiliate_attribution", customParams) {
+    const affiliateData = getAffiliateParams();
+    if (!affiliateData || typeof window === "undefined") return;
+    if (typeof window.gtag === "function") {
+      const eventParams = {
+        utm_source: affiliateData.utm_source,
+        utm_medium: affiliateData.utm_medium,
+        utm_campaign: affiliateData.utm_campaign,
+        utm_term: affiliateData.utm_term,
+        utm_content: affiliateData.utm_content,
+        affiliate_id: affiliateData.affiliate_id,
+        attribution_type: affiliateData.attribution,
+        session_id: affiliateData.sessionId,
+        ...customParams
+      };
+      Object.keys(eventParams).forEach((key) => {
+        if (eventParams[key] === void 0) {
+          delete eventParams[key];
+        }
+      });
+      window.gtag("event", eventName, eventParams);
+    }
+  }
+  /**
+   * Send affiliate data to Facebook Pixel
+   */
+  static sendToFacebookPixel(eventName = "AffiliateAttribution", customParams) {
+    const affiliateData = getAffiliateParams();
+    if (!affiliateData || typeof window === "undefined") return;
+    if (typeof window.fbq === "function") {
+      const eventParams = {
+        utm_source: affiliateData.utm_source,
+        utm_medium: affiliateData.utm_medium,
+        utm_campaign: affiliateData.utm_campaign,
+        fbclid: affiliateData.fbclid,
+        ...customParams
+      };
+      Object.keys(eventParams).forEach((key) => {
+        if (eventParams[key] === void 0) {
+          delete eventParams[key];
+        }
+      });
+      window.fbq("trackCustom", eventName, eventParams);
+    }
+  }
+  /**
+   * Send affiliate data to any custom analytics endpoint
+   */
+  static async sendToCustomEndpoint(endpoint, options = {}) {
+    const affiliateData = getAffiliateParams();
+    if (!affiliateData) return;
+    const { method = "POST", headers = {}, customData = {} } = options;
+    try {
+      await fetch(endpoint, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify({
+          ...affiliateData,
+          ...customData
+        })
+      });
+    } catch (error) {
+      console.error("Failed to send affiliate data to custom endpoint:", error);
+    }
+  }
+};
+var AffiliateUrlUtils = class {
+  /**
+   * Create affiliate links with current parameters
+   */
+  static createAffiliateLink(baseUrl, additionalParams) {
+    let url = appendAffiliateParams(baseUrl);
+    if (additionalParams) {
+      const separator = url.includes("?") ? "&" : "?";
+      const params = new URLSearchParams(additionalParams);
+      url = `${url}${separator}${params.toString()}`;
+    }
+    return url;
+  }
+  /**
+   * Extract affiliate parameters from a URL
+   */
+  static extractFromUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      const params = {};
+      const affiliateKeys = ALL_AFFILIATE_PARAMETERS;
+      affiliateKeys.forEach((key) => {
+        const value = urlObj.searchParams.get(key);
+        if (value) {
+          params[key] = value;
+        }
+      });
+      return params;
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Clean URL by removing affiliate parameters
+   */
+  static cleanUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      const affiliateKeys = ALL_AFFILIATE_PARAMETERS;
+      affiliateKeys.forEach((key) => {
+        urlObj.searchParams.delete(key);
+      });
+      return urlObj.toString();
+    } catch {
+      return url;
+    }
+  }
+};
+var AffiliateAttribution = class {
+  /**
+   * Determine the attribution channel based on affiliate data
+   */
+  static getAttributionChannel(data) {
+    const affiliateData = data || getAffiliateParams();
+    if (!affiliateData) return ATTRIBUTION_CHANNELS.DIRECT;
+    if (affiliateData.gclid || affiliateData.utm_medium === "cpc" || affiliateData.utm_medium === "ppc") {
+      return ATTRIBUTION_CHANNELS.PAID_SEARCH;
+    }
+    if (affiliateData.fbclid || affiliateData.ttclid || affiliateData.twclid || affiliateData.li_fat_id || affiliateData.utm_source && SOCIAL_PLATFORMS.some(
+      (platform) => affiliateData.utm_source?.includes(platform)
+    )) {
+      return ATTRIBUTION_CHANNELS.SOCIAL;
+    }
+    if (affiliateData.utm_medium === "email" || affiliateData.utm_source === "email") {
+      return ATTRIBUTION_CHANNELS.EMAIL;
+    }
+    if (affiliateData.affiliate_id || affiliateData.utm_medium === "affiliate" || affiliateData.utm_medium === "referral") {
+      return ATTRIBUTION_CHANNELS.AFFILIATE;
+    }
+    if (affiliateData.utm_medium === "organic" || affiliateData.referrer && this.isSearchEngine(affiliateData.referrer)) {
+      return ATTRIBUTION_CHANNELS.ORGANIC_SEARCH;
+    }
+    if (affiliateData.utm_medium === "display" || affiliateData.utm_medium === "banner") {
+      return ATTRIBUTION_CHANNELS.DISPLAY;
+    }
+    if (affiliateData.referrer) {
+      return ATTRIBUTION_CHANNELS.REFERRAL;
+    }
+    return ATTRIBUTION_CHANNELS.DIRECT;
+  }
+  /**
+   * Check if a URL is from a search engine
+   */
+  static isSearchEngine(url) {
+    const searchEngines = SEARCH_ENGINES;
+    try {
+      const hostname = new URL(url).hostname.toLowerCase();
+      return searchEngines.some((engine) => hostname.includes(engine));
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get attribution score (0-100) based on data quality
+   */
+  static getAttributionScore(data) {
+    const affiliateData = data || getAffiliateParams();
+    if (!affiliateData) return 0;
+    let score = 0;
+    score += 20;
+    if (affiliateData.utm_source) score += 20;
+    if (affiliateData.utm_medium) score += 20;
+    if (affiliateData.utm_campaign) score += 15;
+    if (affiliateData.gclid || affiliateData.fbclid || affiliateData.msclkid)
+      score += 25;
+    if (affiliateData.referrer) score += 10;
+    if (affiliateData.utm_term) score += 5;
+    if (affiliateData.utm_content) score += 5;
+    return Math.min(score, 100);
+  }
+};
+var AffiliateTestUtils = class {
+  /**
+   * Mock affiliate data for testing
+   */
+  static mockAffiliateData(params = {}) {
+    return {
+      utm_source: "test_source",
+      utm_medium: "test_medium",
+      utm_campaign: "test_campaign",
+      timestamp: Date.now(),
+      sessionId: "test-session-id",
+      attribution: "last-touch",
+      url: "https://example.com?utm_source=test_source&utm_medium=test_medium",
+      ...params
+    };
+  }
+  /**
+   * Create test URL with affiliate parameters
+   */
+  static createTestUrl(baseUrl = "https://example.com", params = {}) {
+    const defaultParams = {
+      utm_source: "test_source",
+      utm_medium: "test_medium",
+      utm_campaign: "test_campaign",
+      ...params
+    };
+    const url = new URL(baseUrl);
+    Object.entries(defaultParams).forEach(([key, value]) => {
+      if (value) {
+        url.searchParams.set(key, value);
+      }
+    });
+    return url.toString();
+  }
+  /**
+   * Simulate URL navigation for testing
+   */
+  static simulateNavigation(url) {
+    if (typeof window !== "undefined") {
+      Object.defineProperty(window, "location", {
+        value: {
+          ...window.location,
+          search: new URL(url).search,
+          href: url
+        },
+        writable: true
+      });
+    }
+  }
+};
+var AffiliateValidation = class {
+  /**
+   * Validate affiliate parameter format
+   */
+  static validateParams(params) {
+    const errors = [];
+    if (params.utm_source && params.utm_source.length > 100) {
+      errors.push("utm_source is too long (max 100 characters)");
+    }
+    if (params.utm_medium && params.utm_medium.length > 100) {
+      errors.push("utm_medium is too long (max 100 characters)");
+    }
+    if (params.utm_campaign && params.utm_campaign.length > 100) {
+      errors.push("utm_campaign is too long (max 100 characters)");
+    }
+    if (params.referrer) {
+      try {
+        new URL(params.referrer);
+      } catch {
+        errors.push("referrer is not a valid URL");
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Sanitize affiliate parameters
+   */
+  static sanitizeParams(params) {
+    const sanitized = {};
+    Object.entries(params).forEach(([key, value]) => {
+      if (typeof value === "string" && value.trim()) {
+        sanitized[key] = value.trim().replace(/[<>'"]/g, "").substring(0, 200);
+      }
+    });
+    return sanitized;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AFFILIATE_PARAMETERS,
+  ALL_AFFILIATE_PARAMETERS,
+  ATTRIBUTION_CHANNELS,
+  ATTRIBUTION_MODELS,
+  AffiliateAnalytics,
+  AffiliateAttribution,
+  AffiliateTestUtils,
+  AffiliateTracker,
+  AffiliateUrlUtils,
+  AffiliateValidation,
+  CLICK_ID_PARAMETERS,
+  DEFAULT_CONFIG,
+  EVENT_TYPES,
+  SEARCH_ENGINES,
+  SOCIAL_PLATFORMS,
+  STORAGE_CONFIG,
+  STORAGE_TYPES,
+  UTM_PARAMETERS,
+  addEventListener,
+  appendAffiliateParams,
+  captureAffiliateParams,
+  clearAffiliateParams,
+  configureAffiliateTracker,
+  getAffiliateParams,
+  getAffiliateParamsAsUrlString,
+  getAffiliateSource,
+  getConfig,
+  hasAffiliateData,
+  resetConfig,
+  useAffiliateEvents,
+  useAffiliateSource,
+  useAffiliateTracker,
+  useAutoCapture,
+  useHasAffiliateData
+});
+//# sourceMappingURL=index.js.map