@okeyamy/lua 5.0.4

package/build/es5/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lua = _interopRequireDefault(require("./lua"));
+var _browserCookie = _interopRequireDefault(require("./stores/browser-cookie"));
+var _local = _interopRequireDefault(require("./stores/local"));
+var _memory = _interopRequireDefault(require("./stores/memory"));
+require("./utm");
+require("./personalization");
+// this is the build for webpack and UMD builds
+// try not to use this!
+// UTM and Personalization modules (IIFE pattern - self-register on window)
+// These files populate window.LuaUTM and window.LuaPersonalize on execution
+var _default = exports.default = _lua.default;
+var stores = {
+  browserCookie: (0, _browserCookie.default)(),
+  local: (0, _local.default)(),
+  memory: (0, _memory.default)()
+};
+window.Lua = _lua.default;
+_lua.default.stores = stores;
+
+// Attach UTM and Personalization from window globals (populated by IIFEs)
+_lua.default.utm = window.LuaUTM || {};
+_lua.default.personalization = window.LuaPersonalize || {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/es5/lua.js

@@ -0,0 +1,366 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _utils = require("./utils");
+// UTM functions are now on window.LuaUTM (IIFE pattern, no import needed)
+// utm.js must be loaded before lua.js to populate window.LuaUTM
+var Lua = exports.default = /*#__PURE__*/function () {
+  function Lua() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2.default)(this, Lua);
+    Object.assign(this, {
+      storageKey: 'ab-tests',
+      root: typeof document !== 'undefined' ? document.body : null
+    }, options);
+    (0, _utils.validateStore)(this.store);
+    this.previousAssignments = {};
+    try {
+      // assert that the data is a JSON string
+      // that represents a JSON object
+      // saw a bug where it was, for some reason, stored as `null`
+      var data = this.store.get(this.storageKey);
+      if (typeof data === 'string' && data[0] === '{') {
+        this.previousAssignments = JSON.parse(data);
+      }
+    } catch (_) {
+      // ignore
+    }
+    this.userAssignments = {};
+    this.persistedUserAssignments = {};
+    this.providedTests = [];
+  }
+  return (0, _createClass2.default)(Lua, [{
+    key: "define",
+    value: function define(tests) {
+      var _this = this;
+      var normalizedData = tests;
+      if (!Array.isArray(tests)) normalizedData = [tests];
+      normalizedData.forEach(function (test) {
+        if (!test.name) throw new Error('Tests must have a name');
+        if (!test.buckets) throw new Error('Tests must have buckets');
+        if (!Object.keys(test.buckets)) throw new Error('Tests must have buckets');
+        _this.providedTests.push(test);
+      });
+    }
+  }, {
+    key: "definitions",
+    value: function definitions() {
+      return this.providedTests;
+    }
+  }, {
+    key: "removeClasses",
+    value: function removeClasses(testName, exceptClassName) {
+      try {
+        var root = this.root;
+        if (!root) return;
+
+        // classList does not support returning all classes
+        var currentClassNames = root.className.split(/\s+/g).map(function (x) {
+          return x.trim();
+        }).filter(Boolean);
+        currentClassNames.filter(function (x) {
+          return x.indexOf("".concat(testName, "--")) === 0;
+        }).filter(function (className) {
+          return className !== exceptClassName;
+        }).forEach(function (className) {
+          return root.classList.remove(className);
+        });
+      } catch (_) {
+        // Ignore
+      }
+    }
+  }, {
+    key: "applyClasses",
+    value: function applyClasses() {
+      var _this2 = this;
+      try {
+        var userAssignments = this.userAssignments,
+          root = this.root;
+        if (!root) return;
+        Object.keys(userAssignments).forEach(function (testName) {
+          var bucket = userAssignments[testName];
+          var className = bucket ? "".concat(testName, "--").concat(bucket) : null;
+          // remove all classes related to this bucket
+          _this2.removeClasses(testName, className);
+
+          // only assign a class is the test is assigned to a bucket
+          // this removes then adds a class, which is not ideal but is clean
+          if (className) root.classList.add(className);
+        });
+      } catch (_) {
+        // Ignore
+      }
+    }
+  }, {
+    key: "assignAll",
+    value: function assignAll() {
+      var previousAssignments = this.previousAssignments,
+        userAssignments = this.userAssignments,
+        persistedUserAssignments = this.persistedUserAssignments;
+      this.providedTests.forEach(function (test) {
+        // winners take precedence
+        {
+          var winner = Object.keys(test.buckets).filter(function (name) {
+            return test.buckets[name].winner;
+          })[0];
+          if (winner) {
+            userAssignments[test.name] = winner;
+            return;
+          }
+        }
+
+        // already assigned, probably because someone
+        // called `.assignAll()` twice.
+        if (userAssignments[test.name]) return;
+        {
+          // previously assigned, so we continue to persist it
+          var bucket = previousAssignments[test.name];
+          if (bucket && test.buckets[bucket]) {
+            var assignment = previousAssignments[test.name];
+            persistedUserAssignments[test.name] = assignment;
+            userAssignments[test.name] = assignment;
+            test.active = true;
+            return;
+          }
+        }
+
+        // inactive tests should be set to default
+        if (test.active === false) {
+          userAssignments[test.name] = (0, _utils.getDefaultBucket)(test.buckets);
+          return;
+        }
+
+        // randomly assign
+        {
+          var _assignment = (0, _utils.getRandomAssignment)(test);
+          persistedUserAssignments[test.name] = _assignment;
+          userAssignments[test.name] = _assignment;
+        }
+      });
+      this.persist();
+      this.applyClasses();
+    }
+  }, {
+    key: "assign",
+    value: function assign(testName, bucketName) {
+      if (!testName) return this.assignAll();
+      var test = this.providedTests.filter(function (x) {
+        return x.name === testName;
+      })[0];
+      if (bucketName === null || !test) {
+        delete this.userAssignments[testName];
+        delete this.persistedUserAssignments[testName];
+        this.persist();
+        this.removeClasses(testName);
+        return;
+      }
+      var assignment = bucketName || (0, _utils.getRandomAssignment)(test);
+      this.userAssignments[testName] = assignment;
+      this.persistedUserAssignments[testName] = assignment;
+      test.active = true;
+      this.persist();
+      this.applyClasses();
+    }
+  }, {
+    key: "extendAssignments",
+    value: function extendAssignments(assignments) {
+      return assignments;
+    }
+  }, {
+    key: "assignments",
+    value: function assignments() {
+      return this.extendAssignments(this.userAssignments);
+    }
+  }, {
+    key: "persist",
+    value: function persist() {
+      this.store.set(this.storageKey, JSON.stringify(this.persistedUserAssignments));
+    }
+
+    /**
+     * Get UTM context for the current page
+     * Uses window.LuaUTM global (populated by utm.js IIFE)
+     * @returns {Object} - Context object with UTM params, referrer, user agent, and intent
+     */
+  }, {
+    key: "getUTMContext",
+    value: function getUTMContext() {
+      try {
+        var _root = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};
+        if (_root.LuaUTM && typeof _root.LuaUTM.getContext === 'function') {
+          return _root.LuaUTM.getContext();
+        }
+        return {
+          utm: {},
+          referrer: {},
+          userAgent: {},
+          primaryIntent: 'default',
+          hasUTM: false
+        };
+      } catch (_) {
+        return {
+          utm: {},
+          referrer: {},
+          userAgent: {},
+          primaryIntent: 'default',
+          hasUTM: false
+        };
+      }
+    }
+
+    /**
+     * Get bucket based on UTM context
+     * Maps UTM intent to test buckets
+     * @param {Object} test - Test definition with buckets
+     * @param {Object} context - UTM context
+     * @returns {string|null} - Bucket name or null if no match
+     */
+  }, {
+    key: "getUTMBasedBucket",
+    value: function getUTMBasedBucket(test, context) {
+      if (!context || !context.hasUTM) return null;
+
+      // Check if test has UTM rules defined
+      var utmRules = test.utmRules || {};
+
+      // Priority 1: Match by utm_campaign
+      if (context.utm.utm_campaign) {
+        var campaignRule = utmRules[context.utm.utm_campaign];
+        if (campaignRule && test.buckets[campaignRule]) {
+          return campaignRule;
+        }
+      }
+
+      // Priority 2: Match by utm_source
+      if (context.utm.utm_source) {
+        var sourceRule = utmRules[context.utm.utm_source];
+        if (sourceRule && test.buckets[sourceRule]) {
+          return sourceRule;
+        }
+      }
+
+      // Priority 3: Match by inferred intent
+      var intent = context.primaryIntent;
+      if (intent && test.buckets[intent]) {
+        return intent;
+      }
+
+      // Priority 4: Check for intent-mapped buckets
+      var intentMapping = test.intentMapping || {};
+      if (intent && intentMapping[intent] && test.buckets[intentMapping[intent]]) {
+        return intentMapping[intent];
+      }
+      return null;
+    }
+
+    /**
+     * Assign with UTM-aware personalization
+     * Falls back to random A/B if no UTM match
+     * @param {string} [testName] - Optional specific test name
+     * @param {Object} [options] - Options including forceUTM, context
+     * @returns {Object} - { assignment, source: 'utm'|'random'|'persisted' }
+     */
+  }, {
+    key: "assignWithUTM",
+    value: function assignWithUTM(testName) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var context = options.context || this.getUTMContext();
+
+      // If no test name, assign all with UTM awareness
+      if (!testName) {
+        return this.assignAllWithUTM(context);
+      }
+      var test = this.providedTests.filter(function (x) {
+        return x.name === testName;
+      })[0];
+      if (!test) {
+        return {
+          assignment: null,
+          source: 'none'
+        };
+      }
+
+      // Check for winner first (takes precedence)
+      var winner = Object.keys(test.buckets).filter(function (name) {
+        return test.buckets[name].winner;
+      })[0];
+      if (winner) {
+        this.userAssignments[testName] = winner;
+        this.persist();
+        this.applyClasses();
+        return {
+          assignment: winner,
+          source: 'winner'
+        };
+      }
+
+      // Check previous assignment
+      var previousBucket = this.previousAssignments[testName];
+      if (previousBucket && test.buckets[previousBucket]) {
+        this.userAssignments[testName] = previousBucket;
+        this.persistedUserAssignments[testName] = previousBucket;
+        test.active = true;
+        this.persist();
+        this.applyClasses();
+        return {
+          assignment: previousBucket,
+          source: 'persisted'
+        };
+      }
+
+      // Try UTM-based assignment
+      var utmBucket = this.getUTMBasedBucket(test, context);
+      if (utmBucket) {
+        this.userAssignments[testName] = utmBucket;
+        this.persistedUserAssignments[testName] = utmBucket;
+        test.active = true;
+        this.persist();
+        this.applyClasses();
+        return {
+          assignment: utmBucket,
+          source: 'utm',
+          intent: context.primaryIntent
+        };
+      }
+
+      // Fallback to random assignment
+      var assignment = (0, _utils.getRandomAssignment)(test);
+      this.userAssignments[testName] = assignment;
+      this.persistedUserAssignments[testName] = assignment;
+      test.active = true;
+      this.persist();
+      this.applyClasses();
+      return {
+        assignment: assignment,
+        source: 'random'
+      };
+    }
+
+    /**
+     * Assign all tests with UTM awareness
+     * @param {Object} context - UTM context
+     * @returns {Object} - Map of test names to assignment results
+     */
+  }, {
+    key: "assignAllWithUTM",
+    value: function assignAllWithUTM(context) {
+      var _this3 = this;
+      context = context || this.getUTMContext();
+      var results = {};
+      this.providedTests.forEach(function (test) {
+        var result = _this3.assignWithUTM(test.name, {
+          context: context
+        });
+        results[test.name] = result;
+      });
+      return results;
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_utils","require","Lua","exports","default","options","arguments","length","undefined","_classCallCheck2","Object","assign","storageKey","root","document","body","validateStore","store","previousAssignments","data","get","JSON","parse","_","userAssignments","persistedUserAssignments","providedTests","_createClass2","key","value","define","tests","_this","normalizedData","Array","isArray","forEach","test","name","Error","buckets","keys","push","definitions","removeClasses","testName","exceptClassName","currentClassNames","className","split","map","x","trim","filter","Boolean","indexOf","concat","classList","remove","applyClasses","_this2","bucket","add","assignAll","winner","assignment","active","getDefaultBucket","getRandomAssignment","persist","bucketName","extendAssignments","assignments","set","stringify","getUTMContext","_root","window","global","LuaUTM","getContext","utm","referrer","userAgent","primaryIntent","hasUTM","getUTMBasedBucket","context","utmRules","utm_campaign","campaignRule","utm_source","sourceRule","intent","intentMapping","assignWithUTM","assignAllWithUTM","source","previousBucket","utmBucket","_this3","results","result"],"sources":["../../src/lua.js"],"sourcesContent":["\nimport {\n  getRandomAssignment,\n  getDefaultBucket,\n  validateStore,\n} from './utils'\n\n// UTM functions are now on window.LuaUTM (IIFE pattern, no import needed)\n// utm.js must be loaded before lua.js to populate window.LuaUTM\n\nexport default class Lua {\n  constructor(options = {}) {\n    Object.assign(this, {\n      storageKey: 'ab-tests',\n      root: typeof document !== 'undefined' ? document.body : null,\n    }, options)\n\n    validateStore(this.store)\n\n    this.previousAssignments = {}\n    try {\n      // assert that the data is a JSON string\n      // that represents a JSON object\n      // saw a bug where it was, for some reason, stored as `null`\n      const data = this.store.get(this.storageKey)\n      if (typeof data === 'string' && data[0] === '{') {\n        this.previousAssignments = JSON.parse(data)\n      }\n    } catch (_) {\n      // ignore\n    }\n\n    this.userAssignments = {}\n    this.persistedUserAssignments = {}\n    this.providedTests = []\n  }\n\n  define(tests) {\n    let normalizedData = tests\n    if (!Array.isArray(tests)) normalizedData = [tests]\n\n    normalizedData.forEach((test) => {\n      if (!test.name) throw new Error('Tests must have a name')\n      if (!test.buckets) throw new Error('Tests must have buckets')\n      if (!Object.keys(test.buckets)) throw new Error('Tests must have buckets')\n      this.providedTests.push(test)\n    })\n  }\n\n  definitions() {\n    return this.providedTests\n  }\n\n  removeClasses(testName, exceptClassName) {\n    try {\n      const { root } = this\n      if (!root) return\n\n      // classList does not support returning all classes\n      const currentClassNames = root.className.split(/\\s+/g)\n        .map(x => x.trim())\n        .filter(Boolean)\n\n      currentClassNames\n        .filter(x => x.indexOf(`${testName}--`) === 0)\n        .filter(className => className !== exceptClassName)\n        .forEach(className => root.classList.remove(className))\n    } catch (_) {\n      // Ignore\n    }\n  }\n\n  applyClasses() {\n    try {\n      const { userAssignments, root } = this\n      if (!root) return\n\n      Object.keys(userAssignments).forEach((testName) => {\n        const bucket = userAssignments[testName]\n\n        const className = bucket ? `${testName}--${bucket}` : null\n        // remove all classes related to this bucket\n        this.removeClasses(testName, className)\n\n        // only assign a class is the test is assigned to a bucket\n        // this removes then adds a class, which is not ideal but is clean\n        if (className) root.classList.add(className)\n      })\n    } catch (_) {\n      // Ignore\n    }\n  }\n\n  assignAll() {\n    const {\n      previousAssignments,\n      userAssignments,\n      persistedUserAssignments,\n    } = this\n\n    this.providedTests.forEach((test) => {\n      // winners take precedence\n      {\n        const winner = Object.keys(test.buckets)\n          .filter(name => test.buckets[name].winner)[0]\n        if (winner) {\n          userAssignments[test.name] = winner\n          return\n        }\n      }\n\n      // already assigned, probably because someone\n      // called `.assignAll()` twice.\n      if (userAssignments[test.name]) return\n\n      {\n        // previously assigned, so we continue to persist it\n        const bucket = previousAssignments[test.name]\n        if (bucket && test.buckets[bucket]) {\n          const assignment = previousAssignments[test.name]\n          persistedUserAssignments[test.name] = assignment\n          userAssignments[test.name] = assignment\n          test.active = true\n          return\n        }\n      }\n\n      // inactive tests should be set to default\n      if (test.active === false) {\n        userAssignments[test.name] = getDefaultBucket(test.buckets)\n        return\n      }\n\n      // randomly assign\n      {\n        const assignment = getRandomAssignment(test)\n        persistedUserAssignments[test.name] = assignment\n        userAssignments[test.name] = assignment\n      }\n    })\n\n    this.persist()\n    this.applyClasses()\n  }\n\n  assign(testName, bucketName) {\n    if (!testName) return this.assignAll()\n\n    const test = this.providedTests.filter(x => x.name === testName)[0]\n    if (bucketName === null || !test) {\n      delete this.userAssignments[testName]\n      delete this.persistedUserAssignments[testName]\n      this.persist()\n      this.removeClasses(testName)\n      return\n    }\n\n    const assignment = bucketName || getRandomAssignment(test)\n    this.userAssignments[testName] = assignment\n    this.persistedUserAssignments[testName] = assignment\n    test.active = true\n\n    this.persist()\n    this.applyClasses()\n  }\n\n  extendAssignments(assignments) {\n    return assignments\n  }\n\n  assignments() {\n    return this.extendAssignments(this.userAssignments)\n  }\n\n  persist() {\n    this.store.set(this.storageKey, JSON.stringify(this.persistedUserAssignments))\n  }\n\n  /**\n   * Get UTM context for the current page\n   * Uses window.LuaUTM global (populated by utm.js IIFE)\n   * @returns {Object} - Context object with UTM params, referrer, user agent, and intent\n   */\n  getUTMContext() {\n    try {\n      var _root = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {}\n      if (_root.LuaUTM && typeof _root.LuaUTM.getContext === 'function') {\n        return _root.LuaUTM.getContext()\n      }\n      return { utm: {}, referrer: {}, userAgent: {}, primaryIntent: 'default', hasUTM: false }\n    } catch (_) {\n      return { utm: {}, referrer: {}, userAgent: {}, primaryIntent: 'default', hasUTM: false }\n    }\n  }\n\n  /**\n   * Get bucket based on UTM context\n   * Maps UTM intent to test buckets\n   * @param {Object} test - Test definition with buckets\n   * @param {Object} context - UTM context\n   * @returns {string|null} - Bucket name or null if no match\n   */\n  getUTMBasedBucket(test, context) {\n    if (!context || !context.hasUTM) return null\n\n    // Check if test has UTM rules defined\n    const utmRules = test.utmRules || {}\n\n    // Priority 1: Match by utm_campaign\n    if (context.utm.utm_campaign) {\n      const campaignRule = utmRules[context.utm.utm_campaign]\n      if (campaignRule && test.buckets[campaignRule]) {\n        return campaignRule\n      }\n    }\n\n    // Priority 2: Match by utm_source\n    if (context.utm.utm_source) {\n      const sourceRule = utmRules[context.utm.utm_source]\n      if (sourceRule && test.buckets[sourceRule]) {\n        return sourceRule\n      }\n    }\n\n    // Priority 3: Match by inferred intent\n    const intent = context.primaryIntent\n    if (intent && test.buckets[intent]) {\n      return intent\n    }\n\n    // Priority 4: Check for intent-mapped buckets\n    const intentMapping = test.intentMapping || {}\n    if (intent && intentMapping[intent] && test.buckets[intentMapping[intent]]) {\n      return intentMapping[intent]\n    }\n\n    return null\n  }\n\n  /**\n   * Assign with UTM-aware personalization\n   * Falls back to random A/B if no UTM match\n   * @param {string} [testName] - Optional specific test name\n   * @param {Object} [options] - Options including forceUTM, context\n   * @returns {Object} - { assignment, source: 'utm'|'random'|'persisted' }\n   */\n  assignWithUTM(testName, options = {}) {\n    const context = options.context || this.getUTMContext()\n\n    // If no test name, assign all with UTM awareness\n    if (!testName) {\n      return this.assignAllWithUTM(context)\n    }\n\n    const test = this.providedTests.filter(x => x.name === testName)[0]\n    if (!test) {\n      return { assignment: null, source: 'none' }\n    }\n\n    // Check for winner first (takes precedence)\n    const winner = Object.keys(test.buckets).filter(name => test.buckets[name].winner)[0]\n    if (winner) {\n      this.userAssignments[testName] = winner\n      this.persist()\n      this.applyClasses()\n      return { assignment: winner, source: 'winner' }\n    }\n\n    // Check previous assignment\n    const previousBucket = this.previousAssignments[testName]\n    if (previousBucket && test.buckets[previousBucket]) {\n      this.userAssignments[testName] = previousBucket\n      this.persistedUserAssignments[testName] = previousBucket\n      test.active = true\n      this.persist()\n      this.applyClasses()\n      return { assignment: previousBucket, source: 'persisted' }\n    }\n\n    // Try UTM-based assignment\n    const utmBucket = this.getUTMBasedBucket(test, context)\n    if (utmBucket) {\n      this.userAssignments[testName] = utmBucket\n      this.persistedUserAssignments[testName] = utmBucket\n      test.active = true\n      this.persist()\n      this.applyClasses()\n      return { assignment: utmBucket, source: 'utm', intent: context.primaryIntent }\n    }\n\n    // Fallback to random assignment\n    const assignment = getRandomAssignment(test)\n    this.userAssignments[testName] = assignment\n    this.persistedUserAssignments[testName] = assignment\n    test.active = true\n    this.persist()\n    this.applyClasses()\n    return { assignment, source: 'random' }\n  }\n\n  /**\n   * Assign all tests with UTM awareness\n   * @param {Object} context - UTM context\n   * @returns {Object} - Map of test names to assignment results\n   */\n  assignAllWithUTM(context) {\n    context = context || this.getUTMContext()\n    const results = {}\n\n    this.providedTests.forEach((test) => {\n      const result = this.assignWithUTM(test.name, { context })\n      results[test.name] = result\n    })\n\n    return results\n  }\n}\n\n"],"mappings":"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","ignoreList":[]}