rudder-sdk-js 1.2.10 → 1.2.15

package/index.d.ts

@@ -39,6 +39,8 @@ declare module "rudder-sdk-js" {
     queueOptions?: queueOptions;
     // Defaults to true
     loadIntegration?: boolean;
+    // Defaults to false
+    secureCookie?: boolean;
     logLevel?: string;
     getSourceConfig?: () =>
       | string

package/index.js

@@ -9,14 +9,9 @@
 
     if (Object.getOwnPropertySymbols) {
       var symbols = Object.getOwnPropertySymbols(object);
-
-      if (enumerableOnly) {
-        symbols = symbols.filter(function (sym) {
-          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-        });
-      }
-
-      keys.push.apply(keys, symbols);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
     }
 
     return keys;
@@ -24,19 +19,12 @@
 
   function _objectSpread2(target) {
     for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i] != null ? arguments[i] : {};
-
-      if (i % 2) {
-        ownKeys(Object(source), true).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
-        });
-      } else if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-      } else {
-        ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-      }
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
     }
 
     return target;
@@ -45,17 +33,11 @@
   function _typeof(obj) {
     "@babel/helpers - typeof";
 
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function (obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function (obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
   }
 
   function _classCallCheck(instance, Constructor) {
@@ -77,6 +59,9 @@
   function _createClass(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
     return Constructor;
   }
 
@@ -5570,7 +5555,7 @@
     PRODUCT_REVIEWED: "Product Reviewed"
   }; // Enumeration for integrations supported
 
-  var CONFIG_URL = "https://api.rudderlabs.com/sourceConfig/?p=npm&v=1.2.10";
+  var CONFIG_URL = "https://api.rudderlabs.com/sourceConfig/?p=npm&v=1.2.15";
   var MAX_WAIT_FOR_INTEGRATION_LOAD = 10000;
   var INTEGRATION_LOAD_CHECK_INTERVAL = 1000;
   /* module.exports = {
@@ -11522,6 +11507,10 @@
       if (Store.enabled) {
         this.storage = Store;
       }
+
+      if (!this.storage) {
+        throw Error("Could not initialize the SDK :: no storage is available");
+      }
     }
 
     _createClass(Storage, [{
@@ -23724,7 +23713,7 @@
     return Appcues;
   }();
 
-  var BingAds = function BingAds(config) {
+  var BingAds = /*#__PURE__*/_createClass(function BingAds(config) {
     var _this = this;
 
     _classCallCheck(this, BingAds);
@@ -23804,7 +23793,7 @@
 
     this.tagID = config.tagID;
     this.name = "BINGADS";
-  };
+  });
 
   /*
   E-commerce support required for logPurchase support & other e-commerce events as track with productId changed
@@ -26982,8 +26971,13 @@
       }
     }, {
       key: "page",
-      value: function page() {
-        window.fbq("track", "PageView");
+      value: function page(rudderElement) {
+        var _rudderElement$messag = rudderElement.message,
+            properties = _rudderElement$messag.properties,
+            messageId = _rudderElement$messag.messageId;
+        window.fbq("track", "PageView", properties, {
+          eventID: messageId
+        });
       }
     }, {
       key: "identify",
@@ -26999,10 +26993,10 @@
         var _this = this;
 
         var self = this;
-        var _rudderElement$messag = rudderElement.message,
-            event = _rudderElement$messag.event,
-            properties = _rudderElement$messag.properties,
-            messageId = _rudderElement$messag.messageId;
+        var _rudderElement$messag2 = rudderElement.message,
+            event = _rudderElement$messag2.event,
+            properties = _rudderElement$messag2.properties,
+            messageId = _rudderElement$messag2.messageId;
         var revValue;
         var currVal;
 
@@ -27313,25 +27307,25 @@
       }
       /**
        * Get the Facebook Content Type
-       * 
+       *
        * Can be `product`, `destination`, `flight` or `hotel`.
-       * 
+       *
        * This can be overridden within the message
        * `options.integrations.FACEBOOK_PIXEL.contentType`, or alternatively you can
        * set the "Map Categories to Facebook Content Types" setting within
        * RudderStack config and then set the corresponding commerce category in
        * `track()` properties.
-       * 
+       *
        * https://www.facebook.com/business/help/606577526529702?id=1205376682832142
        */
 
     }, {
       key: "getContentType",
       value: function getContentType(rudderElement, defaultValue) {
-        var _rudderElement$messag2, _rudderElement$messag3;
+        var _rudderElement$messag3, _rudderElement$messag4;
 
         // Get the message-specific override if it exists in the options parameter of `track()`
-        var contentTypeMessageOverride = (_rudderElement$messag2 = rudderElement.message.integrations) === null || _rudderElement$messag2 === void 0 ? void 0 : (_rudderElement$messag3 = _rudderElement$messag2.FACEBOOK_PIXEL) === null || _rudderElement$messag3 === void 0 ? void 0 : _rudderElement$messag3.contentType;
+        var contentTypeMessageOverride = (_rudderElement$messag3 = rudderElement.message.integrations) === null || _rudderElement$messag3 === void 0 ? void 0 : (_rudderElement$messag4 = _rudderElement$messag3.FACEBOOK_PIXEL) === null || _rudderElement$messag4 === void 0 ? void 0 : _rudderElement$messag4.contentType;
         if (contentTypeMessageOverride) return [contentTypeMessageOverride]; // Otherwise check if there is a replacement set for all Facebook Pixel
         // track calls of this category
 
@@ -29115,6 +29109,7 @@
       this.pageLoadConversions = config.pageLoadConversions;
       this.clickEventConversions = config.clickEventConversions;
       this.defaultPageConversion = config.defaultPageConversion;
+      this.dynamicRemarketing = config.dynamicRemarketing;
       this.sendPageView = config.sendPageView || true;
       this.conversionLinker = config.conversionLinker || true;
       this.disableAdPersonalization = config.disableAdPersonalization || false;
@@ -29159,44 +29154,85 @@
       }
     }, {
       key: "identify",
-      value: function identify(rudderElement) {
+      value: function identify() {
         logger.debug("[GoogleAds] identify:: method not supported");
       } // https://developers.google.com/gtagjs/reference/event
 
     }, {
       key: "track",
       value: function track(rudderElement) {
-        logger.debug("in GoogleAdsAnalyticsManager track");
-        var conversionData = this.getConversionData(this.clickEventConversions, rudderElement.message.event);
+        logger.debug("in GoogleAdsAnalyticsManager track"); // Dynamic remarketing disabled
 
-        if (conversionData.conversionLabel) {
-          var conversionLabel = conversionData.conversionLabel;
-          var eventName = conversionData.eventName;
-          var sendToValue = "".concat(this.conversionId, "/").concat(conversionLabel);
-          var properties = {};
+        if (!this.dynamicRemarketing) {
+          var conversionData = this.getConversionData(this.clickEventConversions, rudderElement.message.event);
+
+          if (conversionData.conversionLabel) {
+            var conversionLabel = conversionData.conversionLabel;
+            var eventName = conversionData.eventName;
+            var sendToValue = "".concat(this.conversionId, "/").concat(conversionLabel);
+            var properties = {};
+
+            if (rudderElement.message.properties) {
+              properties.value = rudderElement.message.properties.revenue;
+              properties.currency = rudderElement.message.properties.currency;
+              properties.transaction_id = rudderElement.message.properties.order_id;
+            }
+
+            properties.send_to = sendToValue;
+            properties = removeUndefinedAndNullValues(properties);
+            window.gtag("event", eventName, properties);
+          }
+        } else {
+          var event = rudderElement.message.event;
+
+          if (!event) {
+            logger.error("Event name not present");
+            return;
+          }
+
+          var payload = {};
+          var _sendToValue = this.conversionId;
 
           if (rudderElement.message.properties) {
-            properties.value = rudderElement.message.properties.revenue;
-            properties.currency = rudderElement.message.properties.currency;
-            properties.transaction_id = rudderElement.message.properties.order_id;
+            payload = rudderElement.message.properties;
           }
 
-          properties.send_to = sendToValue;
-          window.gtag("event", eventName, properties);
+          payload.send_to = _sendToValue;
+          window.gtag("event", event, payload);
         }
       }
     }, {
       key: "page",
       value: function page(rudderElement) {
-        logger.debug("in GoogleAdsAnalyticsManager page");
-        var conversionData = this.getConversionData(this.pageLoadConversions, rudderElement.message.name);
-
-        if (conversionData.conversionLabel) {
-          var conversionLabel = conversionData.conversionLabel;
-          var eventName = conversionData.eventName;
-          window.gtag("event", eventName, {
-            send_to: "".concat(this.conversionId, "/").concat(conversionLabel)
-          });
+        logger.debug("in GoogleAdsAnalyticsManager page"); // Dynamic re-marketing is disabled
+
+        if (!this.dynamicRemarketing) {
+          var conversionData = this.getConversionData(this.pageLoadConversions, rudderElement.message.name);
+
+          if (conversionData.conversionLabel) {
+            var conversionLabel = conversionData.conversionLabel;
+            var eventName = conversionData.eventName;
+            window.gtag("event", eventName, {
+              send_to: "".concat(this.conversionId, "/").concat(conversionLabel)
+            });
+          }
+        } else {
+          var event = rudderElement.message.name;
+
+          if (!event) {
+            logger.error("Event name not present");
+            return;
+          }
+
+          var payload = {};
+          var sendToValue = this.conversionId;
+
+          if (rudderElement.message.properties) {
+            payload = rudderElement.message.properties;
+          }
+
+          payload.send_to = sendToValue;
+          window.gtag("event", event, payload);
         }
       }
     }, {
@@ -29796,7 +29832,10 @@
         var properties = message.properties ? Object.keys(message.properties) : null;
         properties.forEach(function (property) {
           var value = message.properties[property];
-          rawPayload[property] = value;
+
+          if (value && _typeof(value) !== "object" && !Array.isArray(value)) {
+            rawPayload[property] = value;
+          }
         });
 
         if (message.event) {
@@ -30454,6 +30493,102 @@
     return Kissmetrics;
   }();
 
+  /* eslint-disable no-param-reassign */
+
+  var itemsPayload = function itemsPayload(item) {
+    var itemObj = {};
+    itemObj.ProductID = item.product_id;
+    itemObj.SKU = item.sku;
+    itemObj.ProductName = item.name;
+    itemObj.Quantity = item.quantity;
+    itemObj.ItemPrice = item.price;
+    itemObj.RowTotal = item.total;
+    itemObj.ProductURL = item.url;
+    itemObj.ImageURL = item.image_url;
+    itemObj.ProductCategories = item.categories;
+    return itemObj;
+  };
+
+  var ecommEventPayload = function ecommEventPayload(event, message) {
+    var payload = {};
+
+    switch (event) {
+      case "Viewed Product":
+        {
+          payload.ProductName = getValue(message, "properties.name");
+          payload.ProductID = getValue(message, "properties.product_id");
+          payload.SKU = getValue(message, "properties.sku");
+          payload.ImageURL = getValue(message, "properties.image_url");
+          payload.URL = getValue(message, "properties.url");
+          payload.Brand = getValue(message, "properties.brand");
+          payload.Price = getValue(message, "properties.price");
+          payload.CompareAtPrice = getValue(message, "properties.compare_at_price");
+          payload.Categories = getValue(message, "properties.categories");
+          break;
+        }
+
+      case "Added to Cart":
+        {
+          payload.$value = getValue(message, "properties.value");
+          payload.AddedItemProductName = getValue(message, "properties.name");
+          payload.AddedItemProductID = getValue(message, "properties.product_id");
+          payload.AddedItemSKU = getValue(message, "properties.sku");
+          payload.AddedItemImageURL = getValue(message, "properties.image_url");
+          payload.AddedItemURL = getValue(message, "properties.url");
+          payload.AddedItemPrice = getValue(message, "properties.price");
+          payload.AddedItemQuantity = getValue(message, "properties.quantity");
+          payload.AddedItemCategories = getValue(message, "properties.categories");
+          payload.ItemNames = getValue(message, "properties.item_names");
+          payload.CheckoutURL = getValue(message, "properties.checkout_url");
+
+          if (message.properties.items && Array.isArray(message.properties.items)) {
+            var itemArr = [];
+            message.properties.items.forEach(function (element) {
+              var item = itemsPayload(element);
+              item = removeUndefinedAndNullValues(item);
+
+              if (isNotEmpty(item)) {
+                itemArr.push(item);
+              }
+            });
+            payload.Items = itemArr;
+          }
+
+          break;
+        }
+
+      case "Started Checkout":
+        {
+          payload.$event_id = getValue(message, "properties.order_id");
+          payload.$value = getValue(message, "properties.value");
+          payload.Categories = getValue(message, "properties.categories");
+          payload.CheckoutURL = getValue(message, "properties.checkout_url");
+          payload.ItemNames = getValue(message, "item_names");
+
+          if (message.properties.items && Array.isArray(message.properties.items)) {
+            var _itemArr = [];
+            message.properties.items.forEach(function (element) {
+              var item = itemsPayload(element);
+              item = removeUndefinedAndNullValues(item);
+
+              if (isNotEmpty(item)) {
+                _itemArr.push(item);
+              }
+            });
+            payload.Items = _itemArr;
+          }
+
+          break;
+        }
+    }
+
+    if (payload) {
+      payload = removeUndefinedAndNullValues(payload);
+    }
+
+    return payload;
+  };
+
   var Klaviyo = /*#__PURE__*/function () {
     function Klaviyo(config) {
       _classCallCheck(this, Klaviyo);
@@ -30465,6 +30600,14 @@
       this.name = "KLAVIYO";
       this.keysToExtract = ["context.traits"];
       this.exclusionKeys = ["email", "E-mail", "Email", "firstName", "firstname", "first_name", "lastName", "lastname", "last_name", "phone", "Phone", "title", "organization", "city", "City", "region", "country", "Country", "zip", "image", "timezone", "anonymousId", "userId", "properties"];
+      this.ecomExclusionKeys = ["name", "product_id", "sku", "image_url", "url", "brand", "price", "compare_at_price", "quantity", "categories", "products", "product_names", "order_id", "value", "checkout_url", "item_names", "items", "checkout_url"];
+      this.ecomEvents = ["product viewed", "product clicked", "product added", "checkout started"];
+      this.eventNameMapping = {
+        "product viewed": "Viewed Product",
+        "product clicked": "Viewed Product",
+        "product added": "Added to Cart",
+        "checkout started": "Started Checkout"
+      };
     }
 
     _createClass(Klaviyo, [{
@@ -30543,14 +30686,33 @@
         var message = rudderElement.message;
 
         if (message.properties) {
-          var propsPayload = message.properties;
+          // ecomm events
+          var event = getValue(message, "event");
+          event = event ? event.trim().toLowerCase() : event;
+
+          if (this.ecomEvents.includes(event)) {
+            var payload = ecommEventPayload(this.eventNameMapping[event], message);
+            var eventName = this.eventNameMapping[event];
+            var customProperties = {};
+            customProperties = extractCustomFields(message, customProperties, ["properties"], this.ecomExclusionKeys);
+
+            if (isNotEmpty(customProperties)) {
+              payload = _objectSpread2(_objectSpread2({}, payload), customProperties);
+            }
 
-          if (propsPayload.revenue) {
-            propsPayload.$value = propsPayload.revenue;
-            delete propsPayload.revenue;
-          }
+            if (isNotEmpty(payload)) {
+              window._learnq.push(["track", eventName, payload]);
+            }
+          } else {
+            var propsPayload = message.properties;
+
+            if (propsPayload.revenue) {
+              propsPayload.$value = propsPayload.revenue;
+              delete propsPayload.revenue;
+            }
 
-          window._learnq.push(["track", message.event, propsPayload]);
+            window._learnq.push(["track", message.event, propsPayload]);
+          }
         } else window._learnq.push(["track", message.event]);
       }
     }, {
@@ -33217,7 +33379,7 @@
     return payload;
   };
 
-  var ecommEventPayload = function ecommEventPayload(event, message) {
+  var ecommEventPayload$1 = function ecommEventPayload(event, message) {
     var payload = {
       price: getValue(message, "properties.price"),
       currency: getValue(message, "properties.currency"),
@@ -33476,31 +33638,31 @@
 
         switch (event.toLowerCase().trim()) {
           case "order completed":
-            sendEvent(this.ecomEvents.PURCHASE, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.PURCHASE, ecommEventPayload$1(event, message));
             break;
 
           case "checkout started":
-            sendEvent(this.ecomEvents.START_CHECKOUT, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.START_CHECKOUT, ecommEventPayload$1(event, message));
             break;
 
           case "product added":
-            sendEvent(this.ecomEvents.ADD_CART, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.ADD_CART, ecommEventPayload$1(event, message));
             break;
 
           case "payment info entered":
-            sendEvent(this.ecomEvents.ADD_BILLING, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.ADD_BILLING, ecommEventPayload$1(event, message));
             break;
 
           case "promotion clicked":
-            sendEvent(this.ecomEvents.AD_CLICK, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.AD_CLICK, ecommEventPayload$1(event, message));
             break;
 
           case "promotion viewed":
-            sendEvent(this.ecomEvents.AD_VIEW, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.AD_VIEW, ecommEventPayload$1(event, message));
             break;
 
           case "product added to wishlist":
-            sendEvent(this.ecomEvents.ADD_TO_WISHLIST, ecommEventPayload(event, message));
+            sendEvent(this.ecomEvents.ADD_TO_WISHLIST, ecommEventPayload$1(event, message));
             break;
 
           default:
@@ -34079,33 +34241,33 @@
   };
 
   // Application class
-  var RudderApp = function RudderApp() {
+  var RudderApp = /*#__PURE__*/_createClass(function RudderApp() {
     _classCallCheck(this, RudderApp);
 
     this.build = "1.0.0";
     this.name = "RudderLabs JavaScript SDK";
     this.namespace = "com.rudderlabs.javascript";
-    this.version = "1.2.10";
-  };
+    this.version = "1.2.15";
+  });
 
   // Library information class
-  var RudderLibraryInfo = function RudderLibraryInfo() {
+  var RudderLibraryInfo = /*#__PURE__*/_createClass(function RudderLibraryInfo() {
     _classCallCheck(this, RudderLibraryInfo);
 
     this.name = "RudderLabs JavaScript SDK";
-    this.version = "1.2.10";
-  }; // Operating System information class
+    this.version = "1.2.15";
+  }); // Operating System information class
 
 
-  var RudderOSInfo = function RudderOSInfo() {
+  var RudderOSInfo = /*#__PURE__*/_createClass(function RudderOSInfo() {
     _classCallCheck(this, RudderOSInfo);
 
     this.name = "";
     this.version = "";
-  }; // Screen information class
+  }); // Screen information class
 
 
-  var RudderScreenInfo = function RudderScreenInfo() {
+  var RudderScreenInfo = /*#__PURE__*/_createClass(function RudderScreenInfo() {
     _classCallCheck(this, RudderScreenInfo);
 
     this.density = 0;
@@ -34113,9 +34275,9 @@
     this.height = 0;
     this.innerWidth = 0;
     this.innerHeight = 0;
-  }; // Device information class
+  }); // Device information class
 
-  var RudderContext = function RudderContext() {
+  var RudderContext = /*#__PURE__*/_createClass(function RudderContext() {
     _classCallCheck(this, RudderContext);
 
     this.app = new RudderApp();
@@ -34153,7 +34315,7 @@
     this.screen = screen;
     this.device = null;
     this.network = null;
-  };
+  });
 
   var RudderMessage = /*#__PURE__*/function () {
     function RudderMessage() {
@@ -35782,14 +35944,6 @@
 
   var lib$2 = Queue;
 
-  // Payload class, contains batch of Elements
-  var RudderPayload = function RudderPayload() {
-    _classCallCheck(this, RudderPayload);
-
-    this.batch = null;
-    this.writeKey = null;
-  };
-
   var queueOptions = {
     maxRetryDelay: 360000,
     minRetryDelay: 1000,
@@ -35797,34 +35951,21 @@
     maxAttempts: 10,
     maxItems: 100
   };
-  var MESSAGE_LENGTH = 32 * 1000; // ~32 Kb
 
-  /**
-   *
-   * @class EventRepository responsible for adding events into
-   * flush queue and sending data to rudder backend
-   * in batch and maintains order of the event.
-   */
-
-  var EventRepository = /*#__PURE__*/function () {
-    /**
-     *Creates an instance of EventRepository.
-     * @memberof EventRepository
-     */
-    function EventRepository(options) {
-      _classCallCheck(this, EventRepository);
+  var XHRQueue = /*#__PURE__*/function () {
+    function XHRQueue() {
+      _classCallCheck(this, XHRQueue);
 
-      this.eventsBuffer = [];
-      this.writeKey = "";
       this.url = "";
-      this.state = "READY";
-      this.batchSize = 0; // previous implementation
-      // setInterval(this.preaparePayloadAndFlush, FLUSH_INTERVAL_DEFAULT, this);
+      this.writeKey = "";
     }
 
-    _createClass(EventRepository, [{
-      key: "startQueue",
-      value: function startQueue(options) {
+    _createClass(XHRQueue, [{
+      key: "init",
+      value: function init(writeKey, url, options) {
+        this.url = url;
+        this.writeKey = writeKey;
+
         if (options) {
           // TODO: add checks for value - has to be +ve?
           _extends(queueOptions, options);
@@ -35833,79 +35974,20 @@
         this.payloadQueue = new lib$2("rudder", queueOptions, function (item, done) {
           // apply sentAt at flush time and reset on each retry
           item.message.sentAt = getCurrentTimeFormatted(); // send this item for processing, with a callback to enable queue to get the done status
+          // eslint-disable-next-line no-use-before-define
 
-          eventRepository.processQueueElement(item.url, item.headers, item.message, 10 * 1000, function (err, res) {
+          this.processQueueElement(item.url, item.headers, item.message, 10 * 1000, // eslint-disable-next-line consistent-return
+          function (err, res) {
             if (err) {
               return done(err);
             }
 
             done(null, res);
           });
-        }); // start queue
+        }.bind(this)); // start queue
 
         this.payloadQueue.start();
       }
-      /**
-       *
-       *
-       * @param {EventRepository} repo
-       * @returns
-       * @memberof EventRepository
-       */
-
-    }, {
-      key: "preaparePayloadAndFlush",
-      value: function preaparePayloadAndFlush(repo) {
-        // construct payload
-        logger.debug("==== in preaparePayloadAndFlush with state: ".concat(repo.state));
-        logger.debug(repo.eventsBuffer);
-
-        if (repo.eventsBuffer.length == 0 || repo.state === "PROCESSING") {
-          return;
-        }
-
-        var eventsPayload = repo.eventsBuffer;
-        var payload = new RudderPayload();
-        payload.batch = eventsPayload;
-        payload.writeKey = repo.writeKey;
-        payload.sentAt = getCurrentTimeFormatted(); // add sentAt to individual events as well
-
-        payload.batch.forEach(function (event) {
-          event.sentAt = payload.sentAt;
-        });
-        repo.batchSize = repo.eventsBuffer.length; // server-side integration, XHR is node module
-
-        if (true) {
-          var xhr = new XMLHttpRequest();
-        } else {
-          var xhr;
-        }
-
-        logger.debug("==== in flush sending to Rudder BE ====");
-        logger.debug(JSON.stringify(payload, replacer));
-        xhr.open("POST", repo.url, true);
-        xhr.setRequestHeader("Content-Type", "application/json");
-
-        {
-          xhr.setRequestHeader("Authorization", "Basic ".concat(btoa("".concat(payload.writeKey, ":"))));
-        } // register call back to reset event buffer on successfull POST
-
-
-        xhr.onreadystatechange = function () {
-          if (xhr.readyState === 4 && xhr.status === 200) {
-            logger.debug("====== request processed successfully: ".concat(xhr.status));
-            repo.eventsBuffer = repo.eventsBuffer.slice(repo.batchSize);
-            logger.debug(repo.eventsBuffer.length);
-          } else if (xhr.readyState === 4 && xhr.status !== 200) {
-            handleError(new Error("request failed with status: ".concat(xhr.status, " for url: ").concat(repo.url)));
-          }
-
-          repo.state = "READY";
-        };
-
-        xhr.send(JSON.stringify(payload, replacer));
-        repo.state = "PROCESSING";
-      }
       /**
        * the queue item proceesor
        * @param {*} url to send requests to
@@ -35947,6 +36029,216 @@
           queueFn(error);
         }
       }
+    }, {
+      key: "enqueue",
+      value: function enqueue(message, type) {
+        var headers = {
+          "Content-Type": "application/json",
+          Authorization: "Basic ".concat(btoa("".concat(this.writeKey, ":"))),
+          AnonymousId: btoa(message.anonymousId)
+        }; // add items to the queue
+
+        this.payloadQueue.addItem({
+          url: "".concat(this.url, "/v1/").concat(type),
+          headers: headers,
+          message: message
+        });
+      }
+    }]);
+
+    return XHRQueue;
+  }();
+
+  var defaults$3 = {
+    queue: "queue",
+    maxPayloadSize: 64 * 1000
+  };
+
+  var BeaconQueue = /*#__PURE__*/function () {
+    function BeaconQueue() {
+      _classCallCheck(this, BeaconQueue);
+
+      this.storage = Store;
+      this.maxItems = 10;
+      this.flushQueueTimeOut = undefined;
+      this.timeOutActive = false;
+      this.flushQueueTimeOutInterval = 1000 * 60 * 10; // 10 mins
+
+      this.url = "";
+      this.writekey = "";
+      this.queueName = "".concat(defaults$3.queue, ".").concat(Date.now());
+    }
+
+    _createClass(BeaconQueue, [{
+      key: "sendQueueDataForBeacon",
+      value: function sendQueueDataForBeacon() {
+        this.sendDataFromQueueAndDestroyQueue();
+      }
+    }, {
+      key: "init",
+      value: function init(writekey, url, options) {
+        this.url = url;
+        this.writekey = writekey;
+        if (options.maxItems) this.maxItems = options.maxItems;
+        if (options.flushQueueInterval) this.flushQueueTimeOutInterval = options.flushQueueInterval;
+        var sendQueueData = this.sendQueueDataForBeacon.bind(this);
+        window.addEventListener("unload", sendQueueData);
+      }
+    }, {
+      key: "getQueue",
+      value: function getQueue() {
+        return this.storage.get(this.queueName);
+      }
+    }, {
+      key: "setQueue",
+      value: function setQueue(value) {
+        this.storage.set(this.queueName, value);
+      }
+      /**
+       *
+       * Utility method for excluding null and empty values in JSON
+       * @param {*} _key
+       * @param {*} value
+       * @returns
+       */
+
+    }, {
+      key: "replacer",
+      value: function replacer(_key, value) {
+        if (value === null || value === undefined) {
+          return undefined;
+        }
+
+        return value;
+      }
+    }, {
+      key: "enqueue",
+      value: function enqueue(message) {
+        var queue = this.getQueue() || [];
+        queue = queue.slice(-(this.maxItems - 1));
+        queue.push(message);
+        var batch = queue.slice(0);
+        var data = {
+          batch: batch
+        };
+        var dataToSend = JSON.stringify(data, this.replacer);
+
+        if (dataToSend.length > defaults$3.maxPayloadSize) {
+          batch = queue.slice(0, queue.length - 1);
+          this.flushQueue(batch);
+          queue = this.getQueue();
+          queue.push(message);
+        }
+
+        this.setQueue(queue);
+        this.setTimer();
+
+        if (queue.length === this.maxItems) {
+          this.flushQueue(batch);
+        }
+      }
+    }, {
+      key: "sendDataFromQueueAndDestroyQueue",
+      value: function sendDataFromQueueAndDestroyQueue() {
+        this.sendDataFromQueue();
+        this.storage.remove(this.queueName);
+      }
+    }, {
+      key: "sendDataFromQueue",
+      value: function sendDataFromQueue() {
+        var queue = this.getQueue();
+
+        if (queue && queue.length > 0) {
+          var batch = queue.slice(0, queue.length);
+          this.flushQueue(batch);
+        }
+      }
+    }, {
+      key: "flushQueue",
+      value: function flushQueue(batch) {
+        batch.map(function (event) {
+          event.sentAt = new Date().toISOString();
+        });
+        var data = {
+          batch: batch
+        };
+        var payload = JSON.stringify(data, this.replacer);
+        var blob = new Blob([payload], {
+          type: "application/json"
+        });
+        var isPushed = navigator.sendBeacon("".concat(this.url, "?writeKey=").concat(this.writekey), blob);
+
+        if (!isPushed) {
+          logger.debug("Unable to send data");
+        }
+
+        this.setQueue([]);
+        this.clearTimer();
+      }
+    }, {
+      key: "setTimer",
+      value: function setTimer() {
+        if (!this.timeOutActive) {
+          this.flushQueueTimeOut = setTimeout(this.sendDataFromQueue.bind(this), this.flushQueueTimeOutInterval);
+          this.timeOutActive = true;
+        }
+      }
+    }, {
+      key: "clearTimer",
+      value: function clearTimer() {
+        if (this.timeOutActive) {
+          clearTimeout(this.flushQueueTimeOut);
+          this.timeOutActive = false;
+        }
+      }
+    }]);
+
+    return BeaconQueue;
+  }();
+
+  var MESSAGE_LENGTH = 32 * 1000; // ~32 Kb
+
+  /**
+   *
+   * @class EventRepository responsible for adding events into
+   * flush queue and sending data to rudder backend
+   * in batch and maintains order of the event.
+   */
+
+  var EventRepository = /*#__PURE__*/function () {
+    /**
+     *Creates an instance of EventRepository.
+     * @memberof EventRepository
+     */
+    function EventRepository() {
+      _classCallCheck(this, EventRepository);
+
+      this.queue = undefined;
+    }
+
+    _createClass(EventRepository, [{
+      key: "initialize",
+      value: function initialize(writeKey, url, options) {
+        var queueOptions = {};
+        var targetUrl = url.slice(-1) === "/" ? url.slice(0, -1) : url;
+
+        if (options && options.useBeacon) {
+          if (options && options.beaconQueueOptions && options.beaconQueueOptions != null && _typeof(options.beaconQueueOptions) === "object") {
+            queueOptions = options.beaconQueueOptions;
+          }
+
+          targetUrl = "".concat(targetUrl, "/beacon/v1/batch");
+          this.queue = new BeaconQueue();
+        } else {
+          if (options && options.queueOptions && options.queueOptions != null && _typeof(options.queueOptions) === "object") {
+            queueOptions = options.queueOptions;
+          }
+
+          this.queue = new XHRQueue();
+        }
+
+        this.queue.init(writeKey, targetUrl, queueOptions);
+      }
       /**
        *
        *
@@ -35958,34 +36250,22 @@
       key: "enqueue",
       value: function enqueue(rudderElement, type) {
         var message = rudderElement.getElementContent();
-        var headers = {
-          "Content-Type": "application/json",
-          Authorization: "Basic ".concat(btoa("".concat(this.writeKey, ":"))),
-          AnonymousId: btoa(message.anonymousId)
-        };
         message.originalTimestamp = getCurrentTimeFormatted();
         message.sentAt = getCurrentTimeFormatted(); // add this, will get modified when actually being sent
         // check message size, if greater log an error
 
         if (JSON.stringify(message).length > MESSAGE_LENGTH) {
           logger.error("[EventRepository] enqueue:: message length greater 32 Kb ", message);
-        } // modify the url for event specific endpoints
-
-
-        var url = this.url.slice(-1) == "/" ? this.url.slice(0, -1) : this.url; // add items to the queue
+        }
 
-        this.payloadQueue.addItem({
-          url: "".concat(url, "/v1/").concat(type),
-          headers: headers,
-          message: message
-        });
+        this.queue.enqueue(message, type);
       }
     }]);
 
     return EventRepository;
   }();
 
-  var eventRepository = new EventRepository();
+  var eventRepository = new EventRepository(); // eslint-disable-next-line import/prefer-default-export
 
   function addDomEventHandlers(rudderanalytics) {
     var handler = function handler(e) {
@@ -36612,6 +36892,131 @@
     return Math.floor(Date.now() / 60000);
   }
 
+  /* eslint-disable class-methods-use-this */
+
+  var OneTrust = /*#__PURE__*/function () {
+    function OneTrust(sourceConfig) {
+      var _this = this;
+
+      _classCallCheck(this, OneTrust);
+
+      this.sourceConfig = sourceConfig; // If user does not load onetrust sdk before loading rudderstack sdk
+      // we will not be filtering any of the destinations.
+
+      if (!window.OneTrust || !window.OnetrustActiveGroups) {
+        logger.debug("Onetrust window objects not retrieved. Thus events are sent.");
+        return true;
+      } // OneTrust Cookie Compliance populates a data layer object OnetrustActiveGroups with
+      // the cookie categories that the user has consented to.
+      // Eg: ',C0001,C0003,'
+      // We split it and save it as an array.
+
+
+      var userSetConsentGroupIds = window.OnetrustActiveGroups.split(","); // Ids user has consented
+      // Get information about the cookie script - data includes, consent models, cookies in preference centre, etc.
+      // We get the groups(cookie categorization), user has created in one trust account.
+
+      var oneTrustAllGroupsInfo = window.OneTrust.GetDomainData().Groups;
+      this.userSetConsentGroupNames = []; // Get the names of the cookies consented by the user in the browser.
+
+      oneTrustAllGroupsInfo.forEach(function (group) {
+        var CustomGroupId = group.CustomGroupId,
+            GroupName = group.GroupName;
+
+        if (userSetConsentGroupIds.includes(CustomGroupId)) {
+          _this.userSetConsentGroupNames.push(GroupName.toUpperCase().trim());
+        }
+      });
+    }
+
+    _createClass(OneTrust, [{
+      key: "isEnabled",
+      value: function isEnabled(destConfig) {
+        var _this2 = this;
+
+        try {
+          /**
+          * Structure of onetrust consent group destination config.
+          * 
+          * "oneTrustConsentGroup": [
+                            {
+                                "oneTrustConsentGroup": "Performance Cookies"
+                            },
+                            {
+                                "oneTrustConsentGroup": "Functional Cookies"
+                            },
+                            {
+                                "oneTrustConsentGroup": ""
+                            }
+                        ]
+          *
+          */
+          var oneTrustCookieCategories = destConfig.oneTrustCookieCategories; // mapping of the destination with the consent group name
+          // If the destination do not have this mapping events will be sent.
+
+          if (!oneTrustCookieCategories) {
+            return true;
+          } // Change the structure of oneTrustConsentGroup as an array and filter values if empty string
+          // Eg:
+          // ["Performance Cookies", "Functional Cookies"]
+
+
+          var oneTrustConsentGroupArr = oneTrustCookieCategories.map(function (c) {
+            return c.oneTrustCookieCategory;
+          }).filter(function (n) {
+            return n;
+          });
+          var containsAllConsent = true; // Check if all the destination's mapped cookie categories are consented by the user in the browser.
+
+          containsAllConsent = oneTrustConsentGroupArr.every(function (element) {
+            return _this2.userSetConsentGroupNames.includes(element.toUpperCase().trim());
+          });
+          return containsAllConsent;
+        } catch (e) {
+          logger.error("Error during onetrust cookie consent management ".concat(e));
+          return true;
+        }
+      }
+    }]);
+
+    return OneTrust;
+  }();
+
+  var CookieConsentFactory = /*#__PURE__*/function () {
+    function CookieConsentFactory() {
+      _classCallCheck(this, CookieConsentFactory);
+    }
+
+    _createClass(CookieConsentFactory, null, [{
+      key: "initialize",
+      value: function initialize(sourceConfig, cookieConsentOptions) {
+        var _cookieConsentOptions;
+
+        /**
+         *
+         * check which type of cookie consent manager needs to be called if enabled
+         * for now we have only OneTrust.
+         * But if new cookie consent manager options are implemented,
+         * we need to make sure only one of them is enabled by the user in the
+         * load options
+         *
+         */
+        if (cookieConsentOptions !== null && cookieConsentOptions !== void 0 && (_cookieConsentOptions = cookieConsentOptions.oneTrust) !== null && _cookieConsentOptions !== void 0 && _cookieConsentOptions.enabled) {
+          // This is P1. When we have an ui in source side to turn on/off of cookie consent
+          // if (sourceConfig &&
+          //     sourceConfig.cookieConsentManager &&
+          // sourceConfig.cookieConsentManager.oneTrust &&
+          // sourceConfig.cookieConsentManager.oneTrustenabled) {
+          return new OneTrust(); // }
+        }
+
+        return null;
+      }
+    }]);
+
+    return CookieConsentFactory;
+  }();
+
   var queryDefaults = {
     trait: "ajs_trait_",
     prop: "ajs_prop_"
@@ -36671,6 +37076,7 @@
       };
       this.loaded = false;
       this.loadIntegration = true;
+      this.cookieConsentOptions = {};
     }
     /**
      * initialize the user after load config
@@ -36742,10 +37148,20 @@
           }, this);
           logger.debug("this.clientIntegrations: ", this.clientIntegrations); // intersection of config-plane native sdk destinations with sdk load time destination list
 
-          this.clientIntegrations = findAllEnabledDestinations(this.loadOnlyIntegrations, this.clientIntegrations); // remove from the list which don't have support yet in SDK
+          this.clientIntegrations = findAllEnabledDestinations(this.loadOnlyIntegrations, this.clientIntegrations);
+          var cookieConsent = undefined; // Check if cookie consent manager is being set through load options
+
+          if (Object.keys(this.cookieConsentOptions).length) {
+            // Call the cookie consent factory to initialise and return the type of cookie
+            // consent being set. For now we only support OneTrust.
+            cookieConsent = CookieConsentFactory.initialize(response, this.cookieConsentOptions);
+          } // If cookie consent object is return we filter according to consents given by user
+          // else we do not consider any filtering for cookie consent.
+
 
           this.clientIntegrations = this.clientIntegrations.filter(function (intg) {
-            return integrations[intg.name] != undefined;
+            return integrations[intg.name] != undefined && (!cookieConsent || // check if cookieconsent object is present and then do filtering
+            cookieConsent && cookieConsent.isEnabled(intg.config));
           });
           this.init(this.clientIntegrations);
         } catch (error) {
@@ -37409,6 +37825,7 @@
         var _this3 = this;
 
         logger.debug("inside load ");
+        if (options && options.cookieConsentManager) this.cookieConsentOptions = lodash_clonedeep(options.cookieConsentManager);
         if (this.loaded) return;
         var configUrl = CONFIG_URL;
 
@@ -37419,16 +37836,26 @@
           throw Error("failed to initialize");
         }
 
+        var storageOptions = {};
+
         if (options && options.logLevel) {
           logger.setLogLevel(options.logLevel);
         }
 
         if (options && options.setCookieDomain) {
-          this.storage.options({
+          storageOptions = _objectSpread2(_objectSpread2({}, storageOptions), {}, {
             domain: options.setCookieDomain
           });
         }
 
+        if (options && options.secureCookie) {
+          storageOptions = _objectSpread2(_objectSpread2({}, storageOptions), {}, {
+            secure: options.secureCookie
+          });
+        }
+
+        this.storage.options(storageOptions);
+
         if (options && options.integrations) {
           _extends(this.loadOnlyIntegrations, options.integrations);
 
@@ -37465,22 +37892,11 @@
           this.registerCallbacks(true);
         }
 
-        if (options && options.queueOptions && options.queueOptions != null && _typeof(options.queueOptions) == "object") {
-          this.eventRepository.startQueue(options.queueOptions);
-        } else {
-          this.eventRepository.startQueue({});
-        }
-
         if (options && options.loadIntegration != undefined) {
           this.loadIntegration = !!options.loadIntegration;
         }
 
-        this.eventRepository.writeKey = writeKey;
-
-        if (serverUrl) {
-          this.eventRepository.url = serverUrl;
-        }
-
+        this.eventRepository.initialize(writeKey, serverUrl, options);
         this.initializeUser();
         this.setInitialPageProperties();
         this.loaded = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rudder-sdk-js",
-  "version": "1.2.10",
+  "version": "1.2.15",
   "description": "RudderStack Javascript SDK",
   "main": "index.js",
   "types": "index.d.ts",