@okeyamy/lua 5.0.4

package/build/es5/utm.js

@@ -0,0 +1,304 @@
+"use strict";
+
+/**
+ * UTM Parameter Extraction & Context Detection
+ * Uses native URLSearchParams API for extracting UTM parameters
+ * and document.referrer/navigator.userAgent for context inference
+ *
+ * No ES6 imports - self-contained IIFE that registers on window.LuaUTM
+ * Can be loaded standalone via <script> tag or bundled by Rollup
+ */
+;
+(function (root) {
+  'use strict';
+
+  // Default timeout for async operations (1 second max as recommended)
+  var UTM_TIMEOUT_MS = 1000;
+
+  // Allowed UTM parameter names
+  var UTM_PARAMS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_content', 'utm_term'];
+
+  // Referrer type patterns
+  var REFERRER_PATTERNS = {
+    google: /google\./i,
+    bing: /bing\./i,
+    yahoo: /yahoo\./i,
+    duckduckgo: /duckduckgo\./i,
+    facebook: /facebook\.com|fb\.com/i,
+    twitter: /twitter\.com|t\.co|x\.com/i,
+    instagram: /instagram\.com/i,
+    linkedin: /linkedin\.com/i,
+    pinterest: /pinterest\./i,
+    tiktok: /tiktok\.com/i,
+    youtube: /youtube\.com|youtu\.be/i,
+    reddit: /reddit\.com/i
+  };
+
+  // Referrer category mapping
+  var REFERRER_CATEGORIES = {
+    search: ['google', 'bing', 'yahoo', 'duckduckgo'],
+    social: ['facebook', 'twitter', 'instagram', 'linkedin', 'pinterest', 'tiktok', 'youtube', 'reddit']
+  };
+
+  /**
+   * Safely extracts UTM parameters from URL using native URLSearchParams API
+   * @param {string} [url] - URL to parse (defaults to window.location.search)
+   * @returns {Object} - Object containing UTM parameters
+   */
+  function extractUTMParams(url) {
+    var result = {};
+    try {
+      var searchString = url || (typeof window !== 'undefined' ? window.location.search : '');
+      if (!searchString) {
+        return result;
+      }
+
+      // Use native URLSearchParams API
+      var params = new URLSearchParams(searchString);
+      UTM_PARAMS.forEach(function (param) {
+        var value = params.get(param);
+        if (value) {
+          // Sanitize: only allow alphanumeric, dashes, underscores
+          result[param] = sanitizeParam(value);
+        }
+      });
+    } catch (e) {
+      // Fallback: return empty object on any error
+      console.warn('[Lua UTM] Error extracting UTM params:', e);
+    }
+    return result;
+  }
+
+  /**
+   * Sanitize parameter value to prevent XSS
+   * Only allows alphanumeric, dashes, underscores, and spaces
+   * @param {string} value - Raw parameter value
+   * @returns {string} - Sanitized value
+   */
+  function sanitizeParam(value) {
+    if (typeof value !== 'string') return '';
+    // Remove any HTML tags and special characters
+    return value.replace(/<[^>]*>/g, '') // Remove HTML tags
+    .replace(/[^\w\s\-_.]/g, '') // Only allow safe characters
+    .substring(0, 100) // Limit length
+    .trim();
+  }
+
+  /**
+   * Detect referrer type from document.referrer
+   * @returns {Object} - { source: string, category: 'search'|'social'|'email'|'direct'|'other' }
+   */
+  function detectReferrer() {
+    var result = {
+      source: 'direct',
+      category: 'direct',
+      url: ''
+    };
+    try {
+      if (typeof document === 'undefined' || !document.referrer) {
+        return result;
+      }
+      result.url = document.referrer;
+
+      // Check for email patterns in referrer
+      if (/mail\.|email\.|newsletter/i.test(document.referrer)) {
+        result.source = 'email';
+        result.category = 'email';
+        return result;
+      }
+
+      // Check against known patterns
+      for (var source in REFERRER_PATTERNS) {
+        if (REFERRER_PATTERNS[source].test(document.referrer)) {
+          result.source = source;
+
+          // Determine category
+          for (var category in REFERRER_CATEGORIES) {
+            if (REFERRER_CATEGORIES[category].indexOf(source) !== -1) {
+              result.category = category;
+              break;
+            }
+          }
+          return result;
+        }
+      }
+
+      // Unknown external referrer
+      result.source = 'external';
+      result.category = 'other';
+    } catch (e) {
+      console.warn('[Lua UTM] Error detecting referrer:', e);
+    }
+    return result;
+  }
+
+  /**
+   * Get user agent info (for device/browser detection)
+   * @returns {Object} - User agent metadata
+   */
+  function getUserAgentInfo() {
+    var result = {
+      raw: '',
+      isMobile: false,
+      isTablet: false,
+      isDesktop: true
+    };
+    try {
+      if (typeof navigator === 'undefined' || !navigator.userAgent) {
+        return result;
+      }
+      result.raw = navigator.userAgent;
+
+      // Mobile detection
+      result.isMobile = /Android|webOS|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+      result.isTablet = /iPad|Android(?!.*Mobile)/i.test(navigator.userAgent);
+      result.isDesktop = !result.isMobile && !result.isTablet;
+    } catch (e) {
+      console.warn('[Lua UTM] Error getting user agent:', e);
+    }
+    return result;
+  }
+
+  /**
+   * Get full personalization context
+   * Combines UTM params, referrer info, and user agent
+   * @param {Object} [options] - Configuration options
+   * @param {string} [options.url] - Custom URL to parse
+   * @returns {Object} - Complete context object
+   */
+  function getContext(options) {
+    options = options || {};
+    var context = {
+      utm: extractUTMParams(options.url),
+      referrer: detectReferrer(),
+      userAgent: getUserAgentInfo(),
+      timestamp: Date.now(),
+      hasUTM: false,
+      primaryIntent: 'unknown'
+    };
+
+    // Determine if we have UTM data
+    context.hasUTM = Object.keys(context.utm).length > 0;
+
+    // Infer primary intent
+    context.primaryIntent = inferIntent(context);
+    return context;
+  }
+
+  /**
+   * Infer user intent from context
+   * Priority: UTM campaign > UTM source > Referrer category
+   * @param {Object} context - Full context object
+   * @returns {string} - Inferred intent key
+   */
+  function inferIntent(context) {
+    // Priority 1: UTM campaign tells us the specific intent
+    if (context.utm.utm_campaign) {
+      var campaign = context.utm.utm_campaign.toLowerCase();
+      if (/sale|discount|offer|promo/i.test(campaign)) return 'price-focused';
+      if (/gaming|game|esport/i.test(campaign)) return 'gaming';
+      if (/work|office|professional|productivity/i.test(campaign)) return 'professional';
+      if (/creative|design|art|studio/i.test(campaign)) return 'creative';
+      if (/brand|story|about/i.test(campaign)) return 'brand-story';
+    }
+
+    // Priority 2: UTM source can indicate intent
+    if (context.utm.utm_source) {
+      var source = context.utm.utm_source.toLowerCase();
+      if (/google|bing|yahoo/i.test(source)) return 'search-optimized';
+      if (/facebook|instagram|tiktok/i.test(source)) return 'social-visual';
+      if (/twitter|x$/i.test(source)) return 'social-brief';
+      if (/email|newsletter/i.test(source)) return 'returning-user';
+      if (/youtube/i.test(source)) return 'video-engaged';
+    }
+
+    // Priority 3: Referrer category
+    if (context.referrer.category === 'search') return 'search-optimized';
+    if (context.referrer.category === 'social') return 'social-visual';
+    if (context.referrer.category === 'email') return 'returning-user';
+
+    // Default
+    return 'default';
+  }
+
+  /**
+   * Get context with timeout fallback
+   * Returns default context if operation takes too long
+   * @param {Object} [options] - Configuration options
+   * @param {number} [options.timeout] - Timeout in ms (default: 1000)
+   * @returns {Promise<Object>} - Context object
+   */
+  function getContextAsync(options) {
+    options = options || {};
+    var timeout = options.timeout || UTM_TIMEOUT_MS;
+    return new Promise(function (resolve) {
+      var timer = setTimeout(function () {
+        // Timeout: return default context
+        resolve({
+          utm: {},
+          referrer: {
+            source: 'direct',
+            category: 'direct',
+            url: ''
+          },
+          userAgent: {
+            raw: '',
+            isMobile: false,
+            isTablet: false,
+            isDesktop: true
+          },
+          timestamp: Date.now(),
+          hasUTM: false,
+          primaryIntent: 'default',
+          timedOut: true
+        });
+      }, timeout);
+      try {
+        var context = getContext(options);
+        clearTimeout(timer);
+        context.timedOut = false;
+        resolve(context);
+      } catch (e) {
+        clearTimeout(timer);
+        resolve({
+          utm: {},
+          referrer: {
+            source: 'direct',
+            category: 'direct',
+            url: ''
+          },
+          userAgent: {
+            raw: '',
+            isMobile: false,
+            isTablet: false,
+            isDesktop: true
+          },
+          timestamp: Date.now(),
+          hasUTM: false,
+          primaryIntent: 'default',
+          error: e.message
+        });
+      }
+    });
+  }
+
+  // --- Public API ---
+  // Register on the global root (window in browser)
+  var LuaUTM = {
+    extractUTMParams: extractUTMParams,
+    sanitizeParam: sanitizeParam,
+    detectReferrer: detectReferrer,
+    getUserAgentInfo: getUserAgentInfo,
+    getContext: getContext,
+    getContextAsync: getContextAsync,
+    inferIntent: inferIntent,
+    UTM_PARAMS: UTM_PARAMS,
+    UTM_TIMEOUT_MS: UTM_TIMEOUT_MS,
+    REFERRER_PATTERNS: REFERRER_PATTERNS,
+    REFERRER_CATEGORIES: REFERRER_CATEGORIES
+  };
+
+  // Expose globally
+  root.LuaUTM = LuaUTM;
+})(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : void 0);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["root","UTM_TIMEOUT_MS","UTM_PARAMS","REFERRER_PATTERNS","google","bing","yahoo","duckduckgo","facebook","twitter","instagram","linkedin","pinterest","tiktok","youtube","reddit","REFERRER_CATEGORIES","search","social","extractUTMParams","url","result","searchString","window","location","params","URLSearchParams","forEach","param","value","get","sanitizeParam","e","console","warn","replace","substring","trim","detectReferrer","source","category","document","referrer","test","indexOf","getUserAgentInfo","raw","isMobile","isTablet","isDesktop","navigator","userAgent","getContext","options","context","utm","timestamp","Date","now","hasUTM","primaryIntent","Object","keys","length","inferIntent","utm_campaign","campaign","toLowerCase","utm_source","getContextAsync","timeout","Promise","resolve","timer","setTimeout","timedOut","clearTimeout","error","message","LuaUTM","global"],"sources":["../../src/utm.js"],"sourcesContent":["\n/**\n * UTM Parameter Extraction & Context Detection\n * Uses native URLSearchParams API for extracting UTM parameters\n * and document.referrer/navigator.userAgent for context inference\n *\n * No ES6 imports - self-contained IIFE that registers on window.LuaUTM\n * Can be loaded standalone via <script> tag or bundled by Rollup\n */\n;(function (root) {\n    'use strict'\n\n    // Default timeout for async operations (1 second max as recommended)\n    var UTM_TIMEOUT_MS = 1000\n\n    // Allowed UTM parameter names\n    var UTM_PARAMS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_content', 'utm_term']\n\n    // Referrer type patterns\n    var REFERRER_PATTERNS = {\n        google: /google\\./i,\n        bing: /bing\\./i,\n        yahoo: /yahoo\\./i,\n        duckduckgo: /duckduckgo\\./i,\n        facebook: /facebook\\.com|fb\\.com/i,\n        twitter: /twitter\\.com|t\\.co|x\\.com/i,\n        instagram: /instagram\\.com/i,\n        linkedin: /linkedin\\.com/i,\n        pinterest: /pinterest\\./i,\n        tiktok: /tiktok\\.com/i,\n        youtube: /youtube\\.com|youtu\\.be/i,\n        reddit: /reddit\\.com/i\n    }\n\n    // Referrer category mapping\n    var REFERRER_CATEGORIES = {\n        search: ['google', 'bing', 'yahoo', 'duckduckgo'],\n        social: ['facebook', 'twitter', 'instagram', 'linkedin', 'pinterest', 'tiktok', 'youtube', 'reddit']\n    }\n\n    /**\n     * Safely extracts UTM parameters from URL using native URLSearchParams API\n     * @param {string} [url] - URL to parse (defaults to window.location.search)\n     * @returns {Object} - Object containing UTM parameters\n     */\n    function extractUTMParams(url) {\n        var result = {}\n\n        try {\n            var searchString = url || (typeof window !== 'undefined' ? window.location.search : '')\n\n            if (!searchString) {\n                return result\n            }\n\n            // Use native URLSearchParams API\n            var params = new URLSearchParams(searchString)\n\n            UTM_PARAMS.forEach(function (param) {\n                var value = params.get(param)\n                if (value) {\n                    // Sanitize: only allow alphanumeric, dashes, underscores\n                    result[param] = sanitizeParam(value)\n                }\n            })\n        } catch (e) {\n            // Fallback: return empty object on any error\n            console.warn('[Lua UTM] Error extracting UTM params:', e)\n        }\n\n        return result\n    }\n\n    /**\n     * Sanitize parameter value to prevent XSS\n     * Only allows alphanumeric, dashes, underscores, and spaces\n     * @param {string} value - Raw parameter value\n     * @returns {string} - Sanitized value\n     */\n    function sanitizeParam(value) {\n        if (typeof value !== 'string') return ''\n        // Remove any HTML tags and special characters\n        return value\n            .replace(/<[^>]*>/g, '') // Remove HTML tags\n            .replace(/[^\\w\\s\\-_.]/g, '') // Only allow safe characters\n            .substring(0, 100) // Limit length\n            .trim()\n    }\n\n    /**\n     * Detect referrer type from document.referrer\n     * @returns {Object} - { source: string, category: 'search'|'social'|'email'|'direct'|'other' }\n     */\n    function detectReferrer() {\n        var result = {\n            source: 'direct',\n            category: 'direct',\n            url: ''\n        }\n\n        try {\n            if (typeof document === 'undefined' || !document.referrer) {\n                return result\n            }\n\n            result.url = document.referrer\n\n            // Check for email patterns in referrer\n            if (/mail\\.|email\\.|newsletter/i.test(document.referrer)) {\n                result.source = 'email'\n                result.category = 'email'\n                return result\n            }\n\n            // Check against known patterns\n            for (var source in REFERRER_PATTERNS) {\n                if (REFERRER_PATTERNS[source].test(document.referrer)) {\n                    result.source = source\n\n                    // Determine category\n                    for (var category in REFERRER_CATEGORIES) {\n                        if (REFERRER_CATEGORIES[category].indexOf(source) !== -1) {\n                            result.category = category\n                            break\n                        }\n                    }\n\n                    return result\n                }\n            }\n\n            // Unknown external referrer\n            result.source = 'external'\n            result.category = 'other'\n\n        } catch (e) {\n            console.warn('[Lua UTM] Error detecting referrer:', e)\n        }\n\n        return result\n    }\n\n    /**\n     * Get user agent info (for device/browser detection)\n     * @returns {Object} - User agent metadata\n     */\n    function getUserAgentInfo() {\n        var result = {\n            raw: '',\n            isMobile: false,\n            isTablet: false,\n            isDesktop: true\n        }\n\n        try {\n            if (typeof navigator === 'undefined' || !navigator.userAgent) {\n                return result\n            }\n\n            result.raw = navigator.userAgent\n\n            // Mobile detection\n            result.isMobile = /Android|webOS|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\n            result.isTablet = /iPad|Android(?!.*Mobile)/i.test(navigator.userAgent)\n            result.isDesktop = !result.isMobile && !result.isTablet\n\n        } catch (e) {\n            console.warn('[Lua UTM] Error getting user agent:', e)\n        }\n\n        return result\n    }\n\n    /**\n     * Get full personalization context\n     * Combines UTM params, referrer info, and user agent\n     * @param {Object} [options] - Configuration options\n     * @param {string} [options.url] - Custom URL to parse\n     * @returns {Object} - Complete context object\n     */\n    function getContext(options) {\n        options = options || {}\n\n        var context = {\n            utm: extractUTMParams(options.url),\n            referrer: detectReferrer(),\n            userAgent: getUserAgentInfo(),\n            timestamp: Date.now(),\n            hasUTM: false,\n            primaryIntent: 'unknown'\n        }\n\n        // Determine if we have UTM data\n        context.hasUTM = Object.keys(context.utm).length > 0\n\n        // Infer primary intent\n        context.primaryIntent = inferIntent(context)\n\n        return context\n    }\n\n    /**\n     * Infer user intent from context\n     * Priority: UTM campaign > UTM source > Referrer category\n     * @param {Object} context - Full context object\n     * @returns {string} - Inferred intent key\n     */\n    function inferIntent(context) {\n        // Priority 1: UTM campaign tells us the specific intent\n        if (context.utm.utm_campaign) {\n            var campaign = context.utm.utm_campaign.toLowerCase()\n\n            if (/sale|discount|offer|promo/i.test(campaign)) return 'price-focused'\n            if (/gaming|game|esport/i.test(campaign)) return 'gaming'\n            if (/work|office|professional|productivity/i.test(campaign)) return 'professional'\n            if (/creative|design|art|studio/i.test(campaign)) return 'creative'\n            if (/brand|story|about/i.test(campaign)) return 'brand-story'\n        }\n\n        // Priority 2: UTM source can indicate intent\n        if (context.utm.utm_source) {\n            var source = context.utm.utm_source.toLowerCase()\n\n            if (/google|bing|yahoo/i.test(source)) return 'search-optimized'\n            if (/facebook|instagram|tiktok/i.test(source)) return 'social-visual'\n            if (/twitter|x$/i.test(source)) return 'social-brief'\n            if (/email|newsletter/i.test(source)) return 'returning-user'\n            if (/youtube/i.test(source)) return 'video-engaged'\n        }\n\n        // Priority 3: Referrer category\n        if (context.referrer.category === 'search') return 'search-optimized'\n        if (context.referrer.category === 'social') return 'social-visual'\n        if (context.referrer.category === 'email') return 'returning-user'\n\n        // Default\n        return 'default'\n    }\n\n    /**\n     * Get context with timeout fallback\n     * Returns default context if operation takes too long\n     * @param {Object} [options] - Configuration options\n     * @param {number} [options.timeout] - Timeout in ms (default: 1000)\n     * @returns {Promise<Object>} - Context object\n     */\n    function getContextAsync(options) {\n        options = options || {}\n        var timeout = options.timeout || UTM_TIMEOUT_MS\n\n        return new Promise(function (resolve) {\n            var timer = setTimeout(function () {\n                // Timeout: return default context\n                resolve({\n                    utm: {},\n                    referrer: { source: 'direct', category: 'direct', url: '' },\n                    userAgent: { raw: '', isMobile: false, isTablet: false, isDesktop: true },\n                    timestamp: Date.now(),\n                    hasUTM: false,\n                    primaryIntent: 'default',\n                    timedOut: true\n                })\n            }, timeout)\n\n            try {\n                var context = getContext(options)\n                clearTimeout(timer)\n                context.timedOut = false\n                resolve(context)\n            } catch (e) {\n                clearTimeout(timer)\n                resolve({\n                    utm: {},\n                    referrer: { source: 'direct', category: 'direct', url: '' },\n                    userAgent: { raw: '', isMobile: false, isTablet: false, isDesktop: true },\n                    timestamp: Date.now(),\n                    hasUTM: false,\n                    primaryIntent: 'default',\n                    error: e.message\n                })\n            }\n        })\n    }\n\n    // --- Public API ---\n    // Register on the global root (window in browser)\n    var LuaUTM = {\n        extractUTMParams: extractUTMParams,\n        sanitizeParam: sanitizeParam,\n        detectReferrer: detectReferrer,\n        getUserAgentInfo: getUserAgentInfo,\n        getContext: getContext,\n        getContextAsync: getContextAsync,\n        inferIntent: inferIntent,\n        UTM_PARAMS: UTM_PARAMS,\n        UTM_TIMEOUT_MS: UTM_TIMEOUT_MS,\n        REFERRER_PATTERNS: REFERRER_PATTERNS,\n        REFERRER_CATEGORIES: REFERRER_CATEGORIES\n    }\n\n    // Expose globally\n    root.LuaUTM = LuaUTM\n\n})(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : this)\n"],"mappings":"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","ignoreList":[]}